【Leetcode】53. Maximum Subarray

【Leetcode】53. Maximum Subarray

问题链接：
https://leetcode.com/problems/maximum-subarray/description/

参考：
WIKI上面的Maximum subarray problem：
https://en.wikipedia.org/wiki/Maximum_subarray_problem

最开始使用最容易想到的brute force algorithm，暴力解法，思想很简单就是遍历，初始化max的时候要用

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int max= INT_MIN;
        cout<< max<< endl;
        int size= nums.size();
        for (int i= 0; i< size; i++) {
            for (int j= 1; j<= size- i; j++) {
                int sum= 0;
                for (int k= 0; k< j; k++) {
                    sum+= nums[i+ k];
                }
                if (sum> max) max= sum;
            }
        }
        return max;
    }
};

无奈有2个例子没通过，于是再思考了下，发现我想复杂了，只需要两层循环就能够解决，先遍历数字，然后遍历子序列的元素数，思想就是从目前数组该元素一个个元素向后加。然后就AC了，代码如下：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int max= INT_MIN;
        int size= nums.size();
        for (int i= 0; i< size; i++) {
            int sum= 0;
            for (int j= i; j<= size- 1; j++) {
                sum+= nums[j];
                if (sum> max) max= sum;
            }
        }
        return max;
    }
};

寻找更优的方案，发现WIKI上面有这个问题的详情解答（链接如上），WIKI该问题有3种方法：
1. brute force algorithm, 暴力求解
2. divide and conquer, 分治算法
3. dynamic programming.动态规划

第一种方法和上面的差不多，时间复杂度是O(n^2)。
重点是第二种和第三种方法，时间复杂度是O(n)。

divide and conquer 分治法

该题的分治法思想是：使用递归，分为左方和右方计算，然后计算中间的部分。如果左索引等于右索引就返回，因为元素只有一个值。然后使用递归计算左边的最大值和右边的最大值。再是计算中间部分的最大值。计算中间部分的最大值的方法是先计算左边的最大和，然后计算右边的最大和，中间部分的的最大值就是它们的和。最后寻找左边、中间和右边的最大值就是最终结果。
WIKI上面的伪代码：

procedure MaxSum(f,t) begin
//Finds maximum sum in a[f..t]
if f = t then return (a[f], sum[f − 1], sum[f]) //One-element array
c ← (f + t − 1)/2 //Halves array. left is a[f..c], right is a[c+1..t]
(mLeft, minPLeft, maxPLeft) ← MaxSum(f,c)
(mRight, minPRight, maxPRight) ← MaxSum(c + 1,t)
minP ← MIN {minPLeft, minPRight} //Min prefix sum in sum[f−1..t−1]
maxP ← MAX {maxPLeft, maxPRight} //Max prefix sum in sum[f..t]
mCenter ← maxPRight − minPLeft //Solution for the center problem
M ← MAX {mLeft, mRight, mCenter}
return (M, minP, maxP)
end

根据伪代码，修改得到的Solution如下，能够AC。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        return solve(nums, 0, nums.size()- 1);
    }

    int solve(vector<int>& nums, int left, int right) {
        if (left== right) {
            return nums[left];
        }
        int mid= left+ (right- left)/ 2;
        int leftMax= solve(nums, left, mid);
        int rightMax= solve(nums, mid+ 1, right);
        int leftMaxSum= nums[mid];
        int tempSum= nums[mid];
//      go left
        for (int i= mid- 1; i>= left; i--) {
            tempSum+= nums[i];
            if (tempSum> leftMaxSum) leftMaxSum= tempSum;
        }
//      go right
        int rightMaxSum= nums[mid+ 1];
        tempSum= nums[mid+ 1];
        for (int i= mid+ 2; i<= right; i++) {
            tempSum+= nums[i];
            if (tempSum> rightMaxSum) rightMaxSum= tempSum;
        }
        return max(max(leftMax, rightMax), rightMaxSum+ leftMaxSum);
    }
};

dynamic programming 动态规划

使用的就是Kadane’s algorithm，具体思想WIKI上面有。
思想就是：遍历数组，每次都计算出以该点为结束点时的局部最大值，每次遍历，局部最大值是新的结束点的值或者或者上次得到的局部最大值和该次结束点的值的最大值，然后最大值就是就是各个局部最大值的最大值。
该算法是动态规划的典型例子，让我想起了dijkstra最短路径算法。

代码如下：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int max_ending_here= nums[0];
        int max_so_far= nums[0];
        for (int i= 1; i< nums.size(); i++) {
            max_ending_here= max(nums[i], max_ending_here+ nums[i]);
            max_so_far= max(max_ending_here, max_so_far);
        }
        return max_so_far;
    }
};