Problem Description
Now I thinkyou have got an AC in Ignatius.L's "Max Sum" problem. To be a braveACMer, we always challenge ourselves to more difficult problems. Now you arefaced with a more difficult problem.
Given a consecutive number sequence S1, S2,S3, S4 ... Sx, ... Sn(1 ≤ x ≤ n ≤ 1,000,000, -32768 ≤ Sx ≤ 32767). We define
afunction sum(i, j) = Si + ... + Sj (1 ≤ i ≤j ≤ n).
Now given an integer m (m > 0), your task is to find m pairs of i and jwhich make sum(i1, j1) + sum(i2,j2) + sum(i3, j3) + ... +sum(im,
jm) maximal (ix ≤iy ≤ jx or ix ≤ jy≤ jx is not allowed).
But I`m lazy, I don't want to write a special-judge module, so you don't haveto output m pairs of i and j, just output the maximal summation of sum(ix,jx)(1 ≤ x ≤ m) instead. ^_^
Input
Each test casewill begin with two integers m and n, followed by n integers S1,S2, S3 ... Sn.
Process to the end of file.
Output
Output themaximal 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
思路：
dp[i][j]表示前j个元素分成i段的最优解，同时这个最优解是由a[j]元素结束的。
转移方程是dp[i][j]=max{f[i][j-1]+a[j]，f[i-1][k]+a[j],(i-1<=k<j)}(i<=j<=n-m+i)
其中j的上下界的确定比较麻烦。现在分别解释上界和下界：
上界：dp[i][j]中，如果j=i-1，意思就是在前面i-1个元素中分成i段，这个是不可能实现的。
下界：如果m=n=4，这时dp[2][4]求出来了，意思是前面的四个元素分成了两段，当是还有两段要分，
所以求出这个是没有意义的。当然求出来也不会影响结果，只是这样时间复杂度就提高了。
这是其中一个特例的状态转移表 m=4，n=6 ，-1 4 -2 3 -2 3
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
__int64 a[1000010];
__int64 dp[2][1000010],ans;//设置滚动数组
int n,m;
__int64 MAX(__int64 a,__int64 b)
{
return a>b?a:b;
}
int main()
{
int i,j;
while(scanf("%d %d",&m,&n)!=EOF)
{
for(i=1;i<=n;i++)
{
dp[0][i]=dp[1][i]=0;
scanf("%I64d",&a[i]);
}
int pos=1;
for(i=1;i<=m;i++)
{
dp[pos][i]=dp[pos^1][i-1]+a[i];//滚动数组，要进行初始化
__int64 max=dp[pos^1][i-1];
for(j=i+1;j<=n-m+i;j++)
{
max=MAX(max,dp[pos^1][j-1]);
dp[pos][j]=MAX(dp[pos][j-1]+a[j],max+a[j]);
}
pos^=1;
}
pos^=1;
ans=-99999999;
for(i=m;i<=n;i++)
{
if(dp[pos][i]>ans)
{
ans=dp[pos][i];
}
}
cout<<ans<<endl;
}
return 0;
}
本题的大致意思为给定一个数组，求其分成m个不相交子段和最大值的问题。
设Num为给定数组，n为数组中的元素总数，Status[i][j]表示前i个数在选取第i个数的前提下分成j段的最大值，其中1<=j<=i<=n && j<=m，状态转移方程为：
Status[i][j]=Max(Status[i-1][j]+Num[i]，Max(Status[0][j-1]~Status[i-1][j-1])+Num[i])
乍看一下这个方程挺吓人的，因为题中n的限定范围为1~1,000,000而m得限定范围没有给出，m只要稍微大一点就会爆内存。但仔细分析后就会发现Status[i][j]的求解只和Status[*][j]与Status[*][j-1]有关所以本题只需要两个一维数组即可搞定状态转移。
在进行更进一步的分析还会发现其实Max(Status[0][j-1]~Status[i-1][j-1])根本不需要单独求取。在求取now_Status（保存本次状态的数组）的过程中即可对pre_Status（保存前一次状态的数组）进行同步更新。
状态dp[i][j]
有前j个数，组成i组的和的最大值。
决策： 第j个数，是在第包含在第i组里面，还是自己独立成组。
方程 dp[i][j]=Max(dp[i][j-1]+a[j] , max( dp[i-1][k] ) + a[j]) 0<k<j
空间复杂度，m未知，n<=1000000， 继续滚动数组。
时间复杂度 n^3. n<=1000000. 显然会超时，继续优化。
max( dp[i-1][k] ) 就是上一组 0....j-1 的最大值。我们可以在每次计算dp[i][j]的时候记录下前j个
的最大值 用数组保存下来 下次计算的时候可以用，这样时间复杂度为 n^2.
/*
状态dp[i][j]有前j个数，组成i组的和的最大值。决策：
第j个数，是在第包含在第i组里面，还是自己独立成组。
方程 dp[i][j]=Max(dp[i][j-1]+a[j] , max( dp[i-1][k] ) +a[j] ) 0<k<j
空间复杂度，m未知，n<=1000000， 继续滚动数组。
时间复杂度 n^3. n<=1000000. 显然会超时，继续优化。
max( dp[i-1][k] ) 就是上一组 0....j-1 的最大值。
我们可以在每次计算dp[i][j]的时候记录下前j个的最大值
用数组保存下来 下次计算的时候可以用，这样时间复杂度为 n^2.
*/
#include<stdio.h>
#include<algorithm>
#include<iostream>
using namespace std;
#define MAXN 1000000
#define INF 0x7fffffff
int dp[MAXN+10];
int mmax[MAXN+10];
int a[MAXN+10];
int main()
{
int n,m;
inti,j,mmmax;
while(scanf("%d%d",&m,&n)!=EOF)
{
for(i=1;i<=n;i++)
{
scanf("%d",&a[i]);
mmax[i]=0;
dp[i]=0;
}
dp[0]=0;
mmax[0]=0;
for(i=1;i<=m;i++)
{
mmmax=-INF;
for(j=i;j<=n;j++)
{
dp[j]=max(dp[j-1]+a[j],mmax[j-1]+a[j]);
mmax[j-1]=mmmax;
mmmax=max(mmmax,dp[j]);
}
}
printf("%d\n",mmmax);
}
return 0;
}
