# 1. Title Description

Enter an integer array. One or more consecutive integers in the array form a sub array. Find the maximum value of the sum of all subarrays.

The required time complexity is O(n).

Example 1:

Input: num = [- 2,1, - 3,4, - 1,2,1, - 5,4]

Output: 6

Explanation: the maximum sum of continuous subarray [4, - 1,2,1] is 6.

Tips:

1 <= arr.length <= 10^5 -100 <= arr[i] <= 100

Source: LeetCode

Link: https://leetcode-cn.com/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof

The copyright belongs to Lingkou network. For commercial reprint, please contact the official authorization, and for non-commercial reprint, please indicate the source.

# 2. Problem solving steps of dynamic programming

## 2.1. Definition of DP [i]

For the above question, let's take a number, such as 8, then dp[8] represents the maximum sum of consecutive subarrays containing numbers with subscript 8.

dp[i] represents the maximum sum of consecutive subarrays containing numbers with subscript I.

## 2.2. Recursive

If you have watched the video of the up Master of station b (dynamic planning 1 and dynamic planning 2), you should remember a particularly interesting word, choose or not, for this question

This example:

value | -2 | 1 | -3 | 4 | -1 | 2,1 | -5 | 4 |
---|---|---|---|---|---|---|---|---|

subscript | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |

We can think like this,

If we choose the last 4 (subscript 7), the maximum sum of continuous subarrays is maxsum = the maximum sum of continuous subarrays containing numbers with subscript 7 (this should be calculated (calculated)); The calculation is as follows:

maxsum1 = sum(nums[0...7] )

maxsum2 = sum(nums[1...7] )

maxsum3 = sum(nums[2...7] )

maxsum4 = sum(nums[3...7] )

maxsum5 = sum(nums[4...7] )

maxsum6 = sum(nums[5...7] )

maxsum7 = sum(nums[6...7] )

maxsum8 = sum(nums[7...7] )

There are eight cases. Take the maximum maxsum.

If 4 is not selected, the result is the maximum sum of consecutive subarrays with - 5 (subscript 6).

Then compare the two results and take the maximum value.

Therefore, our recurrence formula is:

dp[i] = max(maxsum，dp[i-1]).

## 2.3.dp initialization and recursive function exit

If the array has only one element, the maximum sum is num [0], and the exit is i == 0, Num [0] is returned.

## 2.4. Recursive function

int dp(vector<int> nums,int i){ if(i == 0) { return nums[0]; } int maxSum = INT_MIN; int sum = 0; for(int j = i;j >= 0;j--){ sum += nums[j]; if(sum > maxSum) { maxSum = sum; } } int max2 = dp(nums,i-1); return max(maxSum,max2); }

Although the timeout, it shows that our idea is right and not wrong.

## 2.5. Change recursion to iteration

int dp_iterate(vector<int> nums){ int n = nums.size(); vector<int> dp(n,INT_MIN); dp[0] = nums[0]; for(int i = 1;i < n;i++){ maxSum = max(nums[i],maxSum + nums[i]); int maxSum = INT_MIN; int sum = 0; for(int j = i;j >= 0;j--){ sum += nums[j]; if(sum > maxSum) { maxSum = sum; } } dp[i] = max(dp[i-1],maxSum); } return dp[n-1]; }

It's too slow because the complexity is O (n^2).

## 2.6. Iterative optimization

The results are sequential. We just need to keep the current results and compare them with the next one.

int dp_iterate_better(vector<int> nums){ int n = nums.size(); int ans = nums[0]; for(int i = 1;i < n;i++){ maxSum = max(nums[i],maxSum + nums[i]); int maxSum = INT_MIN; int sum = 0; for(int j = i;j >= 0;j--){ sum += nums[j]; if(sum > maxSum) { maxSum = sum; } } ans = max(ans,maxSum); } return dp[n-1]; }

Space is optimized, but time is not optimized.

Here is the time optimization:

We use maxSum to record the maximum sum of continuous subarrays ending in i - 1. When we calculate the maximum sum of continuous subarrays ending in I, we only need to add num [i] to get the maximum sum of continuous subarrays ending in I, and then compare it with num [i] (this is also the maximum sum of continuous subarrays ending in I), That is, the maximum sum of continuous sub arrays ending with I can be obtained, and then compared with the result. The time complexity is O(n)

int dp_opt_better2(vector<int> nums) { int n = nums.size(); int ans = nums[0]; int maxSum = nums[0]; for(int i = 1;i < n;i++){ maxSum = max(maxSum + nums[i],nums[i]); ans = max(ans,maxSum); } return ans; }

# 3. Conclusion

Write space optimization should be good.