最长递增子序列（来源力扣）

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

进阶：
你能将算法的时间复杂度降低到 O(n log(n)) 吗?

class Solution {
    public int lengthOfLIS(int[] nums) {
        int n = nums.length;
        if(n == 0) return 0;
        int[] dp = new int[n];
        dp[0] = nums[0];
        int pos = 0;
        for(int i = 1; i < n; i++) {
            if(dp[pos] < nums[i]) {
                dp[++pos] = nums[i];
            } else {
                //二分查找找到满足dp[j - 1] < nums[i] < dp[j]的位置j，用nums[i]替换掉dp[j];
                //简言之，就是找到第一个>=nums[i]的数并替换掉！
                int l = 0;
                int r = pos;
                while(l <= r) {
                    int mid = l + (r - l) / 2;
                    if(dp[mid] < nums[i]) {
                        l = mid + 1;
                    } else {
                        r = mid - 1;
                    }
                }
                dp[l] = nums[i];
            }
        }
        return pos + 1;
    }
}

第二种方法：

class Solution {
	public int lengthOfLIS(int[] nums) {
		if(nums.length == 0) {
			return 0;
		}
		int[] dp = new int[nums.length];
		int maxans = 1;
		dp[0] = 1;
		for(int i = 1; i < nums.length; i++) {
			dp[i] = 1;
			for(int j = 0; j < i; j++) {
				if(nums[j] < nums[i]) {
					dp[i] = Math.max(dp[i], dp[j] + 1);
				}
			}
			maxans = Math.max(maxans, dp[i]);
		}
		return maxans;
	}
}