算法打卡：第九章 动态规划part11

今日收获：最长公共子序列，不相交的线，最大子序和，判断子序列

1. 最长公共子序列

题目链接：1143. 最长公共子序列 - 力扣（LeetCode）

思路：

（1）dp[i][j]表示两个字符串中下标为 i-1 和 j-1 的字符之前相等的字符个数。

（2）初始化：第一行和第一列均初始化为0

（3）遍历顺序：从上到下从左到右遍历

（4）递推公式：如果两个字符相等，则dp[i][j]等于两个字符串前一个字符的dp值加1。两个字符不相等，则当前位置等于两个字符串分别前移一位的最大值。

方法：

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int len1=text1.length();
        int len2=text2.length();

        int[][] dp=new int[len1+1][len2+1];
        for (int i=1;i<=len1;i++){
            for (int j=1;j<=len2;j++){
                if (text1.charAt(i-1)==text2.charAt(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[len1][len2];
    }
}

2. 不相交的线

题目链接：1035. 不相交的线 - 力扣（LeetCode）

思路：和上一道题思路相同。

方法：

class Solution {
    public int maxUncrossedLines(int[] nums1, int[] nums2) {
        int len1=nums1.length;
        int len2=nums2.length;

        int[][] dp=new int[len1+1][len2+1];

        for (int i=1;i<=len1;i++){
            for (int j=1;j<=len2;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[len1][len2];
    }
}

3. 最大子序和

题目链接：53. 最大子数组和 - 力扣（LeetCode）

思路：

（1）dp数组表示下标为 i 及之前数组的连续最大和

（2）初始化dp数组的第一个元素为数组的一个元素

（3）遍历顺序：从数组的第二个数组开始，从左到右遍历

（4）递推公式：当前dp数组的值等于前一个位置的值加上当前元素的值和当前元素的值取最大值。（如果之前元素的值加上当前元素值小于当前元素本身，不如从当前元素开始累加）

方法：

class Solution {
    public int maxSubArray(int[] nums) {
        int len=nums.length;

        int[] dp=new int[len];

        dp[0]=nums[0];

        int max=dp[0];  // 最后一位不一定是最大子数组和
        for (int i=1;i<len;i++){
            dp[i]=Math.max(dp[i-1]+nums[i],nums[i]);
            max=Math.max(max,dp[i]);
        }

        return max;
    }
}

4. 判断子序列

题目链接：392. 判断子序列 - 力扣（LeetCode）

思路：和最长公共子序列思路类似。最后再判断

（1）dp[i][j]表示两个字符串中下标为 i-1 和 j-1 的字符之前相等的字符个数。

（2）初始化：第一行和第一列均初始化为0

（3）遍历顺序：从上到下从左到右遍历

（4）递推公式：如果两个字符相等，则dp[i][j]等于两个字符串前一个字符的dp值加1。两个字符不相等，则当前位置等于长字符串前移一位的值。

方法：

class Solution {
    public boolean isSubsequence(String s, String t) {
        int len1=s.length();
        int len2=t.length();

        int[][] dp=new int[len1+1][len2+1];

        for (int i=1;i<=len1;i++){
            for (int j=1;j<=len2;j++){
                if (s.charAt(i-1)==t.charAt(j-1)){
                    dp[i][j]=dp[i-1][j-1]+1;
                }else {
                    dp[i][j]=dp[i][j-1];
                }
            }
        }

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

五. 总结

        动态规划每选一步都和最终的结果有关。根据题目要求的值可以推断出dp数组的定义，通常就是每一小步代表的题目所求值。