LeetCode——Maximum subarray

LeetCode——Maximum Subarray

# 53
Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
the contiguous subarray [4,-1,2,1] has the largest sum = 6.

click to show more practice.

这题是要求找到数组中最大子数组。其实在这种涉及变化过程的都是可以使用动态规划的方法。这个问题使用暴力法当然可以解决，但是时间上肯定浪费很多。例如下面这种使用循环的暴力法来解决，当输入数组大一点的时候，在LeetCode上是不能通过的。

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

在这里使用动态规划的思路，设置两个变量，一个全局最优max_all，一个局部最优max_part。然后写出动态规划的递推式，即dp方程。

max_part[i+1] = max(nums[i],nums[i] + max_part[i])
max_all[i+1] = max(max_part[i+1],max_all[i])

这样就可以比较简单的写出代码，时间复杂度为O(n)。

• C++

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

• Java

class Solution {
    public int maxSubArray(int[] nums) {
        if(nums.length==0)  
        return 0;  
        int max_part = nums[0];  
        int max_all = nums[0];  
        for(int i=1;i<nums.length;i++)  
        {  
            max_part = Math.max(nums[i],max_part+nums[i]);  
            max_all = Math.max(max_part,max_all);  
        }  
        return max_all;  
    }
}

还有一种解法，用到了divide and conquer（分治法）。这个分治法的思想类似于二分搜索法。时间复杂度为O(nlgn)。

• C++

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if (nums.empty()) return 0;
        return helper(nums, 0, (int)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 lmax = helper(nums, left, mid - 1);
        int rmax = helper(nums, mid + 1, right);
        int mmax = nums[mid], t = mmax;
        for (int i = mid - 1; i >= left; --i) {
            t += nums[i];
            mmax = max(mmax, t);
        }
        t = mmax;
        for (int i = mid + 1; i <= right; ++i) {
            t += nums[i];
            mmax = max(mmax, t);
        }
        return max(mmax, max(lmax, rmax));
    }
};