Leetcode 53：最大子序和

题目描述

给定一个整数数组 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) {
        int max_sum = INT_MIN;

        for(int i = 0; i < nums.size(); i++)
        {
            int sum = 0;
            for(int j = i; j < nums.size(); j++)
            {
                sum += nums[j];
                if(max_sum < sum) max_sum = sum;
            }
        }
        
        return max_sum;
    }
};

动态规划

假设子序列以第i个结尾，对应的最大子序和是dp[i]，不难发现，此题的解有如下的递推关系式：
dp[i] = max{ a[i], dp[i-1] + a[i] }

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int sum = nums[0];
        int max_sum = sum;
        for(int i = 1; i < nums.size(); i++)  // 子数组结尾
        {
            if(sum < 0)
            {
                sum = nums[i];
            }
            else
            {
                sum += nums[i];
            }

            if(sum > max_sum) max_sum = sum;
        }
        return max_sum;
    }
};

分治算法

分治算法实现的是把规模较大的问题分成规模小的子问题。在本例中，把序列分成三部分：左序列、右序列和过中点序列，分别找出各自的最大，再比较得出最终结果。时间复杂度o(NlogN)

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        return helper(nums, 0, nums.size() - 1);
    }
    
    int helper(vector<int>& nums, int left, int right)
    {
        if(left >= right) return nums[left];
                
        int mid = left + (right - left) / 2; // 这里取中间偏左为中点
        
        // 取左右子序列的最大
        int max_left = helper(nums, left, mid - 1);
        int max_right = helper(nums, mid + 1, right);
        
        //取过中点的最大
        int cur_cross = nums[mid];
        int max_cross = cur_cross;
        for(int i= mid-1; i >= left; i--)
        {
            cur_cross += nums[i];
            max_cross = max(cur_cross, max_cross);
        }
        
        cur_cross = max_cross;
        for(int i= mid+1; i <= right; i++)
        {
            cur_cross += nums[i];
            max_cross = max(cur_cross, max_cross);
        }
        
        return max(max(max_left, max_right), max_cross);
    }
};

贪心算法

原理来源Leetcode官方解法：

• 使用单个数组作为输入来查找最大（或最小）元素（或总和）的问题，贪心算法是可以在线性时间解决的方法之一。
• 每一步都选择最佳方案，到最后就是全局最优的方案。

算法：
该算法通用且简单：遍历数组并在每个步骤中更新：

• 当前元素
• 当前元素位置的最大和
• 迄今为止的最大和

代码同动态规划：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int cur_max = nums[0];
        int all_max = cur_max;

        for(int i = 1; i < nums.size(); i++)
        {
            cur_max = max(cur_max + nums[i], nums[i]);
            all_max = max(cur_max, all_max);
        }

        return all_max;
    }
};