剑指offer之连续子数组的最大和

连续子数组的最大和

HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。你会不会被他忽悠住？(子向量的长度至少是1)

解题思路

方法一：动态规划

F（i）= max（F（i-1）+ array[i] ， array[i]）
res：所有子数组的和的最大值
res = max（res，F（i））

如数组[6, -3, -2, 7, -15, 1, 2, 2]
初始状态：
F（0）= 6
res = 6
i = 1：
F（1）= max（F（0）-3，-3）= max（6-3，3）= 3
res = max（F（1），res）= max（3，6）= 6
i = 2：
F（2）= max（F（1）-2，-2）=max（3-2，-2）= 1
res = max（F（2），res）= max（1，6）= 6
i=3：
F（3）= max（F（2）+7，7）=max（1+7，7）= 8
res=max（F（2），res）= max（8，6）= 8
i=4：
F（4）= max（F（3）-15，-15）= max（8-15，-15）= -7
res = max（F（4），res）= max（-7，8）= 8
以此类推
最终res的值为8

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        if(array.size() == 0)
            return 0;
        int res = array[0]; //记录当前所有子数组的和的最大值
        int curSum = array[0]; //包含array[i]的连续数组最大值
        for(int i = 1;i<array.size();i++){
            curSum = max(curSum + array[i],array[i]);
            res = max(curSum,res);
        }
        return res;
    }
};

方法二：贪心策略

遍历数组，到当此位置，上次保留的最大值如果为负数就要刷新一次，即curSum<=0时，当即果断丢弃，因为只会越加越小，刷新为当前值；如果为正数，继续累加。

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        if(array.size() == 0)
            return 0;
        int res = 0x80000000; //从开始位置到当前位置，存下的最大值。
        int curSum = 0; //从某个位置开始到当前位置为止，保留的最大值。
        for(int i=0;i<array.size();i++){
            if(curSum <= 0) //到当前位置为止，如果curSum为负数，无论是array[i]为正负，
                          // 加上当前元素后，curSum都会比array[i]小，所以不如将curSum设为array[i]
                curSum = array[i];
            else
                curSum +=array[i]; //如果array[i]为正，curSum会变大，下一步将被保存greatSum中，
                               // 但如果array[i]为负，上一次循环greatSum已经保存了，所以尽可放心；
            if(curSum > res)
                res = curSum;
        }
        return res;
    }
};