代码随想录算法训练营第五十七天 | LeetCode 1143、1035、53

---

前言

LeetCode题目：LeetCode 1143、1035、53
Takeaway：动态规划的子序列系列问题，不要被有些题的描述吓住

---

一、1143

动态规划的子序列系列问题，元素不是连续的，所以DP状态转移公式是 max()

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        
        // 边界值处理
        if(text1.size() == 1 && text2.size() == 1){
            if(text1[0] == text2[0]) {
                return 1;
            }else {
                return 0;
            }
        }

        // DP数组含义：以 i-1 和 j-1 结尾的数组，最大公共子序列是多长
        vector<vector<int>> dp(text1.size()+1, vector(text2.size()+1, 0));

        int ans = 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]); //这里这么写主要是因为，子序列可以不连续
                }

                if(dp[i][j]>ans){
                    ans = dp[i][j];
                }
            }
        }

        return ans;
    }
};

---

二、1035

看起来吓人，其实本质和上一道题是一模一样的，都是求最长公共求子序列，换了个说法而已，码都是一样的。

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        // 边界值处理
        if(nums1.size() == 1 && nums2.size() == 1){
            if(nums1[0] == nums2[0]) {
                return 1;
            }else {
                return 0;
            }
        }

        // DP数组含义：以 i-1 和 j-1 结尾的数组，最大公共子序列是多长
        vector<vector<int>> dp(nums1.size()+1, vector(nums2.size()+1, 0));

        int ans = 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]); //这里这么写主要是因为，子序列可以不连续
                }

                if(dp[i][j]>ans){
                    ans = dp[i][j];
                }
            }
        }

        return ans;
    }
};

---

三、53

动态规划的子序列系列问题，元素不是连续的，所以DP状态转移公式是 max()，搞清楚状态转移公式是什么就简单了。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {

        if(nums.size() == 1){
            return nums[0];
        }

        // DP初始化，DP数组的含义是：以第 i 个元素为结尾的最大子数组和
        vector<int> dp(nums.size(), 0);

        dp[0] = nums[0];
        int ans = dp[0];

        for(int i=1; i<nums.size(); i++){
            dp[i] = max(dp[i - 1] + nums[i], nums[i]);
            if (dp[i] > ans) {
                ans = dp[i];
            }
        }

        return ans;
    }
};

---

总结

动态规划的子序列系列问题，感觉和之前的股票问题区别不是很大，不要被有些题的描述吓住。