动态规划之最长非降子序列

输入数据

输入的第一行是序列的长度N(1 <= N <= 1000)。第二行给出序列中的N 个整数，这些整数的取值范围都在0到10000。

输出要求

最长上升子序列的长度。

输入样例

7

17 3 5 9 4 8

输出样例

4

n如何把这个问题分解成子问题呢？经过分析，发现“求以ak（k=1, 2, 3…N）为终点的最长上升子序列的长度”是个好的子问题――这里把一个上升子序列中最右边的那个数，称为该子序列的“终点”。虽然这个子问题和原问题形式上并不完全一样，但是只要这N个子问题都解决了，那么这N个子问题的解中，最大的那个就是整个问题的解。

n由上所述的子问题只和一个变量相关，就是数字的位置。因此序列中数的位置k 就是“状态”，而状态 k对应的“值”，就是以ak做为“终点”的最长上升子序列的长度。这个问题的状态一共有N个。状态定义出来后，转移方程就不难想了。 

n假定MaxLen(k)表示以ak 做为“终点”的最长上升子序列的长度，那么：

nMaxLen(1) = 1

nMaxLen(k) = Max { MaxLen (i)：1<i< k 且 ai < ak 且 k≠1} + 1

n这个状态转移方程的意思就是，MaxLen(k)的值，就是在ak 左边，“终点”数值小于ak，且长度最大的那个上升子序列的长度再加1。因为ak 左边任何“终点”小于ak 的子序列，加上ak 后就能形成一个更长的上升子序列。

n实际实现的时候，可以不必编写递归函数，因为从 MaxLen(1)就能推算出MaxLen(2)，有了MaxLen(1)和MaxLen(2)就能推算出MaxLen(3)……

import java.util.Scanner;

public class Main {
    static Scanner scin = new Scanner(System.in);

    public static void main(String[] args) {
        int size = scin.nextInt();
        int[] all = new int[size];
        int[] max = new int[size];// 记录每个点作为end节点的最长非降序列的长度
        int[] route = new int[size];// 记录线路，int[size]记录size点线路的上一个节点
        max[0] = 1;
        int i = 0, j = 0, t = 0, pre = 0;
        for (; i < size; i++)
            all[i] = scin.nextInt();
        System.out.println("max[" + 0 + "]=" + 1);
        for (i = 1; i < size; i++) {
            t = 0;
            pre = 0;
            for (j = 0; j < i; j++) {
                if (all[j] < all[i] && t < max[j]) {
                    t = max[j];
                    pre = j;
                }

            }
            route[i] = pre;
            max[i] = t + 1;
            System.out.println("max[" + i + "]=" + max[i]);
        }
        j = 0;
        t = 0;
        for (i = 1; i < size; i++) {
            if (j < max[i]) {
                j = max[i];
                t = i;
            }
        }
        System.out.println("length:" + j);
        System.out.println("line is blow:");
        System.out.println(t);
        while (t > 0) {
            System.out.println(route[t]);
            t = route[t];
        }
    }
}