最长递增子序列（编程之美）

public class TheLargestIncreamentSubSequnece {
	public static void main(String[] args) {
		 int a[]={1,-1,2,-3,4,-5,6,-7};
		//int a[] = { 1, -5, -4, 2, 3, 4, 5, 6, -3, -2, -1, 2, 3 };
		// System.out.println(theLargestIncreamentSubSequence(a));
		System.out.println(theLargestIS(a));
	}

	private static int theLargestIS(int[] a) {
		// TODO Auto-generated method stub
		int low, high, mid;
		int LIS[] = new int[a.length];//存放最大递增子序列的最末元素
		LIS[0] = -100000;// 把LIS[0]设为最小假设数组中的数都大于LIS[0];
		LIS[1] = a[0];//初始时，最大递增子序列长度为1的最末元素为a1
		int len = 1;//最长递增子数组的初始长度
		
		for (int i = 1; i < a.length; i++) {
			low = 0;
			high = len;
			/*
			 * 在第二种算法中，在计算每一个f(i)时，都要找出最大的f(j)(j<i)来，由于f(j)没有顺序，
			 * 只能顺序查找满足aj<ai最大的f(j)，如果能将让f(j)有序，就可以使用二分查找，
			 * 这样算法的时间复杂度就可能降到O(nlogn)。于是想到用一个数组B来存储“子序列的”最大递增子序列的最末元素，
			 * 即有
				B[f(j)] = aj
				在计算f(i)时，在数组B中用二分查找法找到满足j<i且B[f(j)]=aj<ai的最大的j,
				并将B[f[j]+1]置为ai
			 */
			while (low <= high) {//二分查找最末元素小于ai+1的长度最大的最大递增子序列；
				
				mid = (low + high) >> 1;
				if (LIS[mid] < a[i])
					low = mid + 1;
				else {
					high = mid-1;
				}
				
			}
			LIS[low]=a[i];//将长度为p的最大递增子序列的当前最末元素置为ai+1;
			if(low>len)len++;//更新当前最大递增子序列长度；
		}
		for(int i=0;i<LIS.length;i++)
		{
			System.out.print(LIS[i]+"  ");
		}
		System.out.println();
		for(int i=1;i<=len;i++)
		{
			System.out.print(LIS[i]+"  ");
		}
		System.out.println();//时间复杂度为O(Nloglen);
		return len;
	}

	private static int theLargestIncreamentSubSequence(int[] a) {
		// TODO Auto-generated method stub
		int LIS[] = new int[a.length];
		for (int i = 0; i < a.length; i++) {
			LIS[i] = 1;
			for (int j = 0; j < i; j++) {
				if (a[i] > a[j] && LIS[j] + 1 > LIS[i]) {
					LIS[i] = LIS[j] + 1;
				}
			}
		}
		int max = LIS[0];
		for (int i = 1; i < LIS.length; i++) {
			if (LIS[i] > max) {
				max = LIS[i];
			}
		}
		return max;
	}
//时间复杂度为O(n^2)
}