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

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

示例:

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

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

暴力法：

 1 class Solution {
 2 public:
 3     int maxSubArray(vector<int>& nums) {
 4     if(nums.size()==0) return NULL;
 5     int max_value = nums[0];
 6     int sum = 0;
 7     for(int i=0;i<nums.size();i++){
 8         sum = 0;
 9         for(int j=i;j<nums.size();j++){//两个循环都是从0索引开始的
10             sum += nums[j];
11             if(sum > max_value) max_value=sum;
12         }
13     }
14     return max_value;
15     }
16 };

思路：

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

 1 class Solution {
 2 public:
 3     int FindGreatestSumOfSubArray(vector<int> array) {
 4         if(array.size()==0) return NULL;
 5         int sum=0;
 6         int res = array[0];
 7         for(int i=0;i<array.size();i++){
 8             if(sum<0) sum=array[i];
 9             else sum+=array[i];
10             if(sum>res) res=sum;
11         }
12         return res;
13     }
14 };

 

思路：

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

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

 1 class Solution {
 2 public:
 3     int FindGreatestSumOfSubArray(vector<int> array) {
 4         int max_sum=array[0];
 5         int res=array[0];
 6         for(int i=1;i<array.size();i++){
 7             max_sum = max(max_sum+array[i],array[i]);
 8             res = max(max_sum,res);
 9         }
10         return res;
11     }
12 };

 

转载于:https://www.cnblogs.com/pacino12134/p/10990603.html