动态规划入门G - Super Jumping! Jumping! Jumping! （有关最优子序列的一个相关题目）...-CSDN博客

题目：G - 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.
题目的图：https://cn.vjudge.net/contest...
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数组来对应比较，而不是一开始存数的那个数组；

代码：

#include<stdio.h>
#include<string.h>

int a[1005],d[1005];
int main()
{
    int n,i,j;
    while(scanf("%d",&n)!=EOF && n!=0){
        memset(d,0,sizeof(d));
        for(i=0;i<n;++i)
            scanf("%d",&a[i]);
        d[0]=a[0];
        for(i=1;i<n;++i){
            for(j=0;j<i;++j){
                if(a[j]<a[i])
                    d[i]=d[i]>(d[j]+a[i])?d[i]:(d[j]+a[i]);//这里就是更新这个和
            }                                //以保证这个递增和是最大的值的情况；
            d[i]=d[i]>a[i]?d[i]:a[i];  //这个操作是为了保证如果前面都没有递增的；
        }                            //则最后这个dp数组中要存的是其自身，
        int k=0;                        //用三目运算符的d[i]与其自身比较
        for(i=1;i<n;++i)            //可以在不讨论的情况下将所有情况总结出一个
            if(d[k]<d[i])            //共用的，当然也可以转换成用if进行；
            k=i;
        printf("%d\n",d[k]);
    }
    return 0;
}