最大子数组和问题的解

寻找数组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;
}