最长单调递增子序列的求法

package algorithm.apps;

/**
 * 最长单调递增子序列的求法　LIS
 * 
 * @author Toy
 */
public class LIS {

	/**
	 * 动态规划(n^2),记表备查 b[0,n-1]记录以a[i]结尾的最长递增子序列长度
	 * 
	 * @param a
	 * @return
	 */
	public int lis_01(int[] a) {

		int n = a.length;
		if (n <= 0) {
			return 0;
		}

		int max = 0;
		int[] b = new int[n];
		b[0] = 1;
		for (int i = 1; i < n; i++) {
			int ki = 0;
			for (int j = 0; j < i; j++) {
				if (a[i] >= a[j] && ki < b[j]) {
					ki = b[j];
				}
			}
			b[i] = ki + 1;
		}

		for (int i = 0; i < n; i++) {
			if (b[i] > max) {
				max = b[i];
			}
		}

		return max;
	}

	/**
	 * 动态规划(n*log n),记表备查 k是序列a[0:i]的最长递增子序列的长度 b[k]是a[0:i]中所有长度为 k
	 * 的单调递增子序列中的最小结尾元素值 则可知b是单调递增的
	 * 
	 * @param a
	 * @return
	 */
	public int lis_02(int[] a) {

		int n = a.length;
		if (n <= 0) {
			return 0;
		}

		int[] b = new int[n];
		b[1] = a[0];
		int k = 1;
		for (int i = 1; i < n; i++) {
			if (a[i] >= b[k]) {
				b[++k] = a[i];
			} else {
				b[binary(a, i, b, k)] = a[i];
			}

		}

		return k;
	}

	/**
	 * 在数组b[0:k]中找到a[i]的存放位置,满足 b[j-1]<=a[i]<b[j];
	 * 
	 * @param a
	 * @param i
	 * @param b
	 * @param k
	 * @return
	 */
	private int binary(int[] a, int i, int[] b, int k) {

		if (a[i] < b[1]) {
			return 1;
		}

		int m = 1;
		int n = k;
		while (m != n - 1) {
			int mid = (m + n) / 2;
			if (b[mid] <= a[i]) {
				m = mid;
			} else {
				n = k;
			}
		}
		return n;
	}

	/**
	 * 第一种思路在状态转移时的复杂度为o(n),即在找a[k]前面满足a[j]<a[k]的最大b[j]时采用的是顺序查找的方法，复杂度为o(n).
	 * 设想如果能把顺序查找改为折半查找，则状态转移时的复杂度为o(lg(n)),于是产生方法二的思想
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		int[] a = new int[] { 5, 2, 3, 1, 4, 6, 6, 7 };
		LIS s = new LIS();
		int max_01 = s.lis_01(a);
		System.out.println("method 01: " + max_01);
		int max_02 = s.lis_02(a);
		System.out.println("method 02: " + max_02);
	}

}