Leetcode300. 最长递增子序列（CPP）

一、题目

300. 最长递增子序列
给定一个整数数组 nums ，找到其中最长严格递增子序列的长度。
子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

法一：动态规划

• 模式识别1：看到最长字眼，首先考虑使用动态规划的思想解题
• 模式识别2：指纹最优解，不问具体解，考虑使用动态规划，不能使用回溯算法来搜索具体的解
• 题型：最值型+坐标型动态规划

1.1 确定状态

• 最后一步：在最优策略中，最长严格递增子序列一定存在着最后一个元素nums[i]。
  虽然我们不知道是哪个字符，但是肯定有最后一个元素。
  那么，有了最后一个字符之后，我们发现这里存在着两种情况（考虑序列长度大于2的条件下）：

• 第一种情况：最优策略中的最后一个元素 nums[i] 小于前面一个元素 nums[i - 1]，这时最值取决于前面一个元素 nums[i - 1] 结尾的序列，这种情况不属于递增，可以直接跳过。

• 第二种情况：大于，这时候由于题目不要求子序列是连续的，因此我们需要枚举最后一个字符前面的所有元素进行比较，得到最长的递增子序列，然后加上 nums[i]。

• 由此，我们发现：

• 需要求以 nums[i - 1] 结尾的序列的最长递增子序列

• 而原问题是求以 nums[i] 结尾的序列的最长递增子序列

• 问题规模缩小了

• 状态定义：设 f[i] 是以 nums[i] 结尾的序列的最长递增子序列的长度。

• 如何设定状态？根据题目中的要求，如果是求长度，那么我们需要将状态的宾语设定为长度。

1.2 转移方程

f[i] = max( f[i], f[j] + 1) for j in [0, i) 且 nums[i] > nums[j]

1.3 初始条件和边界情况

• 初始条件：每一个元素都可以单独作为一个子序列，这时候的长度为1。
• 边界条件：情况2中 0 <= j < i，而且 nums[i] > nums[j]，满足单调性。

1.4 计算顺序

• 从小到大计算：f[0], f[1], ……, f[n -1]
• 答案：最终的答案不一定是f[n - 1]，因为我们不确定最优策略中的最后一个元素是哪个
• 因此答案为全局最大值：max（f[0], f[1], ……, f[n -1]）

1.5 编程

1.5.1 参考1

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        int result = 1;
        // 定义并初始化状态方程
        vector<int> f(n, 1);
        for (int i = 0; i < n; ++i) {
            // f[i] = 1;
            // 在子问题中,只有最后一个元素与前面的每一个元素都进行对比
            // 这里和674题的连续不同：仅仅需要比较前一个元素就能确保最长
            for (int j = 0; j < i; ++j) {
                if (nums[j] < nums[i]) {
                    f[i] = max(f[i], f[j] + 1);
                }
            }
            if (f[i] > result) {
                result = f[i];
            }
        }
        return result; 
    }
};

1.5.2 参考2：利用C++的函数求最大值

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        vector<int> f(n, 1);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < i; ++j) {
                if (nums[j] < nums[i]) {
                    f[i] = max(f[i], f[j] + 1);
                }
            }
        }
        return *max_element(f.begin(), f.end()); 
    }
};

1.6 运行结果

法二：贪心 + 二分查找

2.1 题目分析

2.2 编程

2.2.1 参考1–替换策略1

• 在 tail 数组中进行二分查找，找到第一个比nums[i] 小的数 tail[k] ，并更新tail[k+1] = nums[i]。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int len = 1, n = (int)nums.size();
        if (n == 0) {
            return 0;
        }
        vector<int> d(n + 1, 0);
        d[len] = nums[0];
        for (int i = 1; i < n; ++i) {
            if (nums[i] > d[len]) {
                d[++len] = nums[i];
            } else {
                int l = 1, r = len, pos = 0; // 如果找不到说明所有的数都比 nums[i] 大，此时要更新 d[1]，所以这里将 pos 设为 0
                while (l <= r) {
                    int mid = (l + r) >> 1;
                    if (d[mid] < nums[i]) {
                        pos = mid;
                        l = mid + 1;
                    } else {
                        r = mid - 1;
                    }
                }
                d[pos + 1] = nums[i];
            }
        }
        return len;
    }
};
// 作者：LeetCode-Solution
// 链接：https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/zui-chang-shang-sheng-zi-xu-lie-by-// leetcode-soluti/
// 来源：力扣（LeetCode）
// 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

2.2.2 参考2–替换策略2

• 用 nums[i] 覆盖掉大于它的元素中最小的那个。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> res(1);
        res[0] = nums[0];
        for(int i = 1; i < nums.size(); ++i) {
            if (nums[i] > res[res.size() - 1]) {
                res.emplace_back(nums[i]);
            }
            // 使用二分查找
            else {
                int left = 0, right = res.size() - 1;
                while (left < right) {
                    // int mid = (left + right) >> 1;
                    int mid = (left + right) / 2;
                    if (res[mid] < nums[i]) {
                        left = mid + 1;
                    }
                    else {
                        right = mid;
                    }
                }
                // 用当前元素覆盖掉 >= 它的元素中最小的那个。
                res[left] = nums[i];
            }
        }
        return res.size();
    }
};

2.2.3 参考3：借助C++的lower_bound(查找左边界，右边界)函数

• lower_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> res;
        for(auto n : nums) {
            auto lb = lower_bound(res.begin(), res.end(), n);
            if(lb == res.end()) {
                res.push_back(n);
            }
            else {
                res[lb - res.begin()] = n;
            }
        }
        return res.size();
    }
};

2.3 运行结果

1

2

3