面試題：給定陣列a，找到最大的j-i, 使a[j]>a[i]

OpenSoucre發表於2014-08-05
面試題陣列

第一種方法：

　　用兩重迴圈對每對點都試一下，然後取最大值即可，時間複雜度為O(n2)

#include <iostream>
#include <algorithm>
using namespace std;

int maxIndexDiff(int a[],int n){
    int maxDiff = -1;
    for(int i = 0 ; i <  n; ++ i){
        for(int j =n-1; j > i ; --j){
            if(a[j]>a[i]) maxDiff = max(maxDiff,j-i);
        }
    }
    return maxDiff;
}

int main(){
    int a[]={9,2,3,4,5,6,7,8,18,0};
    int n = sizeof(a)/sizeof(a[0]);
    int maxDiff = maxIndexDiff(a,n);
    cout<<maxIndexDiff(a,n)<<endl;
}
時間複雜度O(N^2)

第二種方法:

　　首先對陣列按照高度排序從小到大排序，如果高度相等的話，按照索引從小到大排序。

　　此時只需要在右邊找一個索引值j，在左邊找一個索引值i，使j-i最大即可。

　　可以建立一個rightMax陣列，記錄下每個索引右邊的最大值，注意從右邊往左邊掃描，計算右邊最大值簡單些。

　　然後將當前的rightMax與排序後原始索引作差取最大值即可。時間複雜度O(nlogn)

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

struct node{
    int index;
    int height;
    node(int idx = 0, int h = 0):index(idx),height(h){}
    bool operator<(const node& a) const{
        if(height!=a.height) return height < a.height;
        else return index < a.index;
    }
};

int maxIndexDiff(int a[],int n){
    vector<node> b(n);
    for(int i = 0 ; i < n ; ++ i) {b[i].index = i;b[i].height = a[i];}
    sort(b.begin(),b.end());
    vector<int> rightMax(n,b[n-1].index);
    rightMax[n-1]=b[n-1].index;
    for(int i = n -2; i>=0; -- i){
        if(b[i].index > rightMax[i+1]) rightMax[i] = b[i].index;
        else rightMax[i]=rightMax[i+1];
    }
    int maxDiff = -1;
    for(int i = 0 ; i< n ; ++ i){
        maxDiff = max(maxDiff,rightMax[i]-b[i].index);
    }
    return maxDiff;
}

int main(){
    int a[]={9,2,3,4,5,6,7,8,18,0};
    int n = sizeof(a)/sizeof(a[0]);
    int maxDiff = maxIndexDiff(a,n);
    cout<<maxIndexDiff(a,n)<<endl;
}
時間複雜度O(nlogn)

　　還有一種方法是利用二分查詢，注意j-i的值必定在0~n-1之間（索引是從0開始的）

　　取中間一個值mid=(0+n-1)/2，

　　　　如果存在a[i+mid]>a[i]，則必然j-i至少是mid，繼續向上二分查詢

　　　　否則，j-i不超過mid，則向下二分查詢　　

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

bool exist(int a[],int n, int k){
    for(int i = 0 ; i+k< n; ++ i){
        if(a[i] < a[i+k]) return true;
    }
    return false;
    
}

int maxIndexDiff(int a[],int n){
    int left = 0, right = n-1; 
    while(left <= right){
        int mid = (left+right)/2;
        if(exist(a,n,mid)) left=mid+1;
        else right = mid-1;
    }
    return right;
}

int main(){
    int a[]={9,2,3,4,5,6,7,8,18,0};
    int n = sizeof(a)/sizeof(a[0]);
    int maxDiff = maxIndexDiff(a,n);
    cout<<maxIndexDiff(a,n)<<endl;
}
時間複雜度O(nlogn)

第三種方法：

　　從左向右掃描一遍，記錄每個索引左邊的最小值（包括自己），leftMin[0..n-1]

　　從右向左掃描一遍，記錄每個索引右邊的最大值（包括自己），rightMax[0..n-1]

　　要注意的是：

　　對於leftMin[i]，其左邊的leftMin[0..i-1]都大於等於leftMin[i]，其右邊的left[i+1..n-1]都小於leftMin[i]

　　對於rightMax[j]，其左邊的rightMax[0..j-1]都大於等於rightMax[j]，其右邊的rightMax[j+1..n-1]都小於rightMax[j]

　　對於leftMin[i] 和rightMax[j]

　　如果leftMin[i]<rightMax[j]，說明j的右邊還可能存在值使rightMax>leftMin，記錄當前的j-i，使++j

　　否則leftMin[i]>=rightMax[j], 則i的左邊肯定都比rightMax[j]大，要增大++i，　　

#include <iostream>
#include <algorithm>
#include <vector>
#include <climits>
using namespace std;

int maxIndexDiff(int a[],int n){
    vector<int> leftMin(n,a[0]),rightMax(n,a[n-1]);
    for(int i = 1; i < n; ++i ) leftMin[i] = min(a[i],leftMin[i-1]);
    for(int i = n-2; i>=0; -- i) rightMax[i] = max(a[i],rightMax[i+1]);
    int i = 0, j= 0, maxDiff = -1;
    while(i<n && j<n){
        if(leftMin[i]<rightMax[j]){
            maxDiff = max(maxDiff,j-i);
            j++;
        }else ++i;
    }
    return maxDiff;
}

int main(){
    int a[]={9,2,3,4,5,6,7,8,18,0};
    int n = sizeof(a)/sizeof(a[0]);
    int maxDiff = maxIndexDiff(a,n);
    cout<<maxIndexDiff(a,n)<<endl;
}
時間複雜度O(n)

 

相關文章