简单DP

Almost Sorted Array

We are all familiar with sorting algorithms: quick sort, merge sort, heap sort, insertion sort, selection sort, bubble sort, etc. But sometimes it is an overkill to use these algorithms for an almost sorted array.

We say an array is sorted if its elements are in non-decreasing order or non-increasing order. We say an array is almost sorted if we can remove exactly one element from it, and the remaining array is sorted. Now you are given an array a1,a2,…,an

, is it almost sorted?

InputThe first line contains an integer T indicating the total number of test cases. Each test case starts with an integer n in one line, then one line with n integers a1,a2,…,an.

1≤T≤2000
2≤n≤105
1≤ai≤105
There are at most 20 test cases with n>1000.OutputFor each test case, please output "`YES`" if it is almost sorted. Otherwise, output "`NO`" (both without quotes).Sample Input

3
3
2 1 7
3
3 2 1
5
3 1 4 1 5

Sample Output

YES
YES
NO

判断数列是否几乎非递增或非递减，“几乎”就是删掉一个数字后变成了非递增或非递减。
思路判断数列是最大增数列或最大减数列是否大于等于len-1就行，增数列和减数列可以有连续相等的。

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int N = 1e5+10;
const int Inf = 1<<30;
int a[N], dp[N];
int t, n;
int main(){
    scanf("%d",&t);
    while(t--) {
        scanf("%d",&n);
        for(int i = 0; i < n; i ++){
            scanf("%d",&a[i]);
            dp[i] = Inf;
        }
        for(int i = 0; i < n; i ++) {
            *upper_bound(dp,dp+n,a[i]) = a[i];
        }
        int ans = upper_bound(dp,dp+n,Inf-1) - dp;
        for(int i = 0; i < n; i ++) dp[i] = Inf;
        for(int i = 0; i < n/2; i ++){
            swap(a[i],a[n-i-1]);
        }
        for(int i = 0; i < n; i ++) {
            *upper_bound(dp,dp+n,a[i]) = a[i];
        }
        int ans1 = upper_bound(dp,dp+n,Inf-1) - dp;
        if(ans >= n-1 || ans1 >= n-1) cout << "YES
";
        else cout << "NO
";
        memset(a,0,sizeof(a));
    }
    return 0;
}

Greatest Common Increasing Subsequence

This is a problem from ZOJ 2432.To make it easyer,you just need output the length of the subsequence.

InputEach sequence is described with M - its length (1 <= M <= 500) and M integer numbers Ai (-2^31 <= Ai < 2^31) - the sequence itself.Outputoutput print L - the length of the greatest common increasing subsequence of both sequences.Sample Input

1

5
1 4 2 5 -12
4
-12 1 2 4

Sample Output

2

求最大公共增数列。
就是最长递增子序列和最长公共子序列的结合，dp判断下就性。

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
int a[550], b[550], dp[550][550];
int main() {
    int t;
    scanf("%d",&t);
    while(t--) {
        int n, m;
        scanf("%d",&n);
        for(int i = 0; i < n; i ++) scanf("%d",&a[i]);
        scanf("%d",&m);
        for(int i = 0; i < m; i ++) scanf("%d",&b[i]);
        for(int i = 0; i < n; i ++) {
            for(int j = 0; j < m; j ++) {
                if(a[i] == b[j]) dp[i+1][j+1] = dp[i][j] + (b[j] > b[j-1]);
                else dp[i+1][j+1] = max(dp[i][j+1],dp[i+1][j]);
            }
        }
        cout << dp[n][m] << endl;
        if(t)printf("
");
        memset(dp,0,sizeof(dp));
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
    }
    return 0;
}

Advanced Fruits

The company "21st Century Fruits" has specialized in creating new sorts of fruits by transferring genes from one fruit into the genome of another one. Most times this method doesn't work, but sometimes, in very rare cases, a new fruit emerges that tastes like a mixture between both of them.
A big topic of discussion inside the company is "How should the new creations be called?" A mixture between an apple and a pear could be called an apple-pear, of course, but this doesn't sound very interesting. The boss finally decides to use the shortest string that contains both names of the original fruits as sub-strings as the new name. For instance, "applear" contains "apple" and "pear" (APPLEar and apPlEAR), and there is no shorter string that has the same property.

A combination of a cranberry and a boysenberry would therefore be called a "boysecranberry" or a "craboysenberry", for example.

Your job is to write a program that computes such a shortest name for a combination of two given fruits. Your algorithm should be efficient, otherwise it is unlikely that it will execute in the alloted time for long fruit names.

InputEach line of the input contains two strings that represent the names of the fruits that should be combined. All names have a maximum length of 100 and only consist of alphabetic characters.

Input is terminated by end of file.
OutputFor each test case, output the shortest name of the resulting fruit on one line. If more than one shortest name is possible, any one is acceptable.
Sample Input

apple peach
ananas banana
pear peach

Sample Output

appleach
bananas
pearch


求一长度最小的字符串，要包含输入的两个字符串。
最长公共子序列，不过要标记下。

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
const int N = 110;
int dp[N][N], mark[N][N], len1, len2;
char str1[N], str2[N];

void LCS(){
    memset(dp,0,sizeof(dp));
    for(int i = 0; i <= len1; i ++)
        mark[i][0] = 1;
    for(int i = 0; i <= len2; i ++)
        mark[0][i] = -1;
    for(int i = 1; i <= len1; i ++){
        for(int j = 1; j <= len2; j ++){
            if(str1[i-1] == str2[j-1]){
                dp[i][j] = dp[i-1][j-1]+1;
                mark[i][j] = 0;
            }else if(dp[i-1][j] >= dp[i][j-1]){
                dp[i][j] = dp[i-1][j];
                mark[i][j] = 1;
            }else {
                dp[i][j] = dp[i][j-1];
                mark[i][j] = -1;
            }
        }
    }
}
void printLCS(int i, int j) {
    if(!i && !j)return;
    if(mark[i][j] == 0){
        printLCS(i-1,j-1);
        printf("%c",str1[i-1]);
    }else if(mark[i][j] == 1){
        printLCS(i-1,j);
        printf("%c",str1[i-1]);
    }else {
        printLCS(i,j-1);
        printf("%c",str2[j-1]);
    }
}
int main() {
    while(scanf("%s%s",str1,str2)!=EOF){
        len1 = strlen(str1); len2 = strlen(str2);
        LCS();
        printLCS(len1,len2);
        printf("
");
    }
    return 0;
}

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

求一增子序列，并把它的值相加，总和最大的数。

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
const int N = 1010;
int dp[N], a[N], n;
int main(){
    while(scanf("%d",&n)&&n) {
        for(int i = 0; i < n; i ++) scanf("%d",&a[i]);
        int ans = 0;
        for(int i = 0; i < n; i ++) {
            dp[i] = a[i];
            for(int j = 0; j < i; j ++) {
                if(a[i] > a[j]) dp[i] = max(dp[i],dp[j]+a[i]);
            }
            ans = max(dp[i],ans);
        }
        printf("%d
",ans);
        memset(dp,0,sizeof(dp));
        memset(a,0,sizeof(a));
    }
    return 0;
}