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

me_llamo

于 2024-08-17 14:36:51 发布

阅读量249

点赞数 6

文章标签：算法

本文链接：https://blog.csdn.net/weixin_45182267/article/details/141270805

版权

碎碎念：加油
参考：代码随想录

1143.最长公共子序列

题目链接

1143.最长公共子序列

思想

本题的公共子序列中的元素之间可以不连续。
动态规划五部曲：

确定dp数组以及下标的含义：dp[i][j]，以[0,i-1]nums1和以[0,j-1]nums2，这两个数组的最长公共子序列的长度。结果要返回dp[nums1.size-1][nums2.size-2]
确定递推公式：如果nums1[i-1]==nums2[j-1]，dp[i][j] = dp[i-1][j-1]+1; else: dp[i][j] = max(dp[i][j-1],dp[i-1][j])
dp数组的初始化：dp数组的第一行和第一列都没有意义，初始化为0
确定遍历顺序：两层for循环，遍历nums1和nums2，先遍历谁都可以，从左到右，从上到下遍历。
打印dp数组：主要用来debug。注意范围是i<nums1.size()，而不是nums1.size()-1，这点是根据我们对dp数组的定义得出的。

题解

// cpp
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-1][j], dp[i][j-1]);
            }
        }
        return dp[text1.size()][text2.size()];
    }
};

# python
class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        dp = [[0] * (len(text2) + 1) for _ in range(len(text1)+1)]
        for i in range(1, len(text1) + 1):
            for j in range(1, len(text2) + 1):
                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[len(text1)][len(text2)]

反思

1035.不相交的线

题目链接

1035.不相交的线

思想

本题其实就是求最长相同子序列。
动态规划五部曲：

确定dp数组以及下标的含义：dp[i][j]，以[0,i-1]nums1和以[0,j-1]nums2，这两个数组的最长公共子序列的长度。结果要返回dp[nums1.size-1][nums2.size-2]
确定递推公式：如果nums1[i-1]==nums2[j-1]，dp[i][j] = dp[i-1][j-1]+1; else: dp[i][j] = max(dp[i][j-1],dp[i-1][j])
dp数组的初始化：dp数组的第一行和第一列都没有意义，初始化为0
确定遍历顺序：两层for循环，遍历nums1和nums2，先遍历谁都可以，从左到右，从上到下遍历。
打印dp数组：主要用来debug。

题解

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

# python
class Solution:
    def maxUncrossedLines(self, nums1: List[int], nums2: List[int]) -> int:
        dp = [[0] * (len(nums2) + 1) for _ in range(len(nums1) + 1)]
        for i in range(1, len(nums1) + 1):
            for j in range(1, len(nums2) + 1):
                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[len(nums1)][len(nums2)]

反思

53. 最大子序和

题目链接

53. 最大子序和

思想

也可以用暴力搜索和贪心思想。
动态规划五部曲：

确定dp数组以及下标的含义：dp[i]，nums[i]为结尾的最大连续子序列的和。结果要返回dp中的最大值。
确定递推公式：dp[i] = max(dp[i-1]+nums[i], nums[i]
dp数组的初始化：dp[0]=nums[0]
确定遍历顺序：for循环从前往后遍历
打印dp数组：主要用来debug。

题解

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

# python
class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        dp = [0] * (len(nums) + 1)
        dp[0] = nums[0]
        result = dp[0]
        for i in range(1, len(nums)):
            dp[i] = max(dp[i-1]+nums[i], nums[i])
            if result < dp[i]:
                result = dp[i]
        return result

反思

注意result和dp的初始化。

392.判断子序列

题目链接

392.判断子序列

思想

注意这里是子序列，没有强调连续。本题和1143.最长公共子序列很相似。
动态规划五部曲：

确定dp数组以及下标的含义：dp[i][j]，以i-1为结尾的字符串s和j-1为结尾的字符串t，这两个字符串的最长公共子序列的长度。结果要返回dp[s.size][t.size]==s.size
确定递推公式：如果s[i-1]==t[j-1]，dp[i][j] = dp[i-1][j-1]+1; else: dp[i][j] = dp[i][j-1]
dp数组的初始化：dp数组的第一行和第一列都没有意义，初始化为0
确定遍历顺序：两层for循环，遍历s和t，先遍历谁都可以，从左到右，从上到下遍历。
打印dp数组：主要用来debug。

题解

// cpp
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() + 1; i++) {
            for (int j = 1; j < t.size() + 1; j++) {
                if (s[i-1] == t[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
                else dp[i][j] = dp[i][j-1];
            }
        }
        if (dp[s.size()][t.size()] == s.size())
            return true;
        return false;
    }
};

# python
class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        dp = [[0] * (len(t) + 1) for _ in range(len(s) + 1)]
        for i in range(1, len(s) + 1):
            for j in range(1, len(t) + 1):
                if s[i-1] == t[j-1]:
                    dp[i][j] = dp[i-1][j-1] + 1
                else:
                    dp[i][j] = dp[i][j-1]
        if dp[-1][-1] == len(s):
            return True
        return False