二刷代码随想录训练营Day 44|力扣1143.最长公共子序列、1035.不相交的线、53. 最大子序和、392.判断子序列

1.最长公共子序列

视频讲解：动态规划子序列问题经典题目 | LeetCode：1143.最长公共子序列_哔哩哔哩_bilibili

代码随想录

 代码：

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        vector<vector<int>> dp(text1.size() + 1,vector<int>(text2.size() + 1, 0));
        // dp[i][j] 下标为[0,i - 1]的text1和下标为[0,j - 1]的text2子数组的最长公共子序列的长度
        for(int i = 1; i <= text1.size(); i++){
            for(int j = 1; j <= text2.size(); j++){
                if(text1[i - 1] == text2[j - 1]){
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }else{
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[text1.size()][text2.size()];
    }
};

note：

这道题我想过可不可以和之前的子序列问题一样，定义以text1[i]和text2[j]结尾的最长子序列的长度作为dp数组的含义，但是很明显在遍历的时候时间复杂度太高了。而且这道题和那道递增的题也是有区别的，因为此题只要有元素相等就可以直接在原有的子序列的基础上添加元素，但是递增子序列的判断就是得对每一个之前的子序列分别进行判断比较的，不然不满足“递增”这个概念。 

dp数组的含义：dp[i][j] 表示下标为[0,i - 1]的text1和下标为[0,j - 1]的text2子数组的最长公共子序列的长度

递推公式：如果此时遍历的元素相等，就dp[i - 1][j - 1] + 1，如果不等，就max(dp[i - 1][j]，dp[i][j - 1])

dp数组的初始化：全部初始化为0就好了。因为第一行和第一列本来就没有意义，直接赋值为0不影响后续计算即可。而其他的元素都会被重新覆盖，初始化成多少都可以。

遍历顺序：正序，后面的元素依赖前面的元素

2.不相交的线

视频讲解：动态规划之子序列问题，换汤不换药 | LeetCode：1035.不相交的线_哔哩哔哩_bilibili

代码随想录

代码：

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        vector<vector<int>> dp(nums1.size() + 1,vector<int>(nums2.size() + 1,0));

        for(int i = 1; i <= nums1.size(); i++){
            for(int j = 1; j <= nums2.size(); j++){
                if(nums1[i - 1] == nums2[j - 1]){
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }else{
                    dp[i][j] = max(dp[i - 1][j],dp[i][j - 1]);
                }
            }
        }
        return dp[nums1.size()][nums2.size()];
    }
};

note：和上题是一样的。就是得自己想到不相交其实就是要求子序列。

3.最大子序和

视频讲解：看起来复杂，其实是简单动态规划 | LeetCode：53.最大子序和_哔哩哔哩_bilibili

代码随想录

代码：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        vector<int> dp(nums.size(),0);
        dp[0] = nums[0];
        int result = dp[0];
        for(int i = 1; i < nums.size(); i++){
            dp[i] = max(dp[i - 1] + nums[i], nums[i]);
            if(dp[i] > result) result = dp[i];
        }
        return result;
    }
};

 dp数组的含义：以下标i作为结尾的子序列的最大子序和为dp[i]

递推公式：对于每一个以下标i作为结尾的连续子序列，对于和的计算，有两种取值——一个是接着前面的求值加上此元素，一个是从当前位置重新开始计算。dp[i] = max(dp[i - 1] + nums[i], nums[i])

dp数组的初始化：dp[0] = nums[0]，因为按照定义来，dp[0]里必须包含nums[0]

遍历顺序：正序遍历。

要注意！！还是要用result存住最大值的！！因为我们的dp数组有限制结尾的元素，所以并不是最终真正的最大子序和！！

4.判断子序列

视频讲解：动态规划，用相似思路解决复杂问题 | LeetCode：392.判断子序列_哔哩哔哩_bilibili

代码随想录 (programmercarl.com)

代码：

class Solution {
public:
    bool isSubsequence(string s, string t) {
        vector<vector<int>> dp(s.size() + 1,vector<int>(t.size() + 1,0));
        // dp[i][j]表示下标为[0,i - 1]的s子数组和[0,j - 1]的t子数组的最长公共子序列的长度
        for(int i = 1; i <= s.size(); i++){
            for(int j = 1; j <= t.size(); j++){
                if(s[i - 1] == t[j - 1]){
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }else{
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[s.size()][t.size()] == s.size();
    }
};

 note：

其实可以转换成求两个字符串的最长公共子序列的长度，如果这个长度等于要判断的子序列的长度，返回true；反之则是false。