LeetCode300. 最长递增子序列

题目链接

https://leetcode-cn.com/problems/longest-increasing-subsequence/

解题思路

方法一：动态规划
思路与算法

定义 dp[i] 为考虑前 i 个元素，以第 i 个数字结尾的最长上升子序列的长度，注意 nums[i] 必须被选取。

我们从小到大计算 dp 数组的值，在计算 dp[i] 之前，我们已经计算出 dp[0…i−1] 的值，则状态转移方程为：dp[i]=max(dp[j])+1,其中0≤j<i且num[j]<num[i]

即考虑往 dp[0…i−1] 中最长的上升子序列后面再加一个 nums[i]。由于 dp[j] 代表 nums[0…j] 中以 nums[j] 结尾的最长上升子序列，所以如果能从 dp[j] 这个状态转移过来，那么 nums[i] 必然要大于 nums[j]，才能将 nums[i] 放在 nums[j] 后面以形成更长的上升子序列。

最后，整个数组的最长上升子序列即所有 \textit{dp}[i]dp[i] 中的最大值。

ans = max(dp[i]),其中0≤i<n

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        const int N = 2505;
        int dp[N], ans = 1; // 以索引为i结尾的序列最长长度是dp[i] 
        if(nums.size() == 0) return 0;
        for(int i = 0;i < nums.size(); i++){
            dp[i] = 1; // 子序列长度至少1 
            for(int j = 0;j < i; j++){
                if(nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1); // 更新dp[i] 
            }
            ans = max(ans, dp[i]); // 保存最大值 
        }
        return ans;
    }
};

方法二：贪心 + 二分查找
思路与算法

考虑一个简单的贪心，如果我们要使上升子序列尽可能的长，则我们需要让序列上升得尽可能慢，因此我们希望每次在上升子序列最后加上的那个数尽可能的小。

基于上面的贪心思路，我们维护一个数组 d[i] ，表示长度为 i 的最长上升子序列的末尾元素的最小值，用 len 记录目前最长上升子序列的长度，起始时 len 为 1，d[1]=nums[0]。

同时我们可以注意到 d[i] 是关于 i 单调递增的。因为如果 d[j]≥d[i] 且 j<i，我们考虑从长度为 i 的最长上升子序列的末尾删除 i-j 个元素，那么这个序列长度变为 j ，且第 j 个元素 x（末尾元素）必然小于 d[i]，也就小于 d[j]。那么我们就找到了一个长度为 j 的最长上升子序列，并且末尾元素比 d[j] 小，从而产生了矛盾。因此数组 d 的单调性得证。

我们依次遍历数组 nums 中的每个元素，并更新数组 d 和 len 的值。如果 nums[i]>d[len] 则更新 len=len+1，否则在 d[1…len] 中找满足d[i−1]<nums[j]<d[i] 的下标 i，并更新 d[i] = nums[j]。

根据 d 数组的单调性，我们可以使用二分查找寻找下标 i，优化时间复杂度。

最后整个算法流程为：

• 设当前已求出的最长上升子序列的长度为 len（初始时为 1），从前往后遍历数组 nums，在遍历到 nums[i] 时：

   如果 nums[i]>d[len] ，则直接加入到 d 数组末尾，并更新 len=len+1；
  
   否则，在 d 数组中二分查找，找到第一个比 nums[i] 小的数 d[k] ，并更新 d[k+1]=nums[i]。
  

以输入序列 [0, 8, 4, 12, 2] 为例：

• 第一步插入 0，d = [0]；
• 第二步插入 8，d = [0, 8]；
• 第三步插入 4，d = [0, 4]；
• 第四步插入 12，d = [0, 4, 12]；
• 第五步插入 2，d = [0, 2, 12]。

最终得到最大递增子序列长度为 3。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
    	const int N = 2505;
    	int len = 1, d[N];
        if(nums.size() == 0) return 0;
    	d[len] = nums[0]; // 初始化d[1]为nums[0]，因为若数组长度不为0，则len至少为1 
    	for(int i = 1;i < nums.size(); i++) {
    		if(d[len] < nums[i]) d[++len] = nums[i];
    		else {
    			int l = 1, r = len, m, pos = 0; // pos是为了保证当全部数都比nums[i]大时，将d[pos+1]赋值为nums[i] 
    			while(l <= r) {
    				m = l + r >> 1;
    				if(d[m] < nums[i]) {
    					pos = m;
    					l = m + 1;
					}
					else {
						r = m - 1;
					}
				}
				d[pos + 1] = nums[i];
			}
		}
		return len;
    }
};