第49天-DP-第九章 ● 1143.最长公共子序列 ● 1035.不相交的线 ● 53. 最大子序和 动态规划

1. 最长公共子序列

- LeetCode链接

• 注意这里的遍历 是从 i=1, j=1开始
• 

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        // 718题的最长公共数组 要求的子元素序列是连续的， 这道题是不连续的

        // 1. dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]
        // 2. 初始化都为0
        vector<vector<int>> dp(text1.size()+1, vector<int>(text2.size()+1, 0));
        
        // 初始化的时候大小设置为 text1.size()+1 和 text2.size()+1 是为了在遍历的时候, dp[i-1][j-1]在 i=0 j=0的时候好计算
        // 3.确定递归函数
        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] = max(dp[i][j], dp[i-1][j-1] + 1);
                }else{
                    dp[i][j] = max(dp[i][j], max(dp[i-1][j], dp[i][j-1]));
                }
            }
        }
        return dp[text1.size()][text2.size()];
    }
};

2. 不相交的线 (与最长公共子序列相同)

- LeetCdde链接

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        int len1 = nums1.size(), len2 = nums2.size();
        // 也是最长公共子序列的问题
        vector<vector<int>> dp(len1 + 1, vector<int>(len2+1, 0));

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

        return dp[len1][len2];
    }
};

3. 最大子序和 (最大和的连续子数组)

- LeetCode链接

dp方法

    // 1. dp算法
    int maxSubArray(vector<int>& nums) {
        vector<int> dp(nums.size(), 0);
        int result = nums[0];
        dp[0] = nums[0];

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

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

        return result;
    }

贪心算法

    int maxSubArray(vector<int>& nums) {
        int result = INT32_MIN;      // 最小值
        int count = 0;

        // 贪心算法： 使用result记录当前遇到的最大值，当累加和count小于0的时候，直接忽略当前值，count置为0，重新开始累加
        for(int i=0; i<nums.size(); i++){
            count += nums[i];
            if(count > result) result = count;
            
            if(count <= 0) count = 0;
        }
        return result;
    }
};