最长上升子序列

题目链接
给定一个长度为N的数列，求数值严格单调递增的子序列的长度最长是多少。

输入格式

第一行包含整数N。

第二行包含N个整数，表示完整序列。

输出格式

输出一个整数，表示最大长度。

数据范围

1≤N≤1000，
−109≤数列中的数≤109

输入样例：

7
3 1 2 1 8 5 6

输出样例：

4

算法一 ： 普通dp

时间复杂度：O(n^2)
转移方程：dp[i] = Math.max(dp[i],dp[j] + 1)

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];
        for(int i = 0; i < n; i++){
            a[i] = sc.nextInt();
        }
        int[] dp = new int[n+1];
        for(int i = 0; i < n; i++){
            dp[i] = 1;
            for(int j = 0; j < i; j++){
                if(a[i] > a[j]){
                    dp[i] = Math.max(dp[i],dp[j] + 1);
                }
            }
        }
        int max = -1;
        for(int i = 0; i < n; i++){
            max = Math.max(max,dp[i]);
        }
        System.out.println(max);
    }
}

算法二 ：贪心+二分

思路：

新建一个 low 数组，low [ i ]表示长度为i的LIS结尾元素的最小值。对于一个上升子序列，显然其结尾元素越小，越有利于在后面接其他的元素，也就越可能变得更长。因此，我们只需要维护 low 数组，对于每一个a[ i ]，如果a[ i ] > low [当前最长的LIS长度]，就把 a [ i ]接到当前最长的LIS后面，即low [++当前最长的LIS长度] = a [ i ]。
那么，怎么维护 low 数组呢？
对于每一个a [ i ]，如果a [ i ]能接到 LIS 后面，就接上去；否则，就用 a [ i ] 取更新 low 数组。具体方法是，在low数组中找到第一个大于等于a [ i ]的元素low [ j ]，用a [ i ]去更新 low [ j ]。如果从头到尾扫一遍 low 数组的话，时间复杂度仍是O(n^2)。我们注意到 low 数组内部一定是单调不降的，所有我们可以二分 low 数组，找出第一个大于等于a[ i ]的元素。二分一次 low 数组的时间复杂度的O(lgn)，所以总的时间复杂度是O(nlogn)。

我们再举一个例子：有以下序列A[ ] = 3 1 2 6 4 5 10 7，求LIS长度。

我们定义一个B[ i ]来储存可能的排序序列，len 为LIS长度。我们依次把A[ i ]有序地放进B[ i ]里。

 （为了方便，i的范围就从1~n表示第i个数）

A[1] = 3，把3放进B[1]，此时B[1] = 3，此时len = 1，最小末尾是3

A[2] = 1，因为1比3小，所以可以把B[1]中的3替换为1，此时B[1] = 1，此时len = 1，最小末尾是1

A[3] = 2，2大于1，就把2放进B[2] = 2，此时B[ ]={1,2}，len = 2

同理，A[4]=6，把6放进B[3] = 6，B[ ]={1,2,6}，len = 3

A[5]=4，4在2和6之间，比6小，可以把B[3]替换为4，B[ ] = {1,2,4}，len = 3

A[6] = 5，B[4] = 5，B[ ] = {1,2,4,5}，len = 4

A[7] = 10，B[5] = 10，B[ ] = {1,2,4,5,10}，len = 5

A[8] = 7，7在5和10之间，比10小，可以把B[5]替换为7，B[ ] = {1,2,4,5,7}，len = 5
最终我们得出LIS长度为5，但是，但是！！！B[ ] 中的序列并不一定是正确的最长上升子序列。在这个例子中，我们得到的1 2 4 5 7 恰好是正确的最长上升子序列，下面我们再举一个例子：有以下序列A[ ] = 1 4 7 2 5 9 10 3，求LIS长度。
A[1] = 1，把1放进B[1]，此时B[1] = 1，B[ ] = {1}，len = 1
A[2] = 4，把4放进B[2]，此时B[2] = 4，B[ ] = {1,4}，len = 2
A[3] = 7，把7放进B[3]，此时B[3] = 7，B[ ] = {1,4,7}，len = 3
A[4] = 2，因为2比4小，所以把B[2]中的4替换为2，此时B[ ] = {1,2,7}，len = 3
A[5] = 5，因为5比7小，所以把B[3]中的7替换为5，此时B[ ] = {1,2,5}，len = 3
A[6] = 9，把9放进B[4]，此时B[4] = 9，B[ ] = {1,2,5,9}，len = 4
A[7] = 10，把10放进B[5]，此时B[5] = 10，B[ ] = {1,2,5,9,10}，len = 5
A[8] = 3，因为3比5小，所以把B[3]中的5替换为3，此时B[ ] = {1,2,3,9,10}，len = 5

最终我们得出LIS长度为5。但是，但是！！这里的1 2 3 9 10很明显并不是正确的最长上升子序列。因此，B序列并不一定表示最长上升子序列，它只表示相应最长子序列长度的排好序的最小序列。这有什么用呢？我们最后一步3替换5并没有增加最长子序列的长度，而这一步的意义，在于记录最小序列，代表了一种“最可能性”，只是此种算法为计算LIS而进行的一种替换。假如后面还有两个数据12和15，那么B[ ]将继续更新。

因为在B中插入的数据是有序的，不需要移动，只需要替换，所以可以用二分查找插入的位置，那么插入n个数的时间复杂度为〇(logn)，这样我们会把这个求LIS长度的算法复杂度降为了〇(nlogn)。

import java.util.Scanner;
public class Main {
	static int[] a = new int[1003];
	static int[] heap = new int[1005];
	static int Binary_Search(int[] heap, int r, int x) {
		int i = 1;
		while(i <= r) {
			int mid = (r + i)>>1;
			if(heap[mid] <= x) {
				i = mid + 1;
			}else {
				r = mid - 1;
			}
		}
		return i;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		for(int i = 1; i <= n; i++) {
			a[i] = sc.nextInt();
			heap[i] = Integer.MAX_VALUE;
		}
		heap[1] = a[1];
		int len = 1;
		for(int i = 2; i <= n; i++) {
			if(heap[len] < a[i]) {
				heap[++len] = a[i];
			}else {
				heap[Binary_Search(heap,len,a[i])] = a[i];
			}
		}
		System.out.println(len);
	}
}