算法之 数组的“距离”

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谁先到达，都不会错过最优解，于是上述算法是正确的。