Super Jumping! Jumping! Jumping!

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 36986    Accepted Submission(s):
16885

Problem Description

Nowadays, a kind of chess game called “Super Jumping!
Jumping! Jumping!” is very popular in HDU. Maybe you are a good boy, and know
little about this game, so I introduce it to you now.

The game can be played by two or
more than two players. It consists of a chessboard（棋盘）and some chessmen（棋子）, and
all chessmen are marked by a positive integer or “start” or “end”. The player
starts from start-point and must jumps into end-point finally. In the course of
jumping, the player will visit the chessmen in the path, but everyone must jumps
from one chessman to another absolutely bigger (you can assume start-point is a
minimum and end-point is a maximum.). And all players cannot go backwards. One
jumping can go from a chessman to next, also can go across many chessmen, and
even you can straightly get to end-point from start-point. Of course you get
zero point in this situation. A player is a winner if and only if he can get a
bigger score according to his jumping solution. Note that your score comes from
the sum of value on the chessmen in you jumping path.
Your task is to output
the maximum value according to the given chessmen list.

Input

Input contains multiple test cases. Each test case is
described in a line as follow:
N value_1 value_2 …value_N
It is
guarantied that N is not more than 1000 and all value_i are in the range of
32-int.
A test case starting with 0 terminates the input and this test case
is not to be processed.

Output

For each case, print the maximum according to rules,
and one line one case.

Sample Input

3 1 3 2

4 1 2 3 4

4 3 3 2 1

0

Sample Output

4

10

3

题目大意：用一句话总结就是 输入一个整数数列，输出该数列的最大上升子序列和。

解题思路：刚接触到这题的时候没什么思路 看了看网上的题解发现只是一个水DP（赶脚自己好菜啊~~）

　　　　　只要把状态转移方程怼出来就可以了。对于这题来说可以定义一个dp数组

　　　　　dp[i] 表示前i个整数组成的子串的最大上升子序列和

　　　　　状态方程:dp[i]=max{dp[j]}+a[i]; 其中,0<=j<i,a[i]>a[j] ;

 1 #include <stdio.h>
 2 #include <string.h>
 3 #include <algorithm>
 4 using namespace std;
 5
 6 int n;
 7 long long a[1010],dp[1010];  // dp[i] 储存从0到i的最大上升子序列的和
 8 long long LIS()    // 最大上升子序列和
 9 {
10     int i,j;
11     long long sum = 0, maxx;
12     for (i = 0; i < n; i ++)
13     {
14         dp[i] = a[i];      // dp[i]的初值为a[i]
15         maxx = 0;
16         for (j = 0; j < i; j ++)    // 找出i之前的最大dp[i]（并保证a[j] < a[i]）
17         {
18             if (a[j] < a[i])
19                 maxx = max(dp[j],maxx);
20         }
21         dp[i] += maxx;
22         sum = max(sum,dp[i]);    // sum为最大上升子序列的和
23     }
24     return sum;
25 }
26 int main ()
27 {
28     while (scanf("%d",&n),n)
29     {
30         for (int i = 0; i < n; i ++)
31             scanf("%lld",&a[i]);
32         printf("%lld\n",LIS());
33     }
34     return 0;
35 }