动态规划Day16(编辑距离,删除元素待写完)

目录

583. 两个字符串的删除操作

看到题目的第一想法               

看到代码随想录之后的想法

自己实现过程中遇到的困难(看代码)

72. 编辑距离

看到题目的第一想法               

看到代码随想录之后的想法

自己实现过程中遇到的困难(看代码)


583. 两个字符串的删除操作

力扣题目链接(opens new window)

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

示例:

  • 输入: "sea", "eat"
  • 输出: 2
  • 解释: 第一步将"sea"变为"ea",第二步将"eat"变为"ea"
看到题目的第一想法
               

         按照求最长子序列的思路来做,得到最长的公共length值,用两个字符串的长度减去两个公共length 就是最长公共子序列的长度

        公共最长子序列的求法

        dp[i][j] 为0~i-1 0~j-1的最长序列

        递推公式

        若相同,dp[i][j] = dp[i-1][j-1]+1

        若不相同,二选一 dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]);
       

        

看到代码随想录之后的想法

        用动态规划,使用了删除的思路

        (选中两个单词的字符,判断删除哪一个)

        确定dp数组和每个下标的含义

        

        dp[i][j]记录末尾为i-1和j-1的最少删除字符的个数

        

        确定递推公式

        要从递推公式来进行考虑

       若word1[i] = word2[j] 则不管是否选中word1 和word2 和不选中word1和word2都一样,不需要新增删除的次数,总删除的次数和之前相等

                dp[i][j] = dp[i-1][j-1]; 

        若word1[i] !=word2[j] 则从之前的删除次数最小值 来考虑

                若选中word1来删除

                之前的总删除次数为dp[i-1][j]+1

        

                若选中word2来删除

                之前的总删除次数为dp[i][j-1]+1

                若都选中,两者都删

                之前的总删除次数为dp[i-1][j-1]+2

                之前的最长子序列是dp[i][j] = Math.min(dp[i-1][j]+1,dp[i][j-1]+1,dp[i-1][j-1]+2);

               

         dp数组初始化

                  因为dp[i][j] 代表0~i-1,0~j-1的最大删除次数,

                则dp[i][0] = i

                   dp[0][j] = j (含义:若把j变成0 需要删除j次)

        确定遍历顺序

        从前往后,从上往下

        举例推导dp数组           

        打印dp数组

        打印最后一个元素

自己实现过程中遇到的困难(看代码)

                        疑问?为什么选最小的?不相同时不应该两个都要删吗?
                        不是两个都要删,而是判断不相同了,一次只删一个,选择哪一个
                        两个不相等,模拟一下这个双重循环,其实i固定不变,只是在动j
                       遇到两个单词中不相等的字符,来通过dp来判断应该删除哪一个,二维数组是动态变化的
                     最小的删除个数,从之前中选择最小的

class Solution {
    public int minDistance(String word1, String word2) {
        /*
        //我的做法
        //相同的最小步数
        //其实就是看公共子序列的最大长度?,然后看删去需要多少个字符?
        //确定dp的定义和下标的含义
        // dp[i][j] 0~i-1的word1 和 0~j-1的相同公共子序列的长度
        //确定递推公式
        // 若word[i-1]==word[j-1] 则dp[i][j]=dp[i-1][j-1]+1
        // 若不相等 则dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
        //dp数组初始化
        // 都为0
        //确定遍历顺序
        // 从上往下,从左至右
        //打印dp数组
        int[][] dp = new int[word1.length()+1][word2.length()+1];
        for(int i=1;i<=word1.length();i++){
            for(int j=1;j<=word2.length();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]);
                }
            }
        }
        int maxLength = dp[word1.length()][word2.length()];
        return word1.length()+word2.length()-2*maxLength;*/
        //卡哥的做法
        //确定dp的定义和下标的含义
        // dp[i][j] 代表删除字符的最小的个数
        //确定递推公式
        // 如何删除
        // word1[i-1]==word2[j-1] 若相等 考虑选中word1[i-1] 和word2[j-1] 和不选中word1[i-1]和word2[j-1]
        // dp[i][j] = dp[i-1][j-1],因为相等,所以 都考虑和都不考虑,最小删除的个数都是一样的
        // word1[i]!=word2[j] 若不相等 ,考虑最小删除的个数,有三种情况
        // 若不选中word1 则为 dp[i-1][j]+1
        // 若不选中word2 则为 dp[i][j-1]+1
        // 若不都选中 dp[i-1][j-1] +2 去三者中的最小值
        //dp数组初始化
        // dp[i][0] = i word1 有值,word2为空串 
        // dp[0][j] = j word2 有值,word1为空串
        //确定遍历顺序
        // 从上往下,从左至右
        //打印dp数组
        int dp[][] = new int[word1.length()+1][word2.length()+1];
        for(int i=0;i<=word1.length();i++){
            dp[i][0] = i;
        }
        for(int j=0;j<=word2.length();j++){
            dp[0][j] = j;
        }
        for(int i=1;i<=word1.length();i++){
            for(int j=1;j<=word2.length();j++){
                if(word1.charAt(i-1)==word2.charAt(j-1)){
                    dp[i][j] = dp[i-1][j-1];
                }else{
                    // 疑问?为什么选最小的?不相同时不应该两个都要删吗?
                    // 不是两个都要删,而是判断不相同了,一次只删一个,选择哪一个
                    // 两个不相等,模拟一下这个双重循环,其实i固定不变,只是在动j
                    // 看两个单词中不相等的字符,来看通过dp来判断应该删除哪一个,二维数组是动态变化的
                    //最小的删除个数,从之前中选择最小的
                    dp[i][j] = Math.min(dp[i-1][j]+1,dp[i][j-1]+1);
                }
            }
        }
        return dp[word1.length()][word2.length()];
    }
}

72. 编辑距离

力扣题目链接(opens new window)

给你两个单词 word1 和 word2,请你计算出将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作:

  • 插入一个字符

  • 删除一个字符

  • 替换一个字符

  • 示例 1:

  • 输入:word1 = "horse", word2 = "ros"

  • 输出:3

  • 解释: horse -> rorse (将 'h' 替换为 'r') rorse -> rose (删除 'r') rose -> ros (删除 'e')

  • 示例 2:

  • 输入:word1 = "intention", word2 = "execution"

  • 输出:5

  • 解释: intention -> inention (删除 't') inention -> enention (将 'i' 替换为 'e') enention -> exention (将 'n' 替换为 'x') exention -> exection (将 'n' 替换为 'c') exection -> execution (插入 'u')

提示:

  • 0 <= word1.length, word2.length <= 500
  • word1 和 word2 由小写英文字母组成
看到题目的第一想法
               

       按上一题的思路来做

        

看到代码随想录之后的想法

        用动态规划,使用了删除的思路

        (选中两个单词的字符,判断删除哪一个)

        确定dp数组和每个下标的含义

        

        dp[i][j]记录末尾为i-1和j-1的最少删除字符的个数

        

        确定递推公式

        要从递推公式来进行考虑

       若word1[i] = word2[j] 则不管是否选中word1 和word2 和不选中word1和word2都一样,不需要新增删除的次数,总删除的次数和之前相等

                dp[i][j] = dp[i-1][j-1]; 

        若word1[i] !=word2[j] 则从之前的删除次数最小值 来考虑

                若选中word1来删除

                之前的总删除次数为dp[i-1][j]+1

        

                若选中word2来删除

                之前的总删除次数为dp[i][j-1]+1

                若都选中,两者都删

                之前的总删除次数为dp[i-1][j-1]+2

                之前的最长子序列是dp[i][j] = Math.min(dp[i-1][j]+1,dp[i][j-1]+1,dp[i-1][j-1]+2);

               

         dp数组初始化

                  因为dp[i][j] 代表0~i-1,0~j-1的最大删除次数,

                则dp[i][0] = i

                   dp[0][j] = j (含义:若把j变成0 需要删除j次)

        确定遍历顺序

        从前往后,从上往下

        举例推导dp数组           

        打印dp数组

        打印最后一个元素

自己实现过程中遇到的困难(看代码)

                        疑问?为什么选最小的?不相同时不应该两个都要删吗?
                        不是两个都要删,而是判断不相同了,一次只删一个,选择哪一个
                        两个不相等,模拟一下这个双重循环,其实i固定不变,只是在动j
                       遇到两个单词中不相等的字符,来通过dp来判断应该删除哪一个,二维数组是动态变化的
                     最小的删除个数,从之前中选择最小的

你可能感兴趣的:(动态规划,算法)