【LeetCode-动态规划】最长上升子序列

题目描述

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

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

题目链接： https://leetcode-cn.com/problems/longest-increasing-subsequence/

思路1

使用动态规划。假设给定的数组为nums，令dp[i]表示以nums[i]为结尾的最长上升子序列的长度，则dp[i] = max(dp[i], dp[j]+1)，j在[0, i-1]范围内，且nums[j]<nums[i]。代码如下：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if(nums.empty()) return 0;

        vector<int> dp(nums.size(), 0);
        //dp[0] = 1;
        for(int i=0; i<nums.size(); i++){
            dp[i] = 1;
            for(int j=0; j<i; j++){
                if(nums[j]<nums[i]){
                    dp[i] = max(dp[j]+1, dp[i]);
                }
            }
        }
        return *max_element(dp.begin(), dp.end());
    }
};

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

思路2

使用贪心和二分查找。
如果我们想要上升子序列尽可能的长，则我们需要让子序列上升的越慢，因此我们想让每次加入到子序列最末尾的那个数尽可能的小。所以，我们设置一个数组d[]，d[i]表示长度为i的上升子序列末尾元素的最小值。执行以下算法：

• 将子序列放入数组 dp 中，初始时，dp 中只包含 nums[0] 一个元素；
• 从下标 1 开始遍历nums：
  • 如果 nums[i] > dp.back()（dp 的最后一个元素），则将 nums[i] 放入 dp 的尾部;
  • 否则，则使用二分查找在数组 dp 中找到第一个比 nums[i] 大的数 dp[k]，并将 dp[k] 设为 nums[i];

代码如下：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if(nums.size()<2) return nums.size();

        vector<int> dp({nums[0]});
        for(int i=1; i<nums.size(); i++){
            if(nums[i]>dp.back()){
                dp.push_back(nums[i]);
                continue;
            }

            int left = 0;
            int right = dp.size()-1;
            while(left<right){
                int mid = left+(right-left)/2;
                if(dp[mid]<nums[i]) left = mid+1;
                else right = mid;
            }
            dp[left] = nums[i];
        }
        return dp.size();
    }
};

• 时间复杂度：O(nlogn)
  遍历需要O(n)，每次遍历需要O(logn)二分查找，所以为O(nlogn)
• 空间复杂度：O(n)

参考

思路 2 参考了 https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/zui-chang-shang-sheng-zi-xu-lie-dong-tai-gui-hua-e/ 。