hdu-1159 1087 1257（dp）

　　本文就最长公共子序列，最长连续递增子序列的长度，最大连续递增子序列的值进行对比。

hdu-1159:

Common Subsequence

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

Problem Description

A subsequence of a given sequence is the given sequence with some elements (possible none) left out. Given a sequence X = <x1, x2, ..., xm> another sequence Z = <z1, z2, ..., zk> is a subsequence of X if there exists a strictly increasing sequence <i1, i2, ..., ik> of indices of X such that for all j = 1,2,...,k, xij = zj. For example, Z = <a, b, f, c> is a subsequence of X = <a, b, c, f, b, c> with index sequence <1, 2, 4, 6>. Given two sequences X and Y the problem is to find the length of the maximum-length common subsequence of X and Y.
The program input is from a text file. Each data set in the file contains two strings representing the given sequences. The sequences are separated by any number of white spaces. The input data are correct. For each set of data the program prints on the standard output the length of the maximum-length common subsequence from the beginning of a separate line.

 

 

Sample Input

abcfbc abfcab programming contest abcd mnp

 

 

Sample Output

4 2 0

 

 

Source

Southeastern Europe 2003

 

 

本题就是经典的lcs问题哈，还是老套路，把一个问题分解为若干小问题。

得到如下递推式：

 

下面附代码：

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
const int Max = 1111;
char st1[Max],st2[Max];
int dp[Max][Max];
int main()
{
    while(~scanf("%s %s",st1,st2))
    {
        memset(dp,0,sizeof(dp));
        int m=strlen(st1);
        int n=strlen(st2);
        for(int i=0;i<m;i++)
        for(int k=0;k<n;k++)
        {
            if(st1[i]==st2[k])
            dp[i+1][k+1]=dp[i][k]+1;
            else
            dp[i+1][k+1]=max(dp[i+1][k],dp[i][k+1]);
        }
        printf("%d\n",dp[m][n]);
    }
    return 0;
}

 

hdu-1087

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

这道题就是求最大的递增子序列的值，只需要求每一个位置与前面所有的情况中的最大值。
代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int Max = 1111;
int nu;
struct ak 
{
    int maxx;
    int sum;
}dp[Max];
int main()
{
    int n;
    while(~scanf("%d",&n),n)
    {
        int flag=1;
        int i,ans;
        memset(dp,0,sizeof(dp));
        
        while(n--)
        {
            ans=-999999999;
            scanf("%d",&nu);
            for( i=0;i<flag;i++)
            {
                if(dp[i].maxx<nu)
                {
                    if(ans<dp[i].sum+nu)
                    {
                        dp[flag].maxx=nu;
                        ans=dp[i].sum+nu;
                    }
                }
            }
            dp[flag++].sum=ans;
        }
        ans=-999999999;
        for(int i=0;i<flag;i++)
        {
            ans=(ans>dp[i].sum)?ans:dp[i].sum;
        }
        printf("%d\n",ans);
    }
    return 0;
}

hdu 1275

某国为了防御敌国的导弹袭击,发展出一种导弹拦截系统.但是这种导弹拦截系统有一个缺陷:虽然它的第一发炮弹能够到达任意的高度,但是以后每一发炮弹都不能超过前一发的高度.某天,雷达捕捉到敌国的导弹来袭.由于该系统还在试用阶段,所以只有一套系统,因此有可能不能拦截所有的导弹.
怎么办呢?多搞几套系统呗!你说说倒蛮容易,成本呢?成本是个大问题啊.所以俺就到这里来求救了,请帮助计算一下最少需要多少套拦截系统.
Input输入若干组数据.每组数据包括:导弹总个数(正整数),导弹依此飞来的高度(雷达给出的高度数据是不大于30000的正整数,用空格分隔)
Output对应每组数据输出拦截所有导弹最少要配备多少套这种导弹拦截系统.
Sample Input

8 389 207 155 300 299 170 158 65

Sample Output

2
该题就是求最长的递增子序列的长度。其实和上一道很类似，都是从每一点出发，遍历前面的所有状态，找出其中和最大的。
代码：

#include <cstdio>
const int Max = 111111;
int nu[Max],dp[Max];
int main()
{
    int n,k;
    while(~scanf("%d",&n))
    {
        int flag=1;
        scanf("%d",&nu[0]);
        dp[0]=nu[0];
        for(int i=1;i<n;i++)
        {
            scanf("%d",&nu[i]);
            for( k=0;k<flag;k++)
            {
                if(nu[i]<dp[k])
                {
                    dp[k]=nu[i];
                    break;
                }
            }
            if(k==flag)
            dp[flag++]=nu[i];
        }
        printf("%d\n",flag);
    }
    return 0;
}