九度OJ 1480 动态规划 最大上升子序列和

题目1480：最大上升子序列和

时间限制：1 秒内存限制：128 兆特殊判题：否提交：1112解决：419

题目描述：
一个数的序列bi，当b1 < b2 < ... < bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, ...,aN)，我们可以得到一些上升的子序列(ai1, ai2, ..., aiK)，这里1 <= i1 < i2 < ... < iK <= N。比如，对于序列(1, 7, 3, 5, 9, 4, 8)，有它的一些上升子序列，如(1, 7), (3, 4, 8)等等。这些子序列中序列和最大为18，为子序列(1, 3, 5, 9)的和.

你的任务，就是对于给定的序列，求出最大上升子序列和。注意，最长的上升子序列的和不一定是最大的，比如序列(100, 1, 2, 3)的最大上升子序列和为100，而最长上升子序列为(1, 2, 3)。

输入：
输入包含多组测试数据。

每组测试数据由两行组成。第一行是序列的长度N (1 <= N <= 1000)。第二行给出序列中的N个整数，这些整数的取值范围都在0到10000（可能重复）。

输出：

对于每组测试数据，输出其最大上升子序列和。

样例输入：
7

1 7 3 5 9 4 8

样例输出：

18

来源：

2012年北京大学计算机研究生机试真题

使用了比较挫的动态规划，时间复杂度O(n^2), 空间复杂度O(n^2),方法参考算法导论上的方法,先给大伙一组测试数据，这组数据过了基本上就过了。

6                                                         
 -1 -2 -3 -9 -6 -1                                 
8                                                         
 1 1 1 1 -5 -9 -3 -2                            
7                                                         
 1 1 5 6 9 8 -7                                   
3                                                        
 -9 1 2                                                
8                                                        
1 3 -5 9 100 -4 -1 -100                    
8                                                         
 2 100 -1000 6 700 -1000 -1 -2      
8                                                        
1 2 3 -5 -9 -1 8 9                              
8                                                         
100 200 30 -1000 -5 1000 8 63     
8                                                         
 -1 -2 -3 5 9 8 -2 -1                          
9                                                        
-88 99 -8 66 -3 1 2 5 99                  
8                                                        
 -12 1 -100 5 6 8 -100 1                  
11                                                       
 6 -1 -8 3 -1 3 30 -8 -6 30 -100       
9                                                          
-3 -1 2 -1 -9 5 -1 3 -9                        
4                                                         
0 0 -1 1                                               
5                                                         
 0 0 1 0 0                                           
2                                                         
 0 0                                                     

output：

-1
1
21
3
113
802
23
1300
14
165
20
36
7
1
1
0
请按任意键继续. . .

源代码：

#include<stdio.h>
#include<stdlib.h>
int num[901],sort[901],dp[901][901]={0},n,max;
int cmp(const void*a1,const void*a2)
{
	return *(int*)a1-*(int*)a2;
}
int main()
{
	while(~scanf("%d",&n))
	{
		sort[0]=-9999;
		num[0]=-9999;
		max=-9999;
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&num[i]);
			sort[i]=num[i];
		}

		qsort(sort+1,n,sizeof(num[1]),cmp);

		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			{
				if(num[i]==sort[j]&&sort[j]>sort[j-1])
				{
					if(num[i]>dp[i-1][j-1]+num[i])
						dp[i][j]=num[i];
					else
						dp[i][j]=dp[i-1][j-1]+num[i];
				}
				else
					dp[i-1][j]>dp[i][j-1]?(dp[i][j]=dp[i-1][j]):(dp[i][j]=dp[i][j-1]);
			}		
		}

		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				if(dp[i][j]>max&&dp[i][j]<0)
					max=dp[i][j];

		int count=0;
		for(int i=1;i<=n;i++)
			if(num[i]<0)
				count++;

		if(count==n)
			printf("%d\n",max);
		else
			printf("%d\n",dp[n][n]);
	}
	return 0;
}