最长递增子序列

最长递增子序列的序列长度dp过程看：Leetcode 300 题 最长递增子序列

不用二分查找，时间复杂度是O(n^2)
用了二分查找，时间复杂度是O(nlogn)

import java.util.*;


public class Solution {
    /**
     * 最长递增子序列
     * @param arr int整型一维数组 the array
     * @return int整型一维数组
     */
    public static int[] LIS (int[] arr) {
        if(null == arr || arr.length <= 1){
            return arr;
        }
        //	dp[i] 表示包含arr[i]的最长递增子序列的长度
        int[] dp = new int[arr.length];
        //	二分查找辅助数组，有序
        int[] last = new int[arr.length];
        //	当前有序长度（描述last）
        int end = 0;
        last[0] = arr[0];
        for(int i = 1; i < arr.length; ++i){
        	//	这里用后面的两段代码来替换：暴力 or 二分
			//	要查找这么一个位置，arr[i] < arr[j] && (dp[j]是0~j里最大的那个)
			//	然后将其加1赋给dp[i]
        }
        
        System.out.println(Arrays.toString(dp));

		//	回溯出结果
		//	回溯的思想
		//		1，从右向左找到dp中最大值最靠右的位置
		//		2，从最大值位置向左遍历，比如最大值为4，取出当前位置的arr元素，
		//			然后向左遍历找第一值为3的，取出值
		//			接着找第一个值为2的，...，最后就找到了所有元素。
        int[] res = new int[end + 1];
        for(int i = dp.length - 1, j = end; i >= 0; --i){
            if(dp[i] == j){
                res[j--] = arr[i];
            }
        }

        return res;
    }
}

暴力查找的方式

            for(int j = i - 1; j >= 0; --j){
                if(arr[i] >= arr[j] && dp[j] >= dp[i]){
                    dp[i] = dp[j] + 1;
                }
            }

二分查找的方式
last数组只是为了快速找到dp[i]的值
在last有序数组中，该元素的下标就是它的dp值

			int left = 0, right = end + 1;
            while(left < right){
                int mid = left + (right - left) / 2;
                if(arr[i] > last[mid]){
                    left = mid + 1;
                }else{
                    right = mid;
                }
            }
            last[left] = arr[i];
            //  最后一个数比它大
            if(left == end + 1){
                ++end;
            }
            dp[i] = left;