最长单调递增子序列_最长递增子序列（动态规划 + 二分搜索）

题目

给定数组arr，返回arr的最长递增子序列

举例：arr = [2,1,5,3,6,4,8,9,7]，返回的最长递增子序列为[1,3,4,8,9]

要求：如果arr的长度为N，请实现时间复杂度为O(nlogn)的方法。

分析

这一题也是经典的动态规划，那么常规的动态规划时间复杂度为O(n^2);

如果加入二分的话，可以将动态规划优化到O(nlogn)。

解法1 O(n^2)的动态规划

了解题目以后，状态为数组的当前位置i就能决定返回值，那么dp[i]表示arr[0...i]的最长递增子序列

dp[i] = max{dp[i], dp[j]+1} (0<=j<i && arr[i]>arr[j])

// dp O(n^2)
int* getdp1(int arr[], int length){
    int* dp= new int[length];
    for(int i=0;i<length;i++){
        dp[i]=1;
        for(int j=0;j<i;j++){
            dp[i] = max(dp[i], dp[j]+1);
        }
    }
    return dp;
}

如果还需要求出递增序列的话，可以这么做：

首先我们arr从右往左找出最大值，然后根据这个最大值往前递推，满足：

• arr[j] < arr[i] && dp[i] = dp[j] +1

这种递推会推出一种特殊的情况，如果要找出所有的情况，就要再加一个循环。

解法2 O(nlogn)的动态规划

我们在上面的查找过程中，一直都是在对arr进行比较，那么可以通过空间换取时间，将递增序列保存到数组中，然后对这个数组做二分查找。

举例如下：

arr = [2,1,5,3,6,4,8,9,7]

采用ends[length+1]作为递增序列数组，right记录数组的长度

• 遍历arr数组，arr[i]
• 查询arr[i]在ends中的位置
  • 如果arr[i] 大于 ends[right]，那么直接将arr[i]加入ends，说明符合递增
  • 否则用arr[i]替代调二分查找的位置（一直更新最小的结尾数）

详细部分看代码

int* getdp2(int arr[], int length){
    int* dp = new int[length+1];
    int* ends = new int[length+1];
    ends[0] = arr[0];
    dp[0] =1;
    int right = 0;
    int l =0;
    int r = 0;
    int m =0;
    for(int i=1;i<length;i++){
        l=0;
        r=right;
        while(l<=r){
            m = l + (r-l)/2;
            if(arr[i]>ends[m]) {
                l=m+1;
            }else{
                r=m-1;
            }
        }
        right = max(l,right);
        ends[l] = arr[i];
        dp[i] = l+1;
    }
    return dp;
}

Conclusion

这一个题目的动态规划优化是采用了二分来优化，是采用空间换时间；

之前还有路径压缩，缩小空间复杂度的题目 机器人到达指定位置方法数