LintCode "Maximum Subarray III" !

Such a classic DP.. Thought flow:

1. find out the 2 vars in the problem statement: n and k

2. setup dp equation - my first thought was by n which was not natural, so by k.

3. details: if lower inx affects higher one, we calculate from higher to lower to avoid duplicate calculation.

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)
{
int n = nums.size();
if (n < k) return 0;

vector<vector<int>> dp(n + 1, vector<int>(k + 1, INT_MIN));

//    Init with Group 0
for(int i = 0; i <= n; i ++)
dp[i][0] = 0;

//    DP: from Group k-1 to Group k
for (int sub = 1; sub <= k; sub++)
for (int i = sub; i <= nums.size(); i++)
{
long long rsum = INT_MIN;
long long csum = 0;

//    NOTE: has to be from right to left - avoid duplicated calculation
//          because dp[j][*] -> dp[i][*] where j < i
for (int j = i - 1; j >= sub - 1; j--)
{
csum = max((long long)nums[j], csum + nums[j]);
rsum = max(rsum, csum);

dp[i][sub] = max(dp[j][sub-1] + rsum, (long long)dp[i][sub]);
}
}

return dp
[k];
}
};