Day53 | 1143.最长公共子序列, 1035.不相交的线, 53. 最大子序和(动态规划)

Day53 | 1143.最长公共子序列, 1035.不相交的线, 53. 最大子序和(动态规划)

最长公共子序列

LeetCode题目：https://leetcode.cn/problems/longest-common-subsequence/

  与要求连续的子数组不同，此时所求为公共子序列的长度，因此并不会要求长度必须连续。因此，会出现新的状态值更新情况。当满足text1[i] == text2[j]的条件时，与原先连续的情况相同，继承i-1和j-1状态时的长度值。当不满足状态时，该位置的状态则由两个状态决定：dp[i - 1][j]和dp[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 - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[text1.size()][text2.size()];
    }
};

不相交的线

LeetCode题目：https://leetcode.cn/problems/uncrossed-lines/

  不相交的线，其实就可以看做是求最长的的子序列，因为如果不按照顺序的话，一定会出现交叉的情况。因此直接可以看做上一道题。

  代码如下：

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

最大子序和（动态规划）

LeetCode题目：https://leetcode.cn/problems/maximum-subarray/

  在使用贪心算法求解该问题的时候，我们设置了两个值来进行状态的更新，一个用来维护当前连续数组的和，另一个维护全局的最大值。

  在使用动态规划进行状态转移时候，如果将dp作为全局的最大值来，那么会存在一个问题，即无法维护当前较小的连续和，而较小的连续和也可能在后面成为全局的最大值。dp应该代表的是数组到达下标i的时候，当前连续数组的最大值。

  因此，确定了dp数组为当前的连续数组最大值，依据贪心算法的思路，当当前连续数组的和，无法在与下一个数值的加和中提供正面影响（即加法操作后小于原值）则舍弃之前的加和。重新开始计算。因此递推公式可得到为：dp[i] = max(nums[i], dp[i - 1] + nums[i]);并且在每次更新后，维护一个全局的最大值。

  最终代码如下：

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