动态规划系列之「最长递增子序列」

给定一个无序的整数数组，找到其中最长上升子序列的长度。

注意： 这里没要求子序列连续。

示例：

输入：[10, 9, 2, 5, 3, 7, 101, 18]
输出：4
解释：最长的上升子序列是[2, 3, 7, 101]，长度为4

说明：

• 可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。
• 算法的时间复杂度应该为O(n^2)

进阶：

• 你能将算法的时间复杂度降到O(nlgn)吗？

方法一： 动态规划

思路：

首先要定义 dp 数组的含义：dp[i] 表示以 nums[i] 这个数结尾的最长递增子序列的长度。

比如：

index	0	1	2	3	4	5
nums	1	4	3	4	2	3
dp	1	2	2	3	2	?

算法演进的过程如下：

根据这个定义，我们的最终结果（子序列的最大长度）应该是 dp 数组中的最大值，即：

int res = 0;
for(int i = 0; i < dp.length; i++){
  	res = Math.max(dp[i], res);
}
return res;

求状态转移方程：

根据刚才我们对 dp 数组的定义，现在想求 dp[5] 的值，也就是想求以 nums[5] 为结尾的最长递增子序列。

nums[5] = 3，既然是递增子序列，我们只要找到前面那些结尾比 3 小的子序列，然后把 3 接到最后，就可以形成一个新的递增子序列，而且这个新的子序列长度加一。

当然，可能形成很多种新的子序列，但是我们只要最长的，把最长子序列的长度作为 dp[5] 的值即可。

$$dp[5]=max\{\begin{array}{l}dp[0]+1,nums[0]=1<nums[5]\\ dp[4]+1,nums[4]=2<nums[5]\end{array}$$

最终状态转移方程为：

d p [ n ] = m a x { d p [ i ] + 1 , i ∈ [ 0 , n − 1 ] a n d n u m s [ i ] < n u m s [ n ] } dp[n] = max\{ dp[i] + 1, \quad i\in [0,n-1] \quad and \quad nums[i] < nums[n] \} dp[n]=max{dp[i]+1,i∈[0,n−1]andnums[i]<nums[n]}

base case为1，dp 数组应该全部初始化为 1，因为子序列最少也要包含自己，所以长度最小为 1。

import java.util.*;

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

时间复杂度：O(n^2)

空间复杂度：O(n)

方法二： 二分查找思想

至于二分查找的思想可以看这篇文章动态规划设计之最长递增子序列

class Solution {
    public int findNumberOfLIS(int[] nums) {
      	int[] top = new int[nums.length];
      	int piles = 0;
      	for(int i = 0; i < nums.length; i++){
          	int poker = nums[i];
          	int left = 0;
          	int right = piles;
          	while(left < right){
              	int mid = left + (right - left)/2;
              	if(top[mid] > poker){
                  	right = mid;
                }else if(top[mid] < poker){
                  	left = mid + 1;
                }else{
                  	right = mid;
                }
            }
          
          	if(left == piles) piles++;
          	top[left] = poker;
        }
      	return piles;
    }
}

时间复杂度：O(nlgn)

空间复杂度：O(n)