用动态规划解决单词变形

问题

给定2个string，比如 horse 和 rosh, 第一个string最少需要经过多少变换步骤才能变成第二个string？
变换步骤有3种：

1. Insert变换： 在任意位置插入一个字符
2. Delete变换： 删除任意位置的一个字符
3. Replace变换： 替换任意位置的一个字符

就以 horse 和 rosh 为例，转换过程如下：

1. horse -> rorse: 将 h 替换成 r
2. rorse -> rose: 删除第二个 r
3. rore -> rosh: 将 e 替换成 h

思路

这个问题一看就是动态规划的路子。但是，如何思考呢？
首先，由简单到复杂地来看：
从一个空串，如何变换到一个字符的string呢？ 增加一个字符即可。
从一个空串，如何变换到n个字符的string呢？一次一个地增加n个字符。
从一个拥有n个字符的字符串，如何变换到一个空串呢？一次一个地删除n个字符。

然后来看一个稍微复杂的例子：
假设 horse -> ros = x, 那么 horse->rosh = ?
假设走的路径是 horse->rosh = (horse->ros) + h ， 则此条路径的变换次数就是 x+1
当然，这里因为要求最少变换步骤，所以也可能不是走的这个路径，比如，也可以走以下的路径：
horse->rosh = orse->ros

由以上这些思考，我们大致可以想到，这个动态规划的方法，应该是一个由少字符变换逐渐推导出多字符变换的过程。
假设s1要变换到s2，则第一列是s1，第一行是s2，一个字符一个字符地推导，看能否找到规律。于是，我们有了第一张表格：

horse有5个字符，rosh有4个字符，又因为考虑了空字符串，所以这是一个 6x5 的二维数组。
现在已经列出的第一行和第一列的数字，含义很简单：
第一行代表由空字符逐渐变成rosh这个字符串，需要的最少变动次数；
如：由空到r，需要1个变动；由空到ro，需要2个变动；等等。
第一列代表： h->\0 = 1, ho->\0 = 2, hor->\0 = 3, 等等。
因此，第一张表还是很容易看懂的。

以第一张表为基础，我们来推导一下第二行，如下图：

假设这个二维数组叫dp，那么 dp[1][1] 为何等于1呢？
因为 h->r 只需要一个replace变换，
为何 h->ro = 2 呢？ 因为 h->ro = (h->r) + (Insert o) = 1+1 = 2
依次类推。到了最后， 已知 h->ros = 3, 那么 h->rosh = ? 是4吗？
不是4，还是3， 因为h已经在了，只需要增加ros这3个字符即可。这里也可以看成，行与列都减少一个最新的字符。

以上的分析用到了2种操作：

1. Insert变换：
   dp[i][j] = dp[i][j-1] + 1
2. Replace变换：
   dp[i][j] = dp[i-1][j-1]
   这里2个-1，就是上述的“行与列都减少一个最新的字符”的意思。
   注意，这里没有+1，是因为行与列都是h的缘故，即 s1[i] == s2[j],因此不需要替换 ；若+1，则代表在上一次的基础上，本次执行替换，如上一次是 ho->ro, 则本次是 hor -> ros, 即本次执行了r替换为s，这个时候需要+1.

还有第3种操作 - Delete 操作在这一行的举例中没有出现。想一想，什么情况下是Delete操作呢？
看上面的式子，自然地就能想到：
dp[i][j] = dp[i-1][j] + 1 这是代表了Delete操作吗？

没错。举个例子： hor->ro = (Delete r) + (ho->ro) = 1+(ho->ro)

总结以上的一切，

1. 一般情况下， dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
   即，在三种操作中找到操作数最少的一种，然后+1代表的是这种操作
2. 特殊情况是，任何一种操作都不需要，因为此时2个字符串在各自当前位置的字符是一致的，如 s1[i-1] == s2[j-1] ，
   因此不需要 +1 操作，即： dp[i][j] == dp[i-1][j-1]

用这个规律，可以推导出如下的代码和表格：

if (word1[i-1] != word2[j-1]) {
    dp[i][j] = 1 + min(dp[i-1][j-1], min(dp[i-1][j], dp[i][j-1]));
}
else {
    dp[i][j] = dp[i-1][j-1];
}

最终表格：

代码

#include <iostream>
#include <string>
using namespace std;


int minDistance(string& word1, string& word2) 
{
    const int len1 = word1.size() + 1;
    const int len2 = word2.size() + 1;
    
    if (len1 == 1) return len2-1; 
    if (len2 == 1) return len1-1;
    
    int dp[len1][len2];

    for (int i=0; i<len2; ++i) {
        dp[0][i] = i;
    }
    
    for (int i=0; i<len1; ++i) {
        dp[i][0] = i;
    }
    
    for (int i=1; i<len1; ++i) {
        for (int j=1; j<len2; ++j) {
            if (word1[i-1] != word2[j-1]) {
                dp[i][j] = 1 + min(dp[i-1][j-1], min(dp[i-1][j], dp[i][j-1]));
            }
            else {
                dp[i][j] = dp[i-1][j-1];
            }
        }
    }
    for (int i=0; i<len1; i++) {
        for (int j=0; j<len2; j++) {
            cout << dp[i][j] << " ";
        }
        cout << endl;
    }
    
    return dp[len1-1][len2-1];
}


int main()
{
    string s1 = "", s2 = "";
    int minDist = -1;
    
    s1 = "horse";
    s2 = "rosh";
    minDist = minDistance(s1, s2);
    cout << s1 << endl << s2 << endl << minDist << endl;
    cout << "------------------------------\n";
    
    s1 = "a";
    s2 = "a";
    minDist = minDistance(s1, s2);
    cout << s1 << endl << s2 << endl << minDist << endl;
    cout << "------------------------------\n";
    
    s1 = "algorithm";
    s2 = "altruistic";
    minDist = minDistance(s1, s2);
    cout << s1 << endl << s2 << endl << minDist << endl;
    cout << "------------------------------\n";
    
    return 0;
}

(完)