LIS 最长递增子序列

参考：
http://www.cnblogs.com/liyukuneed/archive/2013/05/26/3090402.html
https://www.felix021.com/blog/read.php?1587
http://www.cppblog.com/mysileng/archive/2012/11/30/195841.html

问题：

给定一个长度为N的数组，找出一个最长的单调自增子序列（不一定连续，但是顺序不能乱）。例如：给定一个长度为6的数组A{5， 6， 7， 1， 2， 8}，则其最长的单调递增子序列为{5，6，7，8}，长度为4.

解法一：排序＋最长公共子序列法

仔细思考上面的问题，其实可以把上面的问题转化为求最长公共子序列的问题。原数组为A{5， 6， 7， 1， 2， 8}，下一步，我们对这个数组进行排序，排序后的数组为A‘{1， 2， 5， 6， 7， 8}。我们有了这样的两个数组后，如果想求数组A的最长递增子序列，其实就是求数组A与它的排序数组A‘的最长公共子序列。我来思考下原问题的几个要素：最长、递增、子序列（即顺序不变）。

递增：A' 数组为排序数组，本身就是递增的，保证了两序列的最长公共子序列的递增特性。

子序列：由于A数组就是原数组，其任意的子序列都是顺序不变的，这样就保证了两序列的最长公共子序列的顺序不变。

最长：显而易见。

求解过程参考这两个图：

和

解法二：动态规划法（O(N^2)）

既然是动态规划法，那么最重要的自然就是寻找子问题，对于这个问题，我们找到他的子问题：

设dp[i]表示以i为结尾的最长递增子序列的长度，则状态转移方程为：
dp[i] = max{dp[j] + 1}, 1 <= j < i, a[j] < a[i].

这样，想求ai结尾的最大递增子序列的长度，我们就需要遍历i之前的所有位置j（0到i-1），找出a[j] < a[i]，计算这些j中，能产生最大L[j]的j，之后就可以求出L[i]。之后我对每一个A[N]中的元素都计算以他们各自结尾的最大递增子序列的长度，这些长度的最大值，就是我们要求的问题——数组A的最大递增子序列。

时间复杂度：由于每一次都要与之前的所有i做比较，这样时间复杂度为O(N^2)。

解法三：动态规划法（O(NlogN)）

上面的解法时间复杂度仍然为O(N^2)，与解法一没有明显的差别。仔细分析一下原因，之所以慢，是因为对于每一个新的位置i都需要遍历i之前的所有位置，找出之前位置中最长递增子序列长度。那么我们是不是可以有一种方法能不用遍历之前所有的位置，而可以更快的确定i的位置呢？

假设存在一个序列d[1..9] = 2 1 5 3 6 4 8 9 7，可以看出来它的LIS长度为5。下面一步一步试着找出它。

这就需要申请一个长度为N的空间，B[N]，用变量len记录现在的最长递增子序列的长度。

B数组内任意元素B[i]，记录的是最长递增子序列长度为i的序列的末尾元素的值，也就是这个最长递增子序列的最大元素的最小值。

首先，把d[1] = 2有序地放到B里，令B[1] = 2，就是说当只有1一个数字2的时候，长度为1的LIS的最小末尾是2。这时Len=1

然后，把d[2] = 1有序地放到B里，令B[1] = 1，就是说长度为1的LIS的最小末尾是1，d[1]=2已经没用了，很容易理解吧。这时Len=1

接着，d[3] = 5，d[3]>B[1]，所以令B[1+1]=B[2]=d[3]=5，就是说长度为2的LIS的最小末尾是5，很容易理解吧。这时候B[1..2] = 1, 5，Len＝2

再来，d[4] = 3，它正好加在1,5之间，放在1的位置显然不合适，因为1小于3，长度为1的LIS最小末尾应该是1，这样很容易推知，长度为2的LIS最小末尾是3，于是可以把5淘汰掉，这时候B[1..2] = 1, 3，Len = 2

继续，d[5] = 6，它在3后面，因为B[2] = 3, 而6在3后面，于是很容易可以推知B[3] = 6, 这时B[1..3] = 1, 3, 6，还是很容易理解吧？ Len = 3 了噢。

第6个, d[6] = 4，你看它在3和6之间，于是我们就可以把6替换掉，得到B[3] = 4。B[1..3] = 1, 3, 4， Len继续等于3

第7个, d[7] = 8，它很大，比4大，嗯。于是B[4] = 8。Len变成4了

第8个, d[8] = 9，得到B[5] = 9，嗯。Len继续增大，到5了。

最后一个, d[9] = 7，它在B[3] = 4和B[4] = 8之间，所以我们知道，最新的B[4] =7，B[1..5] = 1, 3, 4, 7, 9，Len = 5。

于是我们知道了LIS的长度为5。

注意，这个1,3,4,7,9不是LIS，它只是存储的对应长度LIS的最小末尾。有了这个末尾，我们就可以一个一个地插入数据。虽然最后一个d[9] = 7更新进去对于这组数据没有什么意义，但是如果后面再出现两个数字 8 和 9，那么就可以把8更新到d[5], 9更新到d[6]，得出LIS的长度为6。

然后应该发现一件事情了：在B中插入数据是有序的，而且是进行替换而不需要挪动——也就是说，我们可以使用二分查找，将每一个数字的插入时间优化到O(logN)~~~~~于是算法的时间复杂度就降低到了O(NlogN)～！

下面是三种方法的Java代码实现：
解法一

	// 转化为A[]与sorted A[]的最长公共子序列
	public static void lcs(int[] A, int[] B) {
		int M = A.length, N = B.length;
		// 结果数组和方向数组，下标从1起
		int[][] dpLen = new int[M+1][N+1];
		int[][] dpDir = new int[M+1][N+1];
		Deque<Integer> ret = new LinkedList<>();
		
		// 根据DP公式填充结果数组dpLen[]和方向数组dpDir
		for (int i = 0; i <= M; i++)	dpLen[i][0] = 0;
		for (int j = 0; j <= N; j++)	dpLen[0][j] = 0;
		
		for (int i = 1; i <= M; i++) {
			for (int j =1; j <= N; j++) {
				if (A[i-1] == B[j-1]) {
					dpLen[i][j] = 1 + dpLen[i-1][j-1];
					dpDir[i][j] = 0;  // 左上
				} else {
					int x = dpLen[i-1][j], y = dpLen[i][j-1];
					if (x >= y) {
						dpLen[i][j] = x;
						dpDir[i][j] = 1;  // 上
					} else {
						dpLen[i][j] = y;
						dpDir[i][j] = 2;  // 左
					}
				}
			}
		}
		
		// 求最长公共子序列的内容
		// 从dpLen[M][N]出发，沿着dpDir记录的方向往回找，用栈记录结果
		for (int k = dpLen[M][N], i = M, j = N; k > 0; ) {
			if (dpDir[i][j] == 0) {
				ret.push(A[i-1]);
				i--;  j--;  k--;
			} else if (dpDir[i][j] == 1) 
				i--;
			else
				j--;
		}
		
		// 输出结果
		System.out.println(dpLen[M][N]);
		while (!ret.isEmpty()) {
			if (ret.size() < dpLen[M][N])
				System.out.print(" ");
			System.out.print(ret.pop());
		}
		System.out.println();
	}

解法二

	// dp[i]表示以a[i]结尾的最大递增子序列长度
	public static void dpN2(int[] A) {
		int N = A.length;
		int[] dp = new int[N];
		int[] B = new int[N];  // 辅助变量，记录每一个dp[i]是从哪一步转移过来的,便于找到确定递增子序列的内容
		Deque<Integer> ret = new LinkedList<>();
		
		for (int i = 0; i < N; i++) {
			int mx = 0;
			B[i] = -1;
			for (int j = 0; j < i; j++) {
				if (A[j] < A[i] && dp[j] >= mx) {
					if (dp[j] > mx || (dp[j] == mx && A[j] < A[B[i]])) {
						mx = dp[j];
						B[i] = j;
					}
				}					
			}						
			dp[i] = mx + 1;
		}
		
		System.out.println(Arrays.toString(dp));
		
		// 求LIS的内容
		int k = idxOfLargest(A);
		ret.push(A[k]);
		while (B[k] != -1) {
			ret.push(A[B[k]]);
			k = B[k];
		}
		System.out.println(Arrays.toString(B));
		System.out.println(ret);

	}
	private static int idxOfLargest(int[] a) {
		int mx = 0;
		for (int i = 0; i < a.length; i++)
			if (a[i] > a[mx])	mx = i;
		return mx;
	}

解法三

    // dp[i]表示长度为i的LIS末尾元素最小值
	public static void dpNlogN(int[] A) {
		int N = A.length;
		int mxl = 0;
		int[] dp = new int[N+1];
		int[] f = new int[N];		//  f[i]: 以a[i]结尾的LIS最大长度
		Deque<Integer> ret = new LinkedList<>();
		
		dp[1] = A[0];
		for (int i = 1; i < N; i++) {
			int pos = upper_bound(dp, 1, mxl, A[i]);
			dp[pos] = A[i];
			f[i] = pos;
			if (mxl < pos)
				mxl = pos;
		}		
		System.out.println(Arrays.toString(f));

		// 结合A[]和f[]来求LIS的内容
		int i = N - 1;
		int x = mxl;
		while (f[i] != mxl)	
			i--;
		ret.push(A[i]);		// 第mxl大元素
		while (i > 0 && x >= 1) {
			if (f[--i] == x-1) {
				if (A[i] < ret.peek()) {
					ret.push(A[i]);		// 第mxl－1 .. 1大元素
					x--;
				}
			}
		}
		System.out.println(ret);
	}
	private static int upper_bound(int[] dp, int l, int r, int key) {
		// dp[]数组为空时，key直接插入在第一个位置；若
		if (dp.length == 0)
			return 1;
		if (dp[r] <= key)
			return r + 1;
		int mid;
		while (l < r) {
			mid = (l + r) / 2;
			if (dp[mid] <= key)
				l = mid + 1;
			else 
				r = mid;
		}
		return l;
	}