一、数组---最大子序列和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
进阶:

如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。

暴力法：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
    if(nums.size()==0) return NULL;
    int max_value = nums[0];
    int sum = 0;
    for(int i=0;i<nums.size();i++){
        sum = 0;
        for(int j=i;j<nums.size();j++){//两个循环都是从0索引开始的
            sum += nums[j];
            if(sum > max_value) max_value=sum;
        }
    }
    return max_value;
    }
};

思路：

遇到负和，就抛弃之前的结果，重新积累，期间保留最大值

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        if(array.size()==0) return NULL;
        int sum=0;
        int res = array[0];
        for(int i=0;i<array.size();i++){
            if(sum<0) sum=array[i];
            else sum+=array[i];
            if(sum>res) res=sum;
        }
        return res;
    }
};

思路：

动态规划，类似于上面的思想，只要遇到累加和小于当前元素的，就抛弃。

F（i）：以array[i]为末尾元素的子数组的和的最大值，子数组的元素的相对位置不变

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) {
        int max_sum=array[0];
        int res=array[0];
        for(int i=1;i<array.size();i++){
            max_sum = max(max_sum+array[i],array[i]);
            res = max(max_sum,res);
        }
        return res;
    }
};