【leetCode-DP】 72. 编辑距离

给定两个单词 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')

依然按照步骤来：

1）.定义一个能够清楚描述最优子问题的数组（明确数组描述的含义）。

2）.找出数组元素之间的关系式(状态转移方程)

3）.找出初始值

 

1).dp[i][j] 代表第一个单词的第i个字符变换到第二个单词的第j个字符需要最少的步骤

2).状态转移方程 :

    当两个字符串中的某个字符相等时既 char1[i] == char2[j] dp[i][j] = dp[i-1][j-1]

    否则,需要通过新增、修改、删除等操作转换 dp[i][j] =  min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1]))+1  { PS:其中dp[i-1][j-1]表示dp[i][j] 由修改的状态转移过来 ，dp[i-1][j] 表示第一个单词要删除 ,dp[i][j-1]表示第一个单词 新增}

3）初始化

        for(int i = 0;i <= row;i++)
                dp[i][0] = i;
        for(int i = 0;i <= col;i++)
            dp[0][i] = i;

 

code:

    public static int minDistance(String word1, String word2) {
        int row = word1.length();
        int col = word2.length();
        char[] char1 = word1.toCharArray();
        char[] char2 = word2.toCharArray();
        if (row == 0) {
            return col;
        }
        if (col == 0) {
            return row;
        }
        int dp[][] = new int[row + 2][col + 2]; //当字符串 word1 的长度为 i，字符串 word2 的长度为 j 时，将 word1 转化为 word2 所使用的最少操作次数为 dp[i] [j]。
        for(int i = 0;i <= row;i++)
            dp[i][0] = i;
        for(int i = 0;i <= col;i++)
            dp[0][i] = i;
        for(int i = 1;i <= row;i++) {
            for(int j = 1;j <= col;j++) {
                //字符串相同的话向下 无累加 移动
                if(char1[i-1] == char2[j-1]) {
                    dp[i][j] = dp[i-1][j-1];
                } else {
                    /**
                     * 修改、增加、删除
                     */
                    // 修改
                    int xg = dp[i - 1][j-1] ;
                    // 删除
                    int sc = dp[i-1][j] ;
                    // 新增
                    int xz = dp[i][j-1] ;
                    dp[i][j] = Math.min(xg,Math.min(sc,xz)) + 1;
                }
            }
        }
        for(int i = 0;i <= row ;i++){
            for(int j = 0;j <= col;j++){
                System.out.print(dp[i][j] +" ");
            }
            System.out.println();
        }
        return dp[row][col];
    }

---

 

优化

同我们之前做的DP类似，在求解的时候发现并不需要保存整个矩阵的状态，只需要保存当前行对应的列即可。但是不同之处在于在当前位置dp[i][j]的左上角还有一个状态，为了同时保存左上角的状态 解决的办法是使用两个变量temp和pre保存，在更新之前，使用temp保存dp[j]，然后dp[j]要被更新，然后将dp[j]赋值给pre，下次递推的时候，左上角的值就是pre；

 

     public int minDistance(String word1, String word2) {
        char[] chs1 = word1.toCharArray();
        char[] chs2 = word2.toCharArray();
        int[] dp = new int[word2.length() + 1]; //注意要 + 1因为一开始是空串
        for (int j = 0; j < word2.length() + 1; j++) dp[j] = j;
        char c1, c2;
        int temp, pre;
        for (int i = 1; i < word1.length() + 1; i++) {
            pre = dp[0]; //上一排的
            dp[0] = i;   //这一排新dp[0]
            for (int j = 1; j < word2.length() + 1; j++) {
                c1 = word1.charAt(i - 1);
                c2 = word2.charAt(j - 1); //注意下标对应的关系
                temp = dp[j];  // 先要保存，因为等下就更新了
                dp[j] = c1 == c2 ? pre : min(dp[j], dp[j - 1], pre) + 1;
                pre = temp;      //记得先保存一下左上角的　pre的值(在二维的dp中就是dp[i-1][j-1])
            }
        }
        return dp[word2.length()];
    }

---

加强问题(ic,dc,rc)

题目:
给定两个字符串str1和str2，再给定三个整数ic、dc和rc，分别代表插入、删除和替换一个字符的代价，返回将str1编辑成str2的最小代价。

这个问题是上面问题的加强版，不同的地方在于这里三个编辑的代价不同，所以我们要更加的清楚是哪个编辑的更新:

code:

class Solution {

    /**
     * 给定的  ic,  dc  ,rc  分别代表的是 插入，删除　取代的代价
     * 　普通二维dp
     */
    public int minDistance(String word1, String word2, int ic, int dc, int rc) {
        char[] chs1 = word1.toCharArray();
        char[] chs2 = word2.toCharArray();

        int[][] dp = new int[chs1.length + 1][chs2.length + 1];

        for (int i = 0; i < chs1.length + 1; i++) dp[i][0] = i * dc; //chs1是   , chs2是""   ->要删除
        for (int j = 0; j < chs2.length + 1; j++) dp[0][j] = j * ic; //chs1 是"" 转换成chs2   -> 要添加

        for (int i = 1; i < chs1.length + 1; i++) {
            for (int j = 1; j < chs2.length + 1; j++) {
                dp[i][j] = chs1[i - 1] == chs2[j - 1] ? dp[i - 1][j - 1]
                        : min(dp[i][j - 1] + ic, dp[i - 1][j] + dc, dp[i - 1][j - 1] + rc); //dp[i-1][j]代表的是删除了 chs1[i-1] 所以加上dc
            }
        }
        return dp[chs1.length][chs2.length];
    }

    public int min(int a, int b, int c) {
        return Math.min(Math.min(a, b), c);
    }
    
}

reference : https://blog.csdn.net/zxzxzx0119/article/details/82054807