严格递增和非严格递增最长递增子序列长度

严格递增

最长递增子序列，给定一个无序整数数组nums（字符串也可以，不重要），给出最长严格递增子序列的长度。比如输入[1, 2 , 1, -1, 1, 4, 0]，输出3，最长递增子序列[1, 2, 4]，当然可能不唯一，[-1, 1, 4]也是一个，但是并不影响长度。
强行遍历就不说了，时间复杂度O(2^n)，简直爆炸。
思路1：动态规划，建立一个数组dp，dp[i]记录nums[0:i]的最长递增子序列的长度。
d p [ i ] = m a x ( d p [ j ] + 1 ) ， j ∈ { j ∣ n u m s [ j ] &lt; n u m s [ i ] , 0 &lt; = j &lt; i } dp[i] = max(dp[j]+1)，j∈\{ j | nums[j] &lt; nums[i], 0 &lt;= j &lt; i\} dp[i]=max(dp[j]+1)，j∈{j∣nums[j]<nums[i],0<=j<i}
输出max(dp)即可，时间复杂度O(n^2)，空间复杂度O(n)。

public int maxLengthCSub(int[] nums) {
	if(nums == null) {
		return 0;
	}
	int len = nums.length;
	if(len == 0 || len == 1) {
		return len;
	}
	int maxLen = 1;
	int[] dp = new int[len];
	for(int i = 0; i < len; i++) {
		dp[i] = 1;
		for(int j = 0; j < i; j++) {
			if(nums[i] > nums[j]) {
				dp[i] = Math.max(dp[i], dp[j]+1);  // 更新dp[i]
				maxLen = Math.max(maxLen, dp[i]);  // 更新最大值
			}
		}
	}
	return maxLen;
}

思路2：动态规划+二分查找
同样建立一个数组dp，但是这里dp记录的是上升子序列，遍历nums室，用nums的元素填充dp，填充规则是什么呢？首先利用二分查找找到nums[i]在dp中应该插入的位置j，若j==当前dp的长度，则在dp末尾插入nums[i]，maxLen加一，否则dp[j]=nums[i]。这里可能有个疑问，比如说nums[i0]=1放入dp[1]，在后面的遍历中有一个nums[i1]=-1也需要放入dp[1]，此时不会影响长度的计算吗？答案是不会，用一个例子比较容易理解。

input:[1, 2 , 1, -1, 1, 4, 0]
dp:[1], maxLen = 1
dp:[1, 2], maxLen = 2
dp:[1, 2], maxLen = 2
dp:[-1, 2], maxLen = 2
dp:[-1, 1], maxLen = 2
dp:[-1, 1, 4], maxLen = 3
dp:[-1, 0, 4], maxLen = 3

这里[-1, 0, 4]虽然不是一个最长递增子序列，但是并不会影响maxLen的值。
时间复杂度O(nlgn)，空间复杂度O(n)。

public int maxLengthCSub(int[] nums) {
	if(nums == null) {
   		return 0;
   	}
 	if(nums.length == 0 || nums.length == 1){
         return nums.length;
    }
    int[] dp = new int[nums.length];
    int maxLen = 0;
    for(int i = 0; i < nums.length; i++){
        int index = findIndex(dp, maxLen, nums[i]);
        dp[index] = nums[i];
        if(index == maxLen)
            maxLen++;
    }
    return maxLen;
}
// 二分查找，找到target在nums[0:len-1]的插入位置
public int findIndex(int[] nums, int len, int target){
    if(len == 0)
        return 0;
    int low = 0;
    int high = len;
    if(target <= nums[low])
        return 0;
    if(target > nums[len-1])
        return len;
    while(low < high){
        int middle = low + (high-low)/2;
        if(target > nums[middle]) // 右边
            low = middle + 1;
        else 
            high = middle;
    }
    return low;
}

非严格递增

思路1：同严格递增的思路1，只需要在比较的时候加个等号：
d p [ i ] = m a x ( d p [ j ] + 1 ) ， j ∈ { j ∣ n u m s [ j ] &lt; = n u m s [ i ] , 0 &lt; = j &lt; i } dp[i] = max(dp[j]+1)，j∈\{ j | nums[j] &lt;= nums[i], 0 &lt;= j &lt; i\} dp[i]=max(dp[j]+1)，j∈{j∣nums[j]<=nums[i],0<=j<i}
思路2：基本类似严格递增的思路1，但是这里插入的规则是要变的，不再是用二分查找插入dp，其插入位置要保证
$$dp[i-1]<=dp[i]<dp[i+1]$$
边界情况这里就不分析了，程序里也不需要进行分析，只需要求出i即可，同样求出i==maxLen，maxLen加一。还是通过一个例子来看。

input:[1, 2 , 1, -1, 1, 4, 0]
dp:[1], maxLen = 1
dp:[1, 2], maxLen = 2
dp:[1, 1], maxLen = 2
dp:[-1, 1], maxLen = 2
dp:[-1, 1, 1], maxLen = 3
dp:[-1, 1, 1, 4], maxLen = 4
dp:[-1, 0, 1, 4], maxLen = 4

看出不一样来了吧，主要是1的插入位置，不在是替换掉前面的1，而是在前面的1的后面放入新的1。

public int maxLengthCSub(int[] nums) {
   	if(nums == null) {
   		return 0;
   	}
   	int len = nums.length;
   	if(len == 0 || len == 1) {
   		return len;
   	}
   	int[] dp = new int[len];
   	int maxLen = 0;
   	for(int i = 0; i < len; i++) {
   		int tmp = findIndex(dp, maxLen, nums[i]); // 无重复数字时的插入位置
   		int tmp2 = findRIndex(dp, tmp, nums[i]);  // 有重复数字时的插入位置
   		tmp = tmp2 == -1 ? tmp:tmp2;
   		dp[tmp] = nums[i];
   		if(tmp == maxLen)
   			maxLen++;
   	}
   	return maxLen;
   }
// 同严格递增
// 二分查找，找到target在nums[0:len-1]的插入位置
public int findIndex(int[] nums, int len, int target){
    if(len == 0)
        return 0;
    int low = 0;
    int high = len;
    if(target <= nums[low])
        return 0;
    if(target > nums[len-1])
        return len;
    while(low < high){
        int middle = low + (high-low)/2;
        if(target > nums[middle]) // 右边
            low = middle + 1;
        else 
            high = middle;
    }
    return low;
}
// 返回-1时，正常使用二分查找即可
public int findRIndex(int[] nums, int low, int tar) {
	if(low >= nums.length || low < 0)
		return -1;
	if(nums[low] != tar) { // 说明没有重复值
		return -1;
	}
	int high = low + 1;
	while(high < nums.length && nums[high] == nums[low]) {
		high++;
	}
	return high;
}