Description:
给定数组A[0---n-1]，找出数组中的max(j - i),其中 i< j && A[i] < A[j].这里的最大的（j-i）的值就是数组的“距离”。
方法一：直接枚举，O(n^2).
方法二：伴随数组 + 排序， O(n*logn)
此处的伴随数组的定义是： A ： 3 2 1 4 那么数组A 的伴随数组即是
A ： 3 2 1 4
index： 0 1 2 3 伴随数组即为 ［（3，0），（2，1），（1，2），（4，3）］其中元素为pair。
接着，对排序之后的数组首先进行预处理，如下：
A ： 4 3 2 5 1 3 2 3 == 》 A ： 1 2 2 3 3 3 4 5 == 》 A ： 1 2 2 3 3 3 4 5
index ： 0 1 2 3 4 5 6 7 == 》 index： 4 3 6 1 5 7 0 2 == 》 index： 7 7 7 7 7 7 2 2
注意：此处必须考虑数组中的元素可能有相同的，也就是在更新j-i的值的时候必须考虑此时的A[i] 与A[j]是否相等。
方法3： O(N)
A : 4 3 5 2 1 3 2 3
lMin : 4 3 3 2 1 1 1 1 lMin[i] : A[0...i]的最小值
rMax : 5 5 5 3 3 3 3 3 rMax[i] : A[j...n-1]的最大值
代码为：
//O(N^2)
int maxIJ1(const vector<int> &A)
{
const int n = A.size();
if(n<2) return -1;
int maxdiff=0;
for(int i=0; i<n; ++i)
{
for(int j=n-1;j>i;--j)
{
//maxdiff=max(maxdiff,j-i);
if((A[j]>A[i]) && (j-i)>maxdiff)
{
maxdiff=j-i;
break;
}
}
}
return maxdiff;
}
//O(N*logN)
int maxIJ2(const vector<int> &A)
{
const int n = A.size();
if(n<2) return -1;
typedef pair<int,int> P;
vector<P> tmp(n);
for(int i=0;i<n;++i)
tmp[i]=make_pair(A[i],i);
sort(tmp.begin(), tmp.end());
//preprocessing the index
vector<int> rMaxIndex(n,0);
rMaxIndex[n-1]=tmp[n-1].second;
for(int i=n-2;i>=0;--i)
rMaxIndex[i]=max(rMaxIndex[i+1],tmp[i].second);
int maxdiff=0;
for(int i=0;i<n;++i)
{
int left=tmp[i].second;
int right=rMaxIndex[i];
assert(A[left]<=A[right]);
if(A[left]!=A[right] && (right-left)>maxdiff) //必须首先判断是否相等。用来处理数组中有相同的元素的情况
maxdiff=right-left;
}
return maxdiff;
}
//O(N)
int maxIJ(const vector<int> &A)
{
const int n = A.size();
if(n<2) return -1;
vector<int> lMin(n,0),rMax(n,0);
lMin[0]=A[0];
rMax[n-1]=A[n-1];
for(int i=1; i<n; ++i)
lMin[i] = min(lMin[i-1],A[i]);
for(int i=n-2; i>=0; --i)
rMax[i] = max(rMax[i+1],A[i]);
int maxdiff=0;
int i=0,j=0;
while(i<n && j<n)
{
if(lMin[i]<rMax[j])
{
maxdiff=max(maxdiff,j-i);
j++;
}
else
{
++i;
}
}
return maxdiff;
}
关于O（N）的算法的正确性的证明：
Obeservation： lMin与rMax都是非递增的。
假设i*,j*是最优解，分两种情况讨论：
1 假设i先到达i*,j还没到，则此时如果i还要再移动的话，那么也就是说lMin[i]>rMax[j],又由于rMax的非递增，rMax[j]>=rMax[j*],则
lMin[i*]>rMax[j]>rMax[j*],与i*,j*是最优解矛盾。
2 假设j先到达j*，i还未到，（那么我们此时要证明的是j不会再移动了），如果j此时要移动的话，那么lMin[i]<rMax[j*],又由于i*与j*是最优解，那么就一定有lMin[i*]<rMax[j*],此时我们将i*换做i可以得到更优的解，与假设矛盾。
因此，无论ij谁先到达，都不会错过最优解，于是上述算法是正确的。