【剑指Offer】30.连续子数组最大和

题目描述：

• 求一串序列中子序列的最大值，序列中存在负数。
• 如{6， -3， -2，7， -15， 1， 2， 2}，连续子向量最大和为8（第0个开始，第3个为止）
• 子向量长度最少是1

方法一：动态规划

• 定义dp[i]表示以i为结尾的连续数组的最大和。所以最终要求dp[n-1]
• 状态转移方程：dp[i] = max(array[i-1], dp[i-1] + array)
• 思路:
  • 判断 array[0] + array[1]+…+array[i] < array[i] ? true : false。
  • true：说明前面的值 i-1个值相加<0，那么从第i个值再次为开始序列
  • false：说明 i-1个值相加仍旧>0，继续往后计算。
  • dp[i]获取在第i个位置处，子序列或该点的值，与历史最大值进行判断，存入最大值。
• 时间复杂度：O(n)
• 空间复杂度：O(n)

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        int sz = array.size();
        vector<int> dp(sz+1, 1);
        dp[0] = 0; // 表示没有元素
        int ret = array[0];
        for (int i=1; i<=sz; ++i) {
            dp[i] = max(array[i-1], dp[i-1]+array[i-1]);
            ret = max(ret, dp[i]);
        }
        return ret;
    }
};

方法二：空间复杂度O(1)解法

• 初始化：维护一个变量tmp=0;
• 如果 tmp + array[i] < 0，说明以i结尾的不做贡献，重新赋值tmp=0；
• 否则 更新 tmp = tmp + array[i]
• 最后判断tmp是否等于0，如果等于0，说明数组都是负数，选取一个最大的值为答案。
• 思路：
  • 以tmp进行累加，如果<0，放弃该值，重置tmp=0，重新累加
  • 每次累加后与历史最大值进行比较，判断是否存入。
• 时间复杂度:O(n)
• 空间复杂度：O(1)

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        int ret = array[0];
        int tmp = 0;
        for (const int k : array) {
            if (tmp + k < 0) {
                tmp = 0;
            }
            else {
                tmp += k;
            }
            ret = max(ret, tmp);
        }
        if (tmp != 0)
            return ret;
        return *max_element(array.begin(), array.end());
    }
};

方法一：Java代码

    public int FindGreatestSumOfSubArray(int[] array) {
        int ret = array[0];
        int dp[] = new int[array.length + 1];
        dp[0] = array[0];
        for (int i = 1;i < array.length; i++){
            dp[i] = array[i] < dp[i-1] + array[i] ? dp[i-1]+array[i]:array[i];
            if (ret < dp[i]){
                ret = dp[i];
            }
        }
        return ret;
    }

方法二：Java代码

    public int FindGreatestSumOfSubArray(int[] array) {
        int tmp = 0;
        int ret = array[0];
        int i = 0;
        while (i < array.length){
            if (tmp < 0)
                tmp = 0;
            tmp = tmp + array[i];
            if (tmp > ret)
                ret = tmp;
            i++;
        }
        return ret;
    }

思路：

• 空间复杂度为O(n)的集题；
• 初始化;dp数组第一个数为0，当前最大值为array[0]。dp数组存放当前的 总和与当前array值的最大值。
  • 如果dp[i-1]+array[i]<array[i]，说明之前相加为负值。给dp[i]负值array[i-1]以下标i-1为头，继续开始寻找最大值。
• 将每次得到的最大值，与历史最大值比较。

• 空间复杂度O(1)的解题–上面思路的变种:
• 初始化：ret存放历史最大值，tmp=0；tmp存放array累加的值（正）
• tmp+array[i]<array[i]时，说明该值（array的当前子序列的和）并不会对后续子序列和产生正向作用，丢弃，赋值tmp=0，重新计算
• 将每次tmp和与ret当前历史最大值进行比较，大者存入。