代码随想录算法训练营第四十四天|最长公共子序列、不相交的线、最大子数组和、判断子序列

最长公共子序列 leetcode 1143

写法一：dp数组是以i和j结尾的最长公共子序列

dp数组含义：text1以i为尾和text2以j为尾的最长公共子序列长度为dp[i][j]。

递推公式：当text1[i]==text2[j]时，dp[i][j]=dp[i-1][j-1]+1。如果当前两个字符相同，那么两个字符串数组各回退一位加一如果是求最长公共连续子序列递推公式此时就可以结束了，但题目要求可以不连续，所以当text1!=text2时，dp[i][j]=max(dp[i-1][j],dp[i][j-1])，这样如果之前有公共的子序列的长度就可以延申保存下来。

初始化：对于第一行，当text1[0]==text2[j]时，从j开始之后包括j全部初始化为1。对于第一列，当text1[i]==text2[0]时从i开始之后包括i全部初始化为1。其余格子初始化为0。

遍历顺序：根据递推公式，遍历顺序应该从上到下，从左到右，text1和text2先遍历哪个都可以。

结果保存：每更新一次dp数组，就要更新一次res。

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        vector<vector<int>> dp(text1.size(),vector<int>(text2.size(),0));
        int res=0;
        for(int i=0;i<text2.size();i++){
            if(text1[0]==text2[i]){
                res=1;
                for(int m=i;m<text2.size();m++){
                    dp[0][m]=1;
                }
            }
        }
        for(int j=0;j<text1.size();j++){
            if(text1[j]==text2[0]){
                res=1;
                for(int n=j;n<text1.size();n++){
                    dp[n][0]=1;
                }
            }  
        }
        for(int i=1;i<text1.size();i++){
            for(int j=1;j<text2.size();j++){
                if(text1[i]==text2[j]) dp[i][j]=dp[i-1][j-1]+1;
                else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                res=max(res,dp[i][j]);
            }
        }
        return res;
    }
};

写法二：dp数组是以i-1和j-1结尾的最长公共子序列

dp数组含义：text1以i-1为尾和text2以j-1为尾的最长公共子序列长度为dp[i][j]。

递推公式：当text1[i-1]==text2[j-1]时，dp[i][j]=dp[i-1][j-1]+1。如果当前两个字符相同，那么两个字符串数组各回退一位加一如果是求最长公共连续子序列递推公式此时就可以结束了，但题目要求可以不连续，所以当text1!=text2时，dp[i][j]=max(dp[i-1][j],dp[i][j-1])，这样如果之前有公共的子序列的长度就可以延申保存下来。

初始化：由递推公式dp[i][j]可以由dp[i-1][j-1]、dp[i-1][j]、dp[i][j-1]得到，所以第一行和第一列需要初始化。对于第一行，dp[0][j]也就是text2和一个空的字符串的最长公共子序列为多少那肯定是0，同理第一列也初始化为0。其余格子也初始化为0。

遍历顺序：根据递推公式，遍历顺序应该从上到下，从左到右，text1和text2先遍历哪个都可以。

结果保存：每更新一次dp数组，就要更新一次res。

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        vector<vector<int>> dp(text1.size()+1,vector<int>(text2.size()+1,0));
        int res=0;
        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]);
                res=max(res,dp[i][j]);
            }
        }
        return res;
    }
};

两种写法

最大的不同就是初始化，第二种写法初始化要简介一点，还有就是定义dp数组的大小要大一圈。

不相交的线 leetcode 1035

本题可以转化为，求nums1和nums2的最长公共不连续子序列，与上一题一模一样。

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        vector<vector<int>> dp(nums1.size()+1,vector<int>(nums2.size()+1,0));
        int res=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]);
                res=max(res,dp[i][j]);
            }
        }
        return res;
    }
};

最大子数组和 leetcode 53

dp数组含义：以i为结尾的nums[i]的最大子数组的和为dp[i]。

递推公式：两种情况，一种是延续前面的子序列，dp[i-1]+nums[i]，另一种是从i开始重新产生一个子序列，nums[i]，则递推公式为dp[i]=max(dp[i-1]+nums[i],nums[i])。

初始化：dp[0]=nums[0]。其余格子初始化为0。

遍历顺序：从前向后。

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

判断子序列 leetcode 392

不要求连续，本题可以由最长公共子序列转换而来，判断s是不是t的子序列，那么就求s和t的最长公共子序列长度，如果等于s的长度那么s就是t的子序列。

class Solution {
public:
    bool isSubsequence(string s, string t) {
        vector<vector<int>> dp(s.size()+1,vector<int>(t.size()+1,0));
        if(s.size()==0) return true;
        if(t.size()==0) return false;
        int res=0;
        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]);
                res=max(res,dp[i][j]);
            }
        }
        if(res==s.size()) return true;
        return false;
    }
};