[LintCode] Maximum Subarray III

Maximum Subarray III

Given an array of integers and a number k, find knon-overlapping subarrays which have the largest sum.

The number in each subarray should be contiguous.

Return the largest sum.

 

Example

Given [-1,4,-2,3,-2,3], k=2, return 8

Note

The subarray should contain at least one number

Analysis:

DP. d[i][j] means the maximum sum we can get by selecting j subarrays from the first i elements.

d[i][j] = max{d[p][j-1]+maxSubArray(p+1,i)}

we iterate p from i-1 to j-1, so we can record the max subarray we get at current p, this value can be used to calculate the max subarray from p-1 to i when p becomes p-1.

class Solution {
public:
    /**
     * @param nums: A list of integers
     * @param k: An integer denote to find k non-overlapping subarrays
     * @return: An integer denote the sum of max k non-overlapping subarrays
     */
    int maxSubArray(vector<int> nums, int k) {
        // write your code here
        int n = nums.size();
        vector<vector<int>> dp(n + 1, vector<int>(k + 1, INT_MIN));
        for (int i = 0; i <= n; ++i) 
            dp[i][0] = 0;
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= min(i, k); ++j) {
                int tmp = 0;
                for (int t = i - 1; t >= j - 1; --t) {
                    tmp = max(tmp + nums[t], nums[t]);
                    dp[i][j] = max(dp[i][j], tmp + dp[t][j-1]);
                }
            }
        }
        return dp[nums.size()][k];
    }
};

 重复使用dp数组，可以将空间复杂度降到O(n)。为了避免冲突，在枚举求解数组长度n时到倒着求，这样可以保证上一次迭代的结果不被覆盖掉。

class Solution {
public:
    /**
     * @param nums: A list of integers
     * @param k: An integer denote to find k non-overlapping subarrays
     * @return: An integer denote the sum of max k non-overlapping subarrays
     */
    int maxSubArray(vector<int> nums, int k) {
        // write your code here
        int n = nums.size();
        vector<int> dp(n + 1, 0);
        for (int j = 1; j <= k; ++j) {
            for (int i = n; i >= j; --i) {
                dp[i] = INT_MIN;
                int tmp = 0;
                for (int t = i - 1; t >= j - 1; --t) {
                    tmp = max(tmp + nums[t], nums[t]);
                    dp[i] = max(dp[i], tmp + dp[t]);
                }
            }
        }
        return dp[n];
    }
};