Super Jumping! Jumping! Jumping（最大递增子序列的和）

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.

InputInput 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.

OutputFor 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
题意：在start->end这条路上有多个棋手，每个棋手都有一个价值，如果你想获得某个棋手的价值则该棋手的价值必须比上一个获得的棋手的价值大，求在这条路线上你能获得的最大价值
分析：从题面上来看，是让我们求最大递增子序列的和。如果我们要求前k项max(lIs)，那我们可以从前k项遍历，如果str[j]<str[k],则dp[k]=max(dp[k],dp[j]+str[k]),反之我们不更新。
dp[i]表示前i项最大递增子序列的和

 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #include<stack>
 #include<queue>
 #include<iostream>
 #include<map>
 #include<vector>
 #define Inf 0x3f3f3f3f
 #define PI acos(-1.0)
 using namespace std;
 int dp[];
 int str[];
 int main()
 {
     int m,n,i,j,pos;
     while(scanf("%d",&m)!=-&&m)
     {
     for(i=; i<=m; i++)
     {
         scanf("%d",&str[i]);
     }
      memset(dp,,sizeof(dp));
      int ans=-Inf;
     for(i=;i<=m;i++)
     {
         dp[i]=str[i];
         for(j=;j<=i;j++)
         {
             if(str[j]<str[i])
             {
                 dp[i]=max(dp[i],dp[j]+str[i]);
             }
         }
         ans=max(ans,dp[i]);

     }
     cout<<ans<<endl;
     }
     return ;
 }

我们会发现对与前n项的max(LIS),都有这个重叠子问题，因此
我们构造状态转移方程dp[k]=max(dp[k],dp[j]+str[k])