最大子陣列和問題的解

尋找陣列A的和最大的非空連續子陣列。例如：A[] = {1, -2, 3, 10, -4, 7, 2, -5}的最大子陣列為3, 10, -4, 7, 2，其最大和為18。陣列元素都為負時，返回最大負值。

解法一：暴力列舉，O(N^2)

//left,最大子陣列左端
//right,最大子陣列右端
//n陣列arr元素個數
const int IntMin = (signed int)0x80000000;
int MaxSum(int *arr, int &left, int &right, int n)
{
    if (!arr || n <= 0) {
        left = -1;
        right = -1;
        return IntMin;
    }

    int maxSum = IntMin;
    for (int i = 0; i < n; ++i) {
        int sum = 0;
        for (int j = i; j < n; ++j) {
            sum += arr[j];
            if (sum > maxSum) {
                left = i;
                right = j;
                maxSum = sum;
            }
        }
    }
    return maxSum;
}

解法二：分治，O(NlogN)

尋找陣列A[low…high]的最大子陣列時，將陣列劃分為兩個規模儘可能相等的子陣列 A[low…mid]和A[mid+1…high]。

A[low…high]的任何連續子陣列A[i…j]所處的位置必然是三種情況之一：

（1）完全位於子陣列A[low..mid]中，因此low<=i<=j<=mid; 

（2）完全位於子陣列A[mid + 1..high]中，因此mid<=i<=j<=high;

（3）跨越了中點，因此low<=i<=mid<j<=high;

A[low…high]的一個最大子陣列必然是完全位於A[low…mid]中、完全位於A[mid+1…high]中或者跨越中點的所有子陣列中和最大者。

//left和right是返回值,未初始化,不能直接使用
const int IntMin = (signed int)0x80000000;
int MaxSumCross(int *arr, int &left, int mid, int &right, int n)
{
    if (arr == NULL) {
        left = -1;
        right = -1;
        return IntMin;
    }

    int lmaxSum = IntMin;
    int sum = 0;
    for (int i = mid; i >= 0; --i) {
        sum += arr[i];
        if (sum > lmaxSum) {
            left = i;
            lmaxSum = sum;
        }
    }

    int rmaxSum = IntMin;
    sum = 0;
    for (int i = mid + 1; i < n; ++i) {
        sum += arr[i];
        if (sum > rmaxSum) {
            right = i;
            rmaxSum = sum;
        }
    }
    return lmaxSum + rmaxSum;
}

int MaxSum(int *arr, int &left, int &right, int n)
{
    if (!arr || left > right || n <= 0) {
        left = -1;
        right = -1;
        return IntMin;
    }
    if (left == right) 
        return arr[left];

    //lleft,lright左子陣列的左端,右端
    //rleft,rright右子陣列的左端,右端
    //mleft,mright中間子陣列的左端,右端
    int mid = left + (right - left) / 2;
    int lleft = left, lright = mid;
    int rleft = mid + 1, rright = right;
    int mleft, mright;
    int leftSum = MaxSum(arr, lleft, lright, n);
    int midSum = MaxSumCross(arr, mleft, mid, mright, n);
    int rightSum = MaxSum(arr, rleft, rright, n);

    if (leftSum >= rightSum && leftSum >= midSum) {
        left = lleft;
        right = lright;
        return leftSum;
    } else if (rightSum >= leftSum && rightSum >= midSum) {
        left = rleft;
        right = rright;
        return rightSum;
    } else if (midSum >= leftSum && midSum >= rightSum) {
        left = mleft;
        right = mright;
        return midSum;
    }
}

解法三：動態規劃，O(N)

int MaxSum(int *arr, int &left, int &right, int n)
{
    if (!arr || n <= 0) {
        left = -1;
        right = -1;
        return IntMin;
    }

    int nAll = arr[n - 1];
    int nStart = arr[n - 1];
    left = 0;
    right = n - 1;
    for (int i = n - 2; i >= 0; --i) {
        if (nStart < 0) {
            right = i;
            nStart = 0;
        }
        nStart += arr[i];
        if (nStart > nAll) {
            left = i;
            nAll = nStart;
        }
    }
    return nAll;
}