LintCode 402 Continuous Subarray Sum (求连续序列最大和 - 经典问题！！！)

402. Continuous Subarray Sum

Given an integer array, find a continuous subarray where the sum of numbers is the biggest. Your code should return the index of the first number and the index of the last number. (If their are duplicate answer, return the minimum one in lexicographical order)

Example
Example 1:

Input: [-3, 1, 3, -3, 4]
Output: [1, 4]
Example 2:

Input: [0, 1, 0, 1]
Output: [0, 3]
Explanation: The minimum one in lexicographical order.

这题就是求序列连续最大和问题。类似 LintCode 41 · Maximum Subarray。不过这里需要记下max subarray的range。
LintCode 41 的代码如下：

class Solution {
public:
    /**
     * @param nums: A list of integers
     * @return: A integer indicate the sum of max subarray
     */
    int maxSubArray(vector<int> &nums) {
        int n = nums.size();
        int sum = INT_MIN, maxSum = INT_MIN;
        for (int i = 0; i < n; i++) {
            if (sum < 0) {
                sum = nums[i];
            } else {
                sum += nums[i];
            }
            maxSum = max(sum, maxSum);
        }
        return maxSum;
    }
};

注意：输入数组有负数，

解法1：代码如下：

class Solution {
public:
    /*
     * @param A: An integer array
     * @return: A list of integers includes the index of the first number and the index of the last number
     */
    vector<int> continuousSubarraySum(vector<int> &A) {
        int n = A.size();
        if (n == 0) return vector<int>();
        int sum = 0, maxSum = 0;
        int startIndex = 0, endIndex = 0;
        int gStartIndex = 0, gEndIndex = 0;
        sum = A[0]; maxSum = A[0];
        for (int i = 1; i < n; ++i) {
            if (sum < 0) {
                sum = A[i];
                startIndex = i;
                endIndex = i;
            } else {
                sum += A[i];
                endIndex = i;
            } 
            
            if (maxSum < sum) {
                maxSum = sum;
                gStartIndex = startIndex;
                gEndIndex = endIndex;
            }
        }
        return vector<int>{gStartIndex, gEndIndex};
    }
};

二刷：

class Solution {
public:
    /**
     * @param a: An integer array
     * @return: A list of integers includes the index of the first number and the index of the last number
     */
    vector<int> continuousSubarraySum(vector<int> &a) {
        vector<int> res;
        int n = a.size();
        int sum = 0, start = 0, end = 0;
        int maxSum = INT_MIN, maxStart = 0, maxEnd = 0;
        int index = 0;
        for (int i = 0; i < n; i++) {
            sum += a[i];
            if (sum > maxSum) {
                maxSum = sum;
                maxStart = start;
                maxEnd = i;
            }
            if (sum < 0) {
                sum = 0;
                start = i + 1;
            }
        }
        return {maxStart, maxEnd};
    }
};

写成这样也可以

class Solution {
public:
    /**
     * @param a: An integer array
     * @return: A list of integers includes the index of the first number and the index of the last number
     */
    vector<int> continuousSubarraySum(vector<int> &a) {
        vector<int> res;
        int n = a.size();
        int sum = 0, start = 0, end = 0;
        int maxSum = INT_MIN, maxStart = 0, maxEnd = 0;
        int index = 0;
        for (int i = 0; i < n; i++) {
            if (sum < 0) {
                sum = a[i];
                start = i;
            }
            else sum += a[i];
            if (sum > maxSum) {
                maxSum = sum;
                maxStart = start;
                maxEnd = i;
            }
        }
        return {maxStart, maxEnd};
    }
};

注意:

1. 如果再加一个条件，即求固定长度的连续序列的最大和，则上述解法不适用，必须用sliding window或deque，详见LintCode 558.
   https://blog.csdn.net/roufoo/article/details/88772574
2. 如果条件变成循环数组求连续序列的最大和(即LintCode 403)，则上述解法不能直接套用。也不好直接将数组复制成2n大小求长度<=n的连续序列最大和。这里因为长度不定，也不能用1)的sliding window解法。最好的方法是还是针对原n长度的数组求连续序列最大和S1与最小和S2，然后答案即为max{S1, total_sum – S2}，但还有一个特殊情况即当S2的情况是整个数组时，说明所有元素都为负，此时选最大的元素(即绝对值最小的负数)即可。详见LintCode 403
   https://blog.csdn.net/roufoo/article/details/88664894

解法2：滑动窗口。注意：以前我以为有负数的情况就不能用滑动窗口。这种想法是错误的！
有负数的情况照样可以用滑动窗口。

class Solution {
public:
    /**
     * @param a: An integer array
     * @return: A list of integers includes the index of the first number and the index of the last number
     */
    vector<int> continuousSubarraySum(vector<int> &a) {
        int n = a.size();
        int left = 0, right = 0;
        int sum = 0, start = 0;
        int maxSum = INT_MIN, maxLeft = 0, maxRight = 0;
        while (right < n) {
            sum += a[right];
            if (maxSum < sum) {
                maxSum = sum;
                maxLeft = left;
                maxRight = right;
            }
            right++;
            while (sum < 0) {
                sum -= a[left];
                left++;
            }
        }
        return {maxLeft, maxRight};
    }
};

解法3：用前缀和数组。非常拖沓冗长，不简洁。

class Solution {
public:
    /**
     * @param a: An integer array
     * @return: A list of integers includes the index of the first number and the index of the last number
     */
    vector<int> continuousSubarraySum(vector<int> &a) {
        int n = a.size();
        if (n == 0) return {};
        vector<int> presums(n, 0);
        presums[0] = a[0];
        for (int i = 1; i < n; i++) {
            presums[i] = presums[i - 1] + a[i];
        }
        //类似股票最优购买时间问题。但还要考虑数组元素自身。
        int minV = presums[0], minVIndex = 0; //
        int maxDiff = presums[0], maxDiffStart = 0, maxDiffEnd = 0;
        for (int i = 1; i < n; i++) {
            if (presums[i] < minV) {
                minV = presums[i];
                minVIndex = i;
            }
            if (i != minVIndex) {
                if (maxDiff < presums[i] - minV) {
                    maxDiff = presums[i] - minV;
                    maxDiffStart = minVIndex + 1; //注意：这里的minVIndex刚好比a[]里面的index大1，这正是我们需要的，因为Presums的index也是加了1。
                    maxDiffEnd = max(i, maxDiffStart);
                }
            } else {
                if (maxDiff < a[i]) {
                    maxDiff = a[i];
                    maxDiffStart = i;
                    maxDiffEnd = i;
                }
            }
            if (maxDiff < presums[i]) {
                maxDiff = presums[i];
                maxDiffStart = 0;
                maxDiffEnd = i;
            }
        }
        return {maxDiffStart, maxDiffEnd};
    }
};

简化presum数组后代码如下:

class Solution {
public:
    /**
     * @param a: An integer array
     * @return: A list of integers includes the index of the first number and the index of the last number
     */
    vector<int> continuousSubarraySum(vector<int> &a) {
        int n = a.size();
        if (n == 0) return {};
        int presum = a[0];
        //类似股票最优购买时间问题
        int minPresum = presum, minPresumIndex = 0; //
        int maxDiff = presum, maxDiffStart = 0, maxDiffEnd = 0;
        for (int i = 1; i < n; i++) {
            presum += a[i];
            if (presum < minPresum) {
                minPresum = presum;
                minPresumIndex = i;
            }
            if (i != minPresumIndex) {
                if (maxDiff < presum - minPresum) {
                    maxDiff = presum - minPresum;
                    maxDiffStart = minPresumIndex + 1; //注意：这里的minVIndex刚好比a[]里面的index大1，这正是我们需要的，因为Presums的index也是加了1。
                    maxDiffEnd = max(i, maxDiffStart);
                }
            } else if (maxDiff < a[i]) {
                maxDiff = a[i];
                maxDiffStart = i;
                maxDiffEnd = i;
            }
            if (maxDiff < presum) {
                maxDiff = presum;
                maxDiffStart = 0;
                maxDiffEnd = i;
            }
        }
        return {maxDiffStart, maxDiffEnd};
    }
};

注意：当处理到i时，最大值要在a[i], presum[i]和presum[i]-minPresum之间选一个最大的。