hdu 1024 Max Sum Plus Plus 小白都可以看得懂的解析

转载于https://blog.51cto.com/13688928/2117013
https://blog.csdn.net/a342374071/article/details/6701544
结合模拟讲解：
这道题弄了很久，网上的很多都看不懂，所以想要写一个像我这种菜鸟都可以看得懂的解析。

题意是将一个长度为n的序列，分成m段不相交叉的子段，使得他们的和最大。

于是可以用dp[i][j]来表示在前j个数中，以num[j]结尾并分为i段的最大和。此时我们可以得出一个式子，dp[i][j]=max(dp[i-1][k]+a[j],dp[i][j-1]+a[j]) (i-1< k< j-1)。分别表示num[j]单独成段和num[j]加入以num[j-1]结尾的一段。

现在举一个例子，序列为-1,4,-2,3,-2,3。

现在可以结合图标来理解式子的意思了，例如dp[2][4]=max(max(-1,4,2,) , 2)+num[4]=7

也就是说计算dp[i][j]只用到了2层的数据，上一层的数据我们只用到了其中的最大值，于是在求dp[j]时，我们可以用premax[]来记录i～j的最大值，在下一层时使用。

为什么i=n时，从第n位开始有值呢？因为这是每个数字自己单独成一段的情况，是满足分成n段的必要条件。

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=1000000;
int num[maxn],premax[maxn],dp[maxn];
int main(){
    int n,m,temp;
    while(~scanf("%d %d",&m,&n)){
        for(int i=1;i<=n;i++)    scanf("%d",&num[i]);
        memset(dp,0,sizeof(dp));
        memset(premax,0,sizeof(premax));
        for(int i=1;i<=m;i++){
            temp=-1e9;
            for(int j=i;j<=n;j++){
                dp[j]=max(premax[j-1],dp[j-1])+num[j];
                premax[j-1]=temp;//temp存放的是i～j-1中的最大值
                temp=max(temp,dp[j]);
            }
        }
        printf("%d\n",temp);
    }
    return 0;
}

详细讲解：
就大致讲解一下DP的整个思路。

我们可以很清楚地得，这是一个顺序DP，由ix<=iy可得。

那它在当前位置或者称为状态，又能做出几个决策才能保证到目前状态是最大的呢？

当然是逐步取其上一状态的最大值。

综上所述就可以得此模糊状态转移方程：dp[i][j] =MAX(dp[?][?],dp[??][??]) （或者是三个或者更多）。

下面我们来找它转移方程的本质：

设dp[i][j] 为前j个数字组成i段的最大和。（前提是i<=j ,这是显而易见的，当小于的时候不能组成i段）

所要达到的状态 :dp[i][j].

需要的条件：1、前j-1个数，组成i段的最大和 ；2、前j-1个数，组成的i-1段的最大和。

解释：由dp[i-1][j-1]到dp[i][j]，指的是当前第j个数单独为一段，dp[i][j-1]->dp[i][j]，第j个数接在第i段后面。

继续深入：我们是要求dp[i-1][j-1],dp[i][j-1]的最大值。那么i段就是在当前这个循环更新i->n状态的，所以dp[i][j-1]时刻在更新，反之，当前dp[i-1][j-1]的状态没有得到更新，那么我们就要加入这个j号元素进入时的更新保证dp[i-1][j-1]是当前可满足状态中最大的。

完全的动态规划转移方程dp[i][j]=MAX(dp[i][j-1],dp[i-1][k]) 其中i<=k<=j。

回头再看：n的最大值为100W，二维数组出来就需要巨额的空间。但是想象，当前需要更新的状态是不是就与当前上一状态和上一层的状态有关。

最终解决办法：采用滚动数组（或者两个一维数组）。
第一种转移的方案是严格按照上述转移方程来的

#include<cstdio>
#include<cstring>
#define MIN -(1<<30)
#define Max(a,b) ((a)>(b)?(a):(b))
#define M 1000001
int dp[2][M],num[M],n,m,max;
 
int main(){
 
	while(~scanf("%d %d",&m,&n)){
		int i=1,j,t=1;
 
		while(i<=n)
			scanf("%d",&num[i]),dp[0][i]=dp[1][i]=0,i++;
		
		for(i=1;i<=m;i++,t=!t){
 
			dp[t][i]=dp[!t][i-1]+num[i];
			dp[!t][i]=Max(dp[!t][i],dp[!t][i-1]);
 
			for(j=i+1;j<=n-m+i;j++){
 
				dp[t][j]=Max(dp[!t][j-1],dp[t][j-1])+num[j];
				dp[!t][j]=Max(dp[!t][j],dp[!t][j-1]);
 
			}
		}
		max=MIN;
		for(i=m;i<=n;i++)
			max=Max(dp[m&1][i],max);
 
		printf("%d\n",max);
 
	}
	return 0;
}

第二种方法只有一出有所不通，就是采用两个一维数组进行更新：
dp[],t[]，但是更值得注意的是，只有dp[j]是当前的状态，而t[k] (i<=k<=j)是当前状态的原状态，所以t[j-1]实际上是代替了方法中的dp[i][j-1]，
换言之。就是t[]中 i->j 是接在dp[j]后面的。而dp[i->j],是上一层的状态。这也是为什么t[j-1]要用max来保存，它表示的是当前层的最大值。

int dp[M],t[M],num[M],n,m;
 
int main(){
 
	while(~scanf("%d %d",&m,&n)){
 
		int i,j;
		for(i=1;i<=n;i++)
			scanf("%d",&num[i]);
 
		memset(dp,0,(n+1)*sizeof(int));
		memset(t,0,(n+1)*sizeof(int));
 
		int sum;
 
		for(i=1;i<=m;i++){
			sum=MIN;
			for(j=i;j<=n;j++){
				dp[j]=Max(dp[j-1],t[j-1])+num[j];
				t[j-1]=sum;
				sum=Max(dp[j],sum);
			}
			t[j-1]=sum;
		}
		printf("%d\n",sum);
	}
}