Question

给定一个整数数组arr []，找出任意两个元素之间的差异，以便在arr []中较小的数字后出现较大的元素。

Max Difference = Max { arr[x] - arr[y] | x > y }

示例：

如果数组为[2, 3, 10, 6, 4, 8, 1, 7]，则返回的值应为8（10和2之间的差异）。
如果数组为[ 7, 9, 5, 6, 3, 2 ]，则返回的值应为2（7到9之间的差异）

我的算法：

我想过使用D＆amp; C算法。解释

2, 3, 10, 6, 4, 8, 1, 7

then

2,3,10,6      and     4,8,1,7

then

2,3  and 10,6  and  4,8 and 1,7

then

2 and 3   10 and 6   4 and 8    1 and 7

这里因为这些元素将保持相同的顺序，我将得到最大的差异，这里是6。

现在我将回到merege这些数组并再次找到第一个块的最小值和第二个块的最大值之间的差异，并继续这样做直到结束。

我无法在我的代码中实现此功能。任何人都可以为此提供伪代码吗？

Answer 1

我们有max { A[i] - A[j] | i > j } = max { A[i] - min { A[j] | j < i } | i }，它会产生一个简单的O（n）算法：

prefix_min = A[0]
result = -infinity
for i := 1 to n - 1:
    # invariant: We have prefix_min = min { A[j] | j < i }
    result = max(result, A[i] - prefix_min)
    prefix_min = min(prefix_min, A[i])

划分＆amp;征服在概念上更复杂，但也导致线性时间解决方案（具有更高的常数因子）。

Answer 2

假设你想找到最大的差异LD（A []）

根据需要完成Psuedocode：

将数组分为A1 []和A2 []两部分。

Find minimum & maximum element in A1[] and LD(A1).
Find minimum & maximum element in A2[] and LD(A2).

LD(A) = max( LD(A1), LD(A2), MAX(A2) - MIN(A1) )
MAX(A) = max( MAX(A1), MAX(A2) )
MIN(A) = min( MIN(A1), MIN(A2) )

基本案例（length(A) == 2）：

If A[1] > A[0], 
  LD(A) = A[1] - A[0].
  MAX(A) = A[1]
  MIN(A) = A[0]
else
  LD(A) = 0.
  MAX(A) = A[0]
  MIN(A) = A[1]

注意：

If (length(A) == 1)
    LD(A) = 0
    MIN(A) = MAX(A) = A[0]

同样，您可以计算每个子阵列中的最小和最大元素。

Answer 3

下面是使用Divide and Conquer的C中的代码 PLZ。请随意发表评论。

#include <stdio.h>

struct data{
    int min_;
    int max_;
};

struct data crossminmax(int *p,int lo,int mid,int hi){
    int i,min,max;
    struct data temp;

    min = p[mid];
    for(i=mid;i>=lo;i--){
        if(p[i] < min){
            min = p[i];
        }
    }

    max = p[mid+1];
    for(i=mid+1;i<=hi;i++){
        if(p[i] > max){
            max = p[i];
        }
    }
    temp.min_ = min;
    temp.max_ = max;
    return temp;
}

/* MinMax calculates the difference between Biggest and Smallest element  *
 * of an array using divide and conquer principles such that the position * 
 * of Biggest element is always greater than the Samllest element         */

struct data minmax(int *p,int lo,int hi){
    int mid,leftdiff,rightdiff,crossdiff;
    struct data left,right,cross,temp;

    if(lo == hi){
        temp.min_ = p[lo];
        temp.max_ = p[hi];
        return temp;
    }

    mid = (lo+hi)/2;
    left = minmax(p,lo,mid);
    right = minmax(p,mid+1,hi);

    cross = crossminmax(p,lo,mid,hi);
    leftdiff = left.max_ - left.min_;
    rightdiff = right.max_ - right.min_;
    crossdiff = cross.max_ - cross.min_;

    if(leftdiff > rightdiff && leftdiff > crossdiff){
        return left;
    }else if(rightdiff > crossdiff){
        return right;
    }else{
        return cross;
    }
}

int main(){
    int arr[] = {5,2,3,10,1,3,16,4,3};
    struct data dt;
    dt = minmax(arr,0,8);
    printf("Max difference = %d, Max Element=%d, Min Element = %d  \n",dt.max_ - dt.min_,dt.max_,dt.min_);
    return 0;
}

Answer 4

数组中最大的差异

condition : - larger number should appear after smaller number
{ 10, 3, 6, 4, 8, 1, 7 }     6
{ 2, 3, 10, 6, 4, 8, 1 }     8
{ 7, 9, 5, 6, 3, 2 }         1
{ 1, 2, 3, 4 }               3
{ 4, 3, 2, 1  }              0



#include<stdio.h>
int main(){
  int n = 7;
  int arr[7] = { 10, 3, 6, 14, 8, 1, 7 };

  int i;
  int max_diff = 0;
  int min = arr[0];

  for( i=0; i<n; i++){
    if( (arr[i] - min) > max_diff ){
      max_diff = arr[i] - min;
    }

    if(arr[i] < min){
      min = arr[i];
    }
  }
  printf("max diff = %d", max_diff);

  return 0;
}

//时间复杂度O（n）

//空间复杂度O（1）

为了更好地理解，请访问https://www.youtube.com/watch?v=thPG6eTPf68&t=130s

划分和征服Algo以找到两个有序元素之间的最大差异

4 个答案: