Max Sum Plus Plus HDU - 1024（dp）（滚动数组优化）

Now I think you have got an AC in Ignatius.L’s “Max Sum” problem. To be a brave ACMer, we always challenge ourselves to more difficult problems. Now you are faced with a more difficult problem.

Given a consecutive number sequence S 1, S 2, S 3, S 4 … S x, … S n (1 ≤ x ≤ n ≤ 1,000,000, -32768 ≤ S x ≤ 32767). We define a function sum(i, j) = S i + … + S j (1 ≤ i ≤ j ≤ n).

Now given an integer m (m > 0), your task is to find m pairs of i and j which make sum(i 1, j 1) + sum(i 2, j 2) + sum(i 3, j 3) + … + sum(i m, j m) maximal (i x ≤ i y ≤ j x or i x ≤ j y ≤ j x is not allowed).

But I`m lazy, I don’t want to write a special-judge module, so you don’t have to output m pairs of i and j, just output the maximal summation of sum(i x, j x)(1 ≤ x ≤ m) instead. ^_
Input
Each test case will begin with two integers m and n, followed by n integers S 1, S 2, S 3 … S n.
Process to the end of file.
Output
Output the maximal summation described above in one line.
Sample Input
1 3 1 2 3
2 6 -1 4 -2 3 -2 3
Sample Output
6
8

Hint
Huge input, scanf and dynamic programming is recommended.

一：状态转移方程的推导：

题目大意：
给你一个数组，从中取出m个区间，这些区间和最大。

题意搞了一天才搞懂。这个题是hdu1003 Max的plus plus版，然鹅感觉除了题目有点像外，其他的根本不一样

令dp[i][j]表示以j为结尾的，前j个数中取出i个区间，和最大值。
那么题意就变成了dp[m][k] (1=<k<=n),中的最大值。
对于j，只能有两种处理方式：把j加到前一个区间的末尾，或者自己成为新的一个区间的第一个数。

1. 如果成为区间第一个数，那么dp[i][j]=max(dp[i-1][k])(1=<k<=j-1);
2. 如果加到上一个区间的末尾，dp[i][j]=dp[i][j-1];

那么总的状态转移方程就是dp[i][j]=max(dp[i][j-1],max(dp[i-1][k])); (1=<k<=j-1);

时间复杂度是o(n3),我们可以在状态转移的过程中将max（dp[i-1][k]）算出来，放到一个二维数组中。这样就可以避免每次状态转移的时候都要算一遍max（dp[i-1][k]），时间复杂度降至o（n2）;

二：滚动数组的优化：

对于这个题目，没有给出m的范围。m大一点可能就会爆掉内存。
我们可以思考一下，dp[i][j]只由dp[i-1][k]（通过优化将max（dp[i-1][k]）保存到一个数组中（maxn[i-1][j]））和dp[i][j-1] 转移而来，而二维数组max[i-1][j]只有在dp[i][j]转移的时候就会用到。

所以，我们可以采用滚动数组的方法，将dp数组降至一维，maxn数组降至一维。

1. dp[j]状态转移时，算出max(dp[k])，并用一个变量（maxnn）暂时存储。
2. 每次状态转移完成后，立刻用maxnn覆盖maxn[j-1];

三：边界处理：

1. 对于dp[i][j],我们从dp[i][i]开始处理，而dp[i][i]进行转移时，不能从dp[i][i-1]转移而来(因为无法把i-1分成i个区间),所以我们要在状态转移之前将dp[i][i-1]设为负无穷，使它只能由dp[i-1][i-1]转移而来

2. 那么初始的dp[1][j]怎么转移呢。这就是hdu1003的问题了。
   对于每个j，可以跟在dp[1][j-1]后面，也可以自己成为区间的第一个(可以看作0+a[j])。
   那么，我们将dp[0][j-1]设为0,dp[1][j]也符合转移方程了。

3. dp[1][1]只应由0+a[1]转移而来。
   kuangbin巨佬是将dp[0]设为0，这样两种转移方式都是0+a[1]符合转移方程
   我将dp[0]设为负无穷，这样肯定不会由dp[0]转移而来，只能由上一层（设为0）转移而来。

#include<iostream>
#include<string.h>
using namespace std;

int dp[1000009];
int maxn[1000009];
int a[1000009];

int main(){
	int maxnn;
	int m,n;
	while(~scanf("%d%d",&m,&n)){
		memset(maxn,0,sizeof(maxn));
		memset(dp,0,sizeof(dp));
		for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
		for(int i=1;i<=m;i++){
			maxnn=-0x3f3f3f3f;
			dp[i-1]=-0x3f3f3f3f;
			for(int j=i;j<=n;j++){
				dp[j]=max(dp[j-1],maxn[j-1])+a[j];
				maxn[j-1]=maxnn;
				maxnn=max(maxnn,dp[j]);
			}			
		}
		cout<<maxnn<<endl;
	}
}