041、子序列类型问题（labuladong）

最新推荐文章于 2024-07-16 15:03:16 发布

FKX1213

最新推荐文章于 2024-07-16 15:03:16 发布

阅读量346

点赞数

文章标签： leetcode 算法动态规划

本文链接：https://blog.csdn.net/Yora123/article/details/129137610

版权

子序列类型问题

一、经典动态规划：编辑距离

基于labuladong的算法网站，经典动态规划：编辑距离；

总结：

一般来说涉及到两个字符串的问题，需要依赖上一次的各种操作，一般使用dp table；
dp数组和dp函数：
本质上是一样的；
只不过dp数组是利用数组去体现结果值；
dp函数是在函数返回结果中体现；

[72]编辑距离

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    // 利用 dp table 进行自下而上的求解
    public int minDistance(String word1, String word2) {
        int m = word1.length();
        int n = word2.length();
        // dp[i][j] ： word1中从[0,i] 变成 word2[0,j] 所需要的最少步骤
        int[][] dp = new int[m + 1][n + 1];
        // base case
        for (int i = 1; i <= m; i++) {
            dp[i][0] = i;
        }
        for (int i = 1; i <= n; i++) {
            dp[0][i] = i;
        }
        // 开始遍历
        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];
                } else {
                    // 插入、删除、替换
                    dp[i][j] = min(
                            dp[i][j - 1] + 1,// 添加
                            dp[i - 1][j] + 1,// 删除
                            dp[i - 1][j - 1] + 1// 替换
                    );
                }
            }
        }
        return dp[m][n];
    }

    int min(int a, int b, int c) {
        return Math.min(a, Math.min(b, c));
    }
}
//leetcode submit region end(Prohibit modification and deletion)

二、动态规划设计：最大子数组

基于labuladong的算法网站，动态规划设计：最大子数组；

力扣第53题，最大子数组和；

[53]最大子数组和

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    // dp table
    public int maxSubArray(int[] nums) {
        int length = nums.length;
        // 需要明确dp数组的定义，dp[i]：以nums[i]为结尾时，最大连续子数组的最大和
        int[] dp = new int[length];
        // base case
        dp[0] = nums[0];
        for (int i = 1; i < length; i++) {
            dp[i] = Math.max(nums[i], dp[i - 1] + nums[i]);
        }
        // 遍历得到最大值
        int res = Integer.MIN_VALUE;
        for (int i = 0; i < length; i++) {
            if (dp[i] > res) {
                res = dp[i];
            }
        }
        return res;
    }
}
//leetcode submit region end(Prohibit modification and deletion)

三、经典动态规划：最长公共子序列

基于labuladong的算法网站，经典动态规划：最长公共子序列；

1、最长公共子序列

力扣第1143题，最长公共子序列；

[1143]最长公共子序列

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    // dp table
    public int longestCommonSubsequence(String text1, String text2) {
        int m = text1.length();
        int n = text2.length();
        // dp[i][j] 代表字符串 text1[0,i] 和 text2[0,j] 的最长公共子序列长度
        int[][] dp = new int[m + 1][n + 1];
        // base case
        for (int i = 0; i <= m; i++) {
            dp[m][0] = 0;
        }
        for (int i = 0; i <= n; i++) {
            dp[0][n] = 0;
        }
        // 开始遍历子串
        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][j - 1], dp[i - 1][j]);
                }
            }
        }
        // 返回
        return dp[m][n];
    }

    int max(int a, int b, int c) {
        return Math.max(a, Math.max(b, c));
    }
}
//leetcode submit region end(Prohibit modification and deletion)

2、两个字符串的删除操作

力扣第583题，两个字符串的删除操作;

[583]两个字符串的删除操作

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    /**
     * @param word1
     * @param word2
     * @return 返回使得 word1 和 word2 相同所需的最小步数
     */
    public int minDistance(String word1, String word2) {
        int length = get(word1, word2);
        return word1.length() + word2.length() - length - length;
    }

    // 求 word1 和 word2 的最长公共子序列
    int get(String word1, String word2) {
        int m = word1.length();
        int n = word2.length();

        int[][] dp = new int[m + 1][n + 1];

        for (int i = 0; i <= m; i++) {
            dp[m][0] = 0;
        }
        for (int i = 0; i <= n; i++) {
            dp[0][n] = 0;
        }

        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 dp[m][n];
    }
}
//leetcode submit region end(Prohibit modification and deletion)

3、两个字符串的最小ASCII删除和

力扣第712题，两个字符串的最小ASCII删除和；

[712]两个字符串的最小ASCII删除和

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public int minimumDeleteSum(String s1, String s2) {
        int m = s1.length();
        int n = s2.length();
        // dp[i][j] 使字符串 s1[0,i] 和 s2[0,j] 两个相等所需要删除的字符的 ASCII 值的最小和
        int[][] dp = new int[m + 1][n + 1];
        // base case
        for (int i = 1; i <= m; i++) {
            dp[i][0] = dp[i - 1][0] + s1.charAt(i - 1);
        }
        for (int i = 1; i <= n; i++) {
            dp[0][i] = dp[0][i - 1] + s2.charAt(i - 1);
        }
        // 开始遍历
        for (int i = 1; i <= m; i++) {
            int code1 = s1.charAt(i - 1);
            for (int j = 1; j <= n; j++) {
                int code2 = s2.charAt(j - 1);
                // 判断此时两个字母是否相等
                if (code1 == code2) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = Math.min(dp[i - 1][j] + code1, dp[i][j - 1] + code2);
                }
            }
        }

        return dp[m][n];
    }
}
//leetcode submit region end(Prohibit modification and deletion)

四、动态规划之子序列问题解题模板

基于labuladong的算法网站，动态规划之子序列问题解题模板；

1、最长回文子序列

力扣第516题，最长回文子序列；

[516]最长回文子序列

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    // 可以看成两个字符串，找最长公共子序列的长度
    public int longestPalindromeSubseq(String s) {
        StringBuffer sb = new StringBuffer();
        int length = s.length();
        for (int i = length - 1; i >= 0; i--) {
            sb.append(s.charAt(i));
        }
        return get(s, sb.toString());
    }

    int get(String word1, String word2) {
        int m = word1.length();
        int 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 dp[m][n];
    }
}
//leetcode submit region end(Prohibit modification and deletion)

2、让字符串成为回文串的最少插入次数

力扣第1312题，让字符串成为回文串的最少插入次数；

[1312]让字符串成为回文串的最少插入次数

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public int minInsertions(String s) {
        StringBuffer sb = new StringBuffer();
        int length = s.length();
        for (int i = length - 1; i >= 0; i--) {
            sb.append(s.charAt(i));
        }
        int max = get(s, sb.toString());
        return length - max;
    }

    int get(String word1, String word2) {
        int m = word1.length();
        int 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 dp[m][n];
    }
}
//leetcode submit region end(Prohibit modification and deletion)