代码随想录算法训练营Day44||Leetcode1143.最长公共子序列 、 1035.不相交的线 、 53. 最大子序和 、392.判断子序列

一、最长公共子序列

        这题与上面重复子数组的区别是这题可以有间断，正是因为允许有间断，这题的递推公式多了一种情况，也就是在间断处，nums1[i-1]!=nums2[j-1]的时候，从[i-1][j]和[i][j-1]两个方向推过来继承的，虽然递推公式麻烦了，但是最后返回的结果可以直接返回最后一个元素了

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

               
            }
        }

        return dp[text1.size()][text2.size()];
    }
};

二、不相交的线

        和上一题一样，只不过把字符串换成了数组

        对于为什么能想到是一样的，结合题解这样理解：

        

不能交叉，所以  上1   后边的  上4只能找  下1 后边的元素，而上4后面的上5 不能在 下1,4之间再找，体现了一个次序性，跟最长公共子序列异曲同工

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()];
    
    
    } 
};

 三、最大子数组和

        （一）dp数组含义：到第i个之前，最大子数组的和

        （二）递推公式：dp[i]=dp[i-1]+nums[i]或dp[i]=nums[i]

        （三）初始化，result为nums[0]

        （四）遍历顺序：从前到后

        （五）打印dp数组

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

            if(result<dp[i])result=dp[i];
        }

        return result;
    }
};

四、判断子序列

        最长公共子序列的变形题，即判断长字符串中与短字符串公共的最长子序列是否等于短字符串长度即可，可以把最长公共子序列看做一个长字符串的一个子集，看看这个子集长度是否等于短字符串长度，从而推出前者属于后者的子集

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