【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的上升子序列末尾元素的最小值。执行以下算法：

• 将子序列初始长度len设为1，将nums[0]赋值给d[len];
• 从1开始遍历nums
  • 如果nums[i]>d[len]，则将nums[i]放入d[len+1], len++;
  • 如果nums[i]<=d[len]，则使用二分查找在数组d中找到第一个比nums[i]小的数d[k]，并将d[k+1]设为nums[i];

代码如下：

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

        int len=1;
        vector<int> d(nums.size()+1, 0);
        d[len] = nums[0];
        for(int i=1; i<nums.size(); i++){
            if(nums[i]>d[len]) d[++len] = nums[i];
            else{
                int left=1, right=len, pos=0;
                while(left<=right){
                    int mid = (left+right)>>1;
                    if(d[mid]<nums[i]){
                        pos = mid;
                        left = mid+1;
                    }else{
                        right = mid-1;
                    }
                }
                d[pos+1] = nums[i];
            }
        }
        return len;
    }
};

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