【转】HDU 1024 Max Sum Plus Plus

Max Sum Plus Plus

Time Limit : 2000/1000ms(Java/Other)   Memory Limit : 65536/32768K (Java/Other)

Total Submission(s) :0   Accepted Submission(s) : 0

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

ProblemDescription

Now I think youhave 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 S₁, S₂,S₃, S₄ ... 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 jwhich make sum(i₁, j₁) + sum(i₂,j₂) + sum(i₃, j₃) + ... +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 haveto 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 willbegin with two integers m and n, followed by n integers S₁, S₂,S₃ ... S_n.
Process to the end of file.

Output

Output the maximalsummation 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, scanfand dynamic programming is recommended.

Author

JGShining（极光炫影）

★ Max Sum Plus Plus http://acm.hdu.edu.cn/showproblem.php?pid=1024
    1. 对于前n个数, 以v[n]为底取m段: 
    当n==m时,Sum[m][n]=Sum[m-1][n-1]+v[n],第n个数独立成段;
当n>m时, Sum[m][n]=max{Sum[m-1][k],Sum[m][n-1]}+v[n]; 其中,m-1<=k<j,解释为,v[n]要么加在Sum[m][n-1],段数不变,要么独立成段接在前n-1个数取m-1段所能构成的最大值后面
2. 空间的优化:
        通过状态方程可以看出,取m段时,只与取m-1段有关,所以用滚动数组来节省空间

问题：

给定由n个整数(可能为负整数)组成的序列e1,e2,…,en,以及一个正整数m，要求确定序列的m个不相交子段，使这m个子段的总和达到最大。

 

分析：

设b(i，j)表示数组e的前j项中i个子段和的最大值，且第i个子段含e[j](1£ i £m，i£ j £n)。以下称b(i,j)为“最后一个元素属于第i子段的j元素i子段问题”。则n个元素中求i个子段的最优值显然为：

 

best(i,n) = Max{ b(i, j) } (i <= j <= n)

 

计算b(i，j)的最优子结构为：

 

b(i，j) = Max{ b(i, j-1) + e[i], Max{ b(i-1, t) } + e[i] } (i<= t < j)

 

这样，可以得到时间复杂度为O(m * n ^ 2)和空间复杂度为O(m * n)的MS相当漂亮而且容易理解的DP算法。当n不大的时候，这个算法足够优秀，然而，当n很大的时候，这个算法显然是不能让人满意的！

 

优化：

观察上面的最优子结构，我们发现b(i, j)的计算只和b(i, j-1)和b(i-1, t)有关，也就是说只和最后一个元素属于第i子段的j-1元素i子段问题和前j-1个元素的最大i-1子段问题有关（可以分别理解为将e[j]作为最后一个元素而并入第i子段和将e[j]另起一段作为第i分段）。这样，我们只要分别用curr_best和prev_best两个一维数组保存当前阶段和前一阶段的状态值b(i, *)和b(i-1,*) 就行了，内存使用也就可以降为O(2 * n)。

再来看看时间。分析发现，原算法低效主要是在求max_sum(i, t) = Max{b(i, t)} (i<= t < j)的时候用了O(n)的时间。其实，在求b(i, j)的过程中，我们完全可以同时计算出max_sum(i, t)，因为max_sum(i,j) = Max{b(i,j), max_sum(i,j-1)}，这个只花费O(1)的时间。而max_sum(i,t)不就是i+1阶段中要用到的吗？关键问题已经解决了！那如何保存max_sum呢？再开一个数组？我们可以在prev_best数组中保存！这个数组的任务相当艰巨，它既存放着i-1阶段的max_sum数值，又存放这供i+1阶段使用的i阶段的max_sum值。MS这有点矛盾？其实这是可行的。注意到我们在计算b(i,j)时只使用了prev_best[j-1]，使用完了再也没有用了，这样空闲着岂不浪费？其实我们可以将max_sum(i, j-1)存放到prev_best[j-1]里面——这个主意相当不错，它让所有问题迎刃而解。

现在，我们得到了一个时间复杂度为O(m * n)、空间复杂度为(2 * n)的算法。这个算法相当优秀，以至于m为小常数，n = 1000000时，结果也是瞬间就出来了（此时算法的时间复杂度可以认为是O(n)的）。

#include<stdio.h>
#include<stdlib.h>
#define MIN_SUM 0x80000000

int max_sum(int e[],int n,int m)
{
	int *curr_best;
	int *prev_best;
	int max_sum,i,j;
	curr_best=(int*)malloc(sizeof(int)*(n+1));
	prev_best=(int*)calloc(n+1,sizeof(int));
	*curr_best=0;
	e--;
	for(i=1;i<=m;++i)
	{
		max_sum=MIN_SUM;
		for(j=i;j<=n;++j)
		{
			if(curr_best[j-1]<prev_best[j-1])
			curr_best[j]=prev_best[j-1]+e[j];
			else
			curr_best[j]=curr_best[j-1]+e[j];
			prev_best[j-1]=max_sum;
			if(max_sum<curr_best[j])
			max_sum=curr_best[j];
		}
		prev_best[j-1]=max_sum;
		
	}
	free(prev_best);
	free(curr_best);
	return max_sum; 
}

int main()
{
	int n,m,i,*data;
	while(scanf("%d%d",&m,&n)==2&&n>0&&m>0)
	{
		data=(int*)malloc(sizeof(int)*n);
		for(i=0;i<n;i++)
		scanf("%d",&data[i]);
		printf("%d\n",max_sum(data,n,m));
		free(data);
	}
	return 0;
}