Question

这是一个亚马逊采访问题。我已经使用动态解决了O（n）中的这个问题编程。但是我想知道可以有比 O（n）

更多的优化

例如假设下面是数组

3 7 1 4 2 4 returns 4

5 4 3 2 1 returns Nothing

4 3 2 2 3 returns 1

这是我编写的代码Code

Answer 1

让我们说你有int A[N]。

int res = -1;
int min_value = A[0];
for(int i=1; i<N; i++) {
    // A[i] - A[j] is maximal, when A[j] is minimal value from {A[0], A[1],.., A[i-1]}
    res = max(res, A[i] - min_value);
    min_value = min(min_value, A[i]);
}
return res;

复杂度O（N）。

你需要检查N个元素，所以O（N）是最好的。

Answer 2

但我想知道可以有更多的优化，然后O（n）

任何n元素都可以作为解决方案的一部分，因此每个元素都需要进行检查。因此，O(n)无法改进。

为了完整起见，这是一个需要O(n)时间且需要O(1)内存的解决方案：

A = [1, 10, 20, -10, 3, 4, 18, 42, 15]

smallest = A[0]
maxdiff = float('-inf')
for x in A[1:]:
  maxdiff = max(maxdiff, x - smallest)
  smallest = min(smallest, x)
print maxdiff

Answer 3

它不能比O（n）做得更好，因为无论你使用什么方法，你都必须至少迭代一次数组，而这个步骤本身就是O（n）。休息战斗只是为了尽量减少常数。

Answer 4

public static int maxOrderedDiff(int[] A){
    //A[x]-A[y] | x>y
    int min = 0, max = 0;
    int less = 0;
    for(int i=1; i<A.length; i++){
        if(A[less]>A[i]){
            less = i;
        }
        if(A[i]-A[min]>A[max]-A[min] || A[i]-A[less] >A[max]-A[min]){
            max=i;
            if(A[less]<A[min])
                min = less;
        }
    }

    return max>min? A[max]-A[min]: -1;
}//maxOrderedDiff

测试：

public static void main(String[] args){
    int[][] A = {{3, 7, 1, 4, 2, 4},{5, 4, 3, 2,1},{4, 3, 2, 2, 3}};

    for(int[] B: A)
        System.out.format("%s :: %d%n", Arrays.toString(B), maxOrderedDiff(B));
}

给定未排序的数组，找到A [j] - A [i]的最大值，其中j> i..in O（n）时间

4 个答案: