一句话总结：秒了。

原题链接：1143 最长公共子序列

与昨天的最长重复子数组极度类似。 由于这里是子序列，两者不相等时有dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j])。同时由于子序列的缘故，dp数组及下标的含义也有了改变：以text1[i]和text2[j]结尾的最长子序列长度，因此最终结果即dp[m][n]。除此之外完全一致。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        char[] ca1 = text1.toCharArray(), ca2 = text2.toCharArray();
        int m = ca1.length, n = ca2.length;
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 1; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (ca1[i - 1] == ca2[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
                else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
        return dp[m][n];
    }
}

原题链接：1035 不相交的线

与上一题完全一致，代码少量修改即可。

class Solution {
    public int maxUncrossedLines(int[] nums1, int[] nums2) {
        int m = nums1.length, n = nums2.length;
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 1; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (nums1[i - 1] == nums2[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
                else dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
            }
        }
        return dp[m][n];
    }
}

 原题链接：53 最大子数组和

本题此前已经有过贪心做法：

class Solution {
    public int maxSubArray(int[] nums) {
        int pre = 0, ans = Integer.MIN_VALUE;
        for (int x : nums) {
            if (pre < 0) pre = x;
            else pre += x;
            ans = Math.max(ans, pre);
        }
        return ans;
    }
}

 现在要用动规做法，如下动规五部曲：

1. 确定dp数组及下标的含义：以nums[i]为结尾的子数组的最大值；
2. 确定状态转移方程：dp[i] = Math.max(dp[i - 1] + nums[i], nums[i])，即要么该子序列为当前数值，要么加入之前的子序列；
3. dp数组初始化：dp[0] = nums[0]；
4. 确定遍历顺序：由于dp[i]由dp[i - 1]转移而来，可见需从前往后遍历；
5. 举例推导dp数组。

最终代码如下：

class Solution {
    public int maxSubArray(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        dp[0] = nums[0];
        int ans = nums[0];
        for (int i = 1; i < n; ++i) {
            dp[i] = Math.max(nums[i], dp[i - 1] + nums[i]);
            ans = Math.max(ans, dp[i]);
        }
        return ans;
    }
}