最长上升子序列

两个思路，

第一个，所求子序列，必然以某一个元素结尾，求出所有元素结尾的最长子序列，挑一个最大的，就可以了。辅助数组存的是对应下标的元素的最长值。

第二个，辅助数组存的是对应长度的最小值，可以反证法证明，长度越大的最小元素值，大于长度比他小的最小元素值。因此，该辅助数组是单调递增的，可以二分，提高效率。

public class LIS {

	private int[] a;
	private int[] b;
	
	public LIS(int[] a){
		assert(a != null);
		assert(a.length>0);
		this.a = a;
		b = new int[a.length];
	}
	
	/**
	 * The max subsequence must be ended with one(or several) of the array,  
	 * To find the max subsequence, is to find all the max subsequences ending with each array member, and choose
	 * the max value in them. That is the result.
	 * @return
	 */
	public int find(){
		//the max counts of subsequence equals the b.length.
		int max = 1;
		/*for the a[i], to generate the max sub ending with a[i], which item appeared before 
		should the a[i] follow? 
		so we need an array to record all the happened counts.
		b[n] stands the min ending value in all the possible max subsequences 
		happened before whose length are all (n-1). 
		why is ONLY the min ending value saved? because for the next following item, the ending value
		 smaller means the new item will easier to follow to generate a longer subsequence. 
		 b has 2 characteristic.
		1) the index is the max length.
		2) b is sorted well naturally.
		*/
		b[0] = a[0];
		//find the max sub each one by one, ending with a[i]
		for(int i=1; i<a.length-1; i++){
			//find the right place in array b, make the subsequence ending with a[i] has the max length.
			int position = search(a[i], b, 0, max-1);
			//if exceed the max, add it directly.
			if(position == (max-1)){
				b[max] = a[i];
				max++;
			}
			if(a[i] < b[position+1]){
				b[position+1] = a[i];
			}
		}
//		print(b, 0, max-1);
		return max;
	}
	
	public int find2(){
		for(int i=0; i<a.length; i++){
			int max = 1;
			for(int j=0; j<i; j++){
				if(a[j] < a[i]){
					int temp = b[j] + 1;
					if(temp > max){
						max = temp;
					}
				}
			}
			b[i] = max;
		}
		int result = 1;
		for(int k=0; k<b.length; k++){
			if(b[k] > result){
				result = b[k];
			}
		}
		return result;
	}
	/**
	 * find the right place in array b, make the subsequence ending with a[i] has the max length.
	 * @param value
	 * @param b
	 * @return
	 */
	public int search(int value, int[] b, int left, int right){
		assert(b != null);
		if(value <= b[left]){
			return -1;
		}
		if(value > b[right]){
			return right;
		}
		return binarySearch(value, b, left, right);
	}
	/**
	 * Find the closest item in array b which is less than the value.  and return its index.
	 * @param value
	 * @return 
	 */
	private int binarySearch(int value, int[] b, int left, int right){
		//why always return "right"?
		if(left > right){
			return right;
		}
		int index = (left+right)/2;
		int mid = b[index];
		if(mid == value){
			return index-1;
		}else if(value > mid){
			return binarySearch(value, b, index+1, right);
		}else{
			return binarySearch(value, b, left, index-1);
		}
	}
	
	public void print(int[] b, int left, int right){
		for(int i=left; i<=right; i++){
			System.out.print(b[i] + " ");
		}
		System.out.print("\r");
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] a = {7,2,4,8,3,5,1,9,6};
		LIS seq = new LIS(a);
		int max = seq.find();
//		int max = seq.find2();
		System.out.println(max);
		
		
	}

}