leetcode72 edit distance

题目：

Given two words word1 and word2, find the minimum number of operations required to convert word1 to word2.

You have the following 3 operations permitted on a word:

Insert a character
Delete a character
Replace a character

---

错误解法：

明显没有好策略，要动态规划列举。
第一步，字母数量要对齐。
设word1，word2分别有m，n个字母，
若m > n，则要从word1中选出n个。若m < n，则互换word1和word2的地位。
第二步，再看有几个字母需要replace。
共m-n+不同字母个数个操作。
这样问题转化为从m个字母中选出n个的动态规划。
下面验证是否具有最优子结构：
假设已知从word1的前m个字母中抽n个字母的最优方案dp[m][n]，
若抽第m个，dp[m][n] = 子方案1 + m号，若存在子方案2比子方案1更优（即这样进入第二步时，不同的字母数量最少），那么子方案2+m号一定比dp[m][n]更优，因此假设不成立。
若不抽，dp[m][n] = dp[m-1][n]一定是最优。
综上，问题具备最优子结构。

• 选择状态
  dp[i][k]表示从word1的前i个数中选出k个(i>=k)，使其变为word2的前k个所需的最少操作数。
• 状态转移方程
  若选上word1的i-1号字母，则

temp1 = word1[i-1]==word2[k-1] ? dp[i-1][k-1] : (dp[i-1][k-1]+1);

若不选word1的i-1号字母，则临时方案temp2

temp2 = dp[i-1][k]+1;

最后

dp[i][k] = temp1<temp2 ? temp1 : temp2;

• 边界
  保证i>=k>=1，手动初始化
  从前i个中选0个, dp[i][0] = i;
  从前k个中选k个, dp[k][k] = word1[0~k-1]与word2[0~k-1]有多少个不同字母;
• 处理顺序
  涉及左上方、上方，处理顺序为从左到右，从上到下。直到dp[m][n]。

class Solution {
public:
    int minDistance(string word1, string word2) {
        int m=word1.length(), n=word2.length();
        if(m<n) return minDistance(word2, word1);
        int dp[m+1][n+1];
        for(int i=0; i<=m; i++) dp[i][0] = i;
        for(int k=1; k<=n; k++){
            dp[k][k] = word1[k-1]==word2[k-1] ? dp[k-1][k-1] : (dp[k-1][k-1]+1);
        }
        for(int i=2; i<=m; i++){
            for(int k=1; k<i && k<=n; k++){
                int temp1 = word1[i-1]==word2[k-1] ? dp[i-1][k-1] : (dp[i-1][k-1]+1);
                int temp2 = dp[i-1][k] + 1;
                dp[i][k] = temp1<temp2 ? temp1 : temp2;
            }
        }
        return dp[m][n];
    }
};

错误点：策略错了。对于案例
“sea”
“eat”
字母个数相等，并不是直接算不同的个数。

正确解法：经典问题-编辑距离（Edit Distance）

• 选择状态
  dp[i][j]表示word1前i个，与word2前j个的编辑距离。
• 状态转移方程
  小规模问题有3个，分别代表3种把word1的前i个变为word2的前j个的方法
  1. dp[i-1][j-1]，先把word1的前i-1个变为word2的前j-1个，最后是否需要一次replace，由word1[i-1]与word2[j-1]是否相同决定。
  2. dp[i-1][j]，只用word1的前i-1个变为word2的前j个，这时候要删掉word1[i-1]，即多1次delete操作。
  3. dp[i][j-1]，用word1的前i个只变为word2的前j-1个，最后多1次insert，插入word2[j-1]。
• 边界
  保证i,j>=1，初始化第0行，0列
  dp[i][0] = i;，i次delete
  dp[0][j] = j;，j次insert
• 处理顺序
  涉及左、上、左上方，处理顺序为从左到右，从上到下。

class Solution {
public:
    int minDistance(string word1, string word2) {
        int m=word1.length(), n=word2.length();
        int dp[m+1][n+1];
        for(int i=0; i<=m; i++) dp[i][0] = i;
        for(int j=0; j<=n; j++) dp[0][j] = j;
        for(int i=1; i<=m; i++){
            for(int j=1; j<=n; j++){
                dp[i][j] = min( min(dp[i-1][j]+1, dp[i][j-1]+1), word1[i-1]==word2[j-1]?dp[i-1][j-1]:dp[i-1][j-1]+1);
            }
        }
        return dp[m][n];
    }
};