leetcode每日一题系列-两个字符串的删除操作-「序列DP+LCS」-「序列DP」

626 阅读2分钟

leetcode-583-两个字符串的删除操作

[博客链接]

菜🐔的学习之路

掘金首页

[题目链接]

题目链接

[github地址]

github地址

[题目描述]

给定两个单词 word1 和 word2,找到使得 word1 和 word2 相同所需的最小步数,每步可以删除任意一个字符串中的一个字符。

 

示例:

输入: "sea", "eat" 输出: 2 解释: 第一步将"sea"变为"ea",第二步将"eat"变为"ea"  

提示:

给定单词的长度不超过500。 给定单词中的字符只含有小写字母。

思路一:序列DP+LCS

  • 很容易转换成求最长公共子序列的问题
  • 最后返回的就是n-max+m-max
  • n和m表示两个字符串长度
  • max表示子序列长度
  • dp[i][j]表示第一个字符串前i位和第二个字符串前j位的最长公共子序列
  • 转移过程可以根据s1[i] s2[j]的判断关系来决定
    • 如果s1[i] == s2[j] dp[i][j] = dp[i-1][j-1] +1
    • 否则dp[i][j] = max(dp[i-1][j]+1,dp[i][j-1]+1)
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 - 1][j], dp[i][j - 1]);
                    }
                }
            }
            return m - dp[m][n] + n - dp[m][n];
        }

  • 时间复杂度O(m*n)
  • 空间复杂度O(m*n)

思路二:序列DP

  • 第二种可以选择更加直接的dp定义
  • dp[i][j]表示一个字符串前i位和第二个字符串前j位形成相同字符串需要的操作次数
  • 初始化dp[i][0] = i dp[0][j] = j
  • 转移方程也是分为两种情况
    • 如果s1[i] == s2[j] dp[i][j] = dp[i-1][j-1]
    • 否则dp[i][j] = min(dp[i-1][j]+1,dp[i][j-1]+1)+1
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 = 0; i <= m; i++) {
        dp[i][0] = i;
    }
    for (int i = 0; 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] = Math.min(dp[i - 1][j], dp[i][j - 1]) + 1;
            }
        }
    }
    return dp[m][n];
}
  • 时间复杂度O(m*n)
  • 空间复杂度O(m*n)