力扣算法 Java 刷题笔记【动态规划篇 DP 子序列类型问题】hot100（三）LCS 最长公共子序列及其变形 3

文章目录

• 1. 最长公共子序列（中等）
• 2. 两个字符串的删除操作（中等）
• 3. 两个字符串的最小 ASCII 删除和（中等）

1. 最长公共子序列（中等）

https://mp.weixin.qq.com/s/ZhPEchewfc03xWv9VP3msg

地址: https://leetcode-cn.com/problems/longest-common-subsequence/
2021/12/26
做题反思：dp[] 的定义考虑初值

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int m = text1.length(), n = text2.length();
        int[][] dp = new int[m + 1][n + 1];

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; 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 - 1][j], dp[i][j - 1]);
                }
            }
        }

        return dp[m][n];
    }
}

2. 两个字符串的删除操作（中等）

地址: https://leetcode-cn.com/problems/delete-operation-for-two-strings/
2021/12/26
做题反思：

class Solution {
    public int minDistance(String word1, String word2) {
        int m = word1.length(), n = word2.length();
        int[][] dp = new int[m + 1][n + 1];

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (word1.charAt(i - 1) == word2.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 m - dp[m][n] + n - dp[m][n];
    }
}

3. 两个字符串的最小 ASCII 删除和（中等）

（2021/03/18 携程笔试）
地址: https://leetcode-cn.com/problems/minimum-ascii-delete-sum-for-two-strings/
2021/12/26
做题反思：dp[] 数组的定义， base case

class Solution {
    int[][] memo;
    public int minimumDeleteSum(String s1, String s2) {
        int m = s1.length(), n = s2.length();
        memo = new int[m][n];
        return dp(s1, 0, s2, 0);
    }

    int dp(String s1, int i, String s2, int j) {
        int res = 0;
        if (i == s1.length()) {
            for (; j < s2.length(); j++) {
                res += s2.charAt(j);
            }
            return res;
        }
        if (j == s2.length()) {
            for (; i < s1.length(); i++) {
                res += s1.charAt(i);
            }
            return res;
        }

        if (memo[i][j] != 0) {
            return memo[i][j];
        }

        if (s1.charAt(i) == s2.charAt(j)) {
            memo[i][j] = dp(s1, i + 1, s2, j + 1); 
        } else {
            memo[i][j] = Math.min(
                s1.charAt(i) + dp(s1, i + 1, s2, j),
                s2.charAt(j) + dp(s1, i, s2, j + 1));
        }

        return memo[i][j];
    }
}