ZCMU-1898 Trainsorting

题目链接：Trainsorting

题目:

Problem B: Trainsorting

Erin is an engineer. She drives trains. She also arranges the cars within each train. She prefers to put the cars in decreasing order of weight, with the heaviest car at the front of the train.

Unfortunately, sorting train cars is not easy. One cannot simply pick up a car and place it somewhere else. It is impractical to insert a car within an existing train. A car may only be added to the beginning and end of the train.

Cars arrive at the train station in a predetermined order. When each car arrives, Erin can add it to the beginning or end of her train, or refuse to add it at all. The resulting train should be as long as possible, but the cars within it must be ordered by weight.

Given the weights of the cars in the order in which they arrive, what is the longest train that Erin can make?

Input

The first line contains an integer 0 <= n <= 2000, the number of cars. Each of the following n lines contains a non-negative integer giving the weight of a car. No two cars have the same weight.  

Output

Output a single integer giving the number of cars in the longest train that can be made with the given restrictions.

Sample Input

3

1 2 3

Sample Output

3

这题感觉是第三次在训练赛遇到这题了，第一次没做来后来看了题解后就记住了也没去理解，今天第三次遇见了，还是好好理解一下LIS吧。

题目意思：一些车厢，一辆辆从头到尾开进站，进站的时候可以选择接在头或者尾，或者放弃这节，但是必须保证车厢从头到尾是从大到小的，问最长能接几节。

想到LIS和LDS这一点是不难的，也就是在这些车中，求出每个第i节车厢作为第一个入队的车往后的最长递减序列数和最长递增序列数，则ans=max(LIS[i]+LDS[i]-1)

重点是一直想不通为什么是逆序进行DP.自己手写了一段序列的LIS值发现，朴素的求法求出来的LIS[i]表示的i这个数往前的一段序列，以i为结尾的最长递增子序列长度，这样一看，不正是和我们的问题要求相反吗......那么逆序进行dp，求出来的LIS[i]自然就是以i为开头的，往后面的序列算过去的递减子序列数了，同时LDS也可以得出了。

代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
int a[2005], LIS[2005], LDS[2005];
int solve(int n)
{
    int i, j, ans = 0;
    //逆序DP求最长单调递增/递减子序列
    for(i = n; i >= 1; i--)
    {
        LIS[i] = LDS[i] = 1;//赋初始值
        for(j = n; j > i; j--)
        {
            if(a[i] > a[j])
            {
                //LDS[i]是针对顺序情况下的递减子序列，在逆序情况下就是递增
                LDS[i] = max(LDS[i], LDS[j] + 1);
            }
            else
            {
                LIS[i] = max(LIS[i], LIS[j] + 1);
            }
        }
        ans = max(ans, LIS[i] + LDS[i] - 1);
    }
    return ans;
}
int main()
{
    int n, i, j;
    while(scanf("%d", &n) != EOF)
    {
        for(i = 1; i <= n; i++)
        {
            scanf("%d", &a[i]);
        }
        cout<<solve(n)<<endl;
    }
    return 0;
}