动态规划 - 字符串的编辑距离

简单来说，编辑距离就是将两个字符串变成相同字符串所需要的最小操作次数。所需的操作可能有：

1. 修改一个字符（如把“a”替换为“b”）
2. 增加一个字符（如把“abdd”变为“aebdd”）
3. 删除一个字符（如把“travelling”变为“traveling”）

例如，对于“abcdefg”和“abcdef”两个字符串来讲，可以通过增加/减少一个“g”的方式来达到目的。上面的两种方案，都仅需要一次操作。把这个操作所需要的次数定义为两个字符串的“编辑距离”。如何计算两个字符串的“编辑距离”？

鉴于DP自底向上求解子问题的性质，我们还是对字符串从后向前分析，这样寻找编辑距离的子问题比较直观，而且分解的子问题使得递归做备忘录变得容易理解，也使得自底向上实现时对状态转移矩阵的初始化更为简便易懂。

寻找子问题时，我们完全可以像分析最长公共子序列那样分析这个问题，我觉得它们是灰常相似的，都是“从后向前”看，假设有两个串X=abcdaex，Y=fdfax，它们的最后一个字符是相同的，只要计算X[1,…,6]=abcdae和Y[1,…,4]=fdfa的距离就可以了；但是如果两个串的最后一个字符不相同，那么就可以进行如下的操作来达到目的（xlen和ylen是X串和Y串的长度）：

1. 一步操作之后，再计算X[1,…,xlen-1]和Y[1,…ylen]的距离。这个操作可以是删除X的最后一个字符，也可以是增加X串的最后一个字符到Y串的最后字符之后
2. 一步操作之后，再计算X[1,…,xlen]和Y[1,…ylen-1]的距离。这个操作与情况1类似，反过来而已
3. 一步操作之后，再计算X[1,…,xlen-1]和Y[1,…ylen-1]的距离。这个操作可以是修改X串的最后有一个字符为Y串的最后一个字符，后者修改Y的变为X的最后一个字符，使得二者相同。

注意：我们计算编辑距离，并不需要关心两个字符串相等之后是怎样的，也不需要具体采取了什么操作，只是需要知道操作次数就可以，所以经过上面的分析，我们就可以尝试写状态方程了，这个的初始状态就是当两个串的长度都为0，那么编辑距离就是0，所以与最长公共子序列一样，dp[i][j]中的i和j表示串X和Y的长度，其中，如果某一个串的长度为0，则编辑距离就是另一个串的长度，这很容易理解。状态转移方程为

1. dp[i][j] = 0  如果i=0 & j=0
2. dp[i][j] = xlen | ylen  如果j=0 | i=0
3. dp[i][j] = dp[i-1][j-1]  如果X[i-1] = Y[i-1]
4. dp[i][j] = 1 + min{ dp[i-1][j], dp[i][j-1], dp[i-1][j-1] }  如果X[i-1] != Y[i-1]

#include <iostream>
#include <string>
using namespace std;
/* 编辑距离
 * 设每个字符串长度不超过 30
*/
 
/* 存储子问题的解 i,j表示X，Y长度
 * dp[i][j]表示X[0-i)与Y[0-j)的编辑距离
*/
int dp[31][31];
char X[31];
char Y[31];
/* 自底向上 DP */
int calDistance(char *ptrX, int xlen, char *ptrY, int ylen)
{
    int i, j;
    for(i = 1; i <= xlen; ++i)
    {
        dp[i][0] = i;
    }
    for(j = 1; j <= ylen; ++j)
    {
        dp[0][j] = j;
    }
    for(i = 1; i <= xlen; ++i)
    {
        for(j = 1; j <= ylen; ++j)
        {
            if(ptrX[i-1] == ptrY[j-1])
            {
                dp[i][j] = dp[i-1][j-1];
            }else
            {
                int t1 = dp[i-1][j];
                t1 = t1 < dp[i][j-1] ? t1 :dp[i][j-1];
                t1 = t1 < dp[i-1][j-1] ? t1 : dp[i-1][j-1];
                dp[i][j] = t1 + 1;
            }
        }
    }
    return dp[xlen][ylen];
}

int main(int argc, char *argv[])
{
	char *a = "abcdefg";
	char *b = "bbdeefh";
	int alen = strlen(a);
	int blen = strlen(b);
	int minDistance = calDistance(a, alen, b, blen);
	cout << minDistance << endl;

	return 0;
}

另附上递归算法：

/* 递归搜索 */
int calDistance1(char *ptrX, int xbeg, int xend, char *ptrY, int ybeg, int yend)
{
    if(xbeg > xend)
    {
        if(ybeg > yend)
            return 0;
        else
            return yend - ybeg + 1;
    }
    if(ybeg > yend)
    {
        if(xbeg > xend)
            return 0;
        else
            return xend - xbeg + 1;
    }
    if(ptrX[xend] == ptrY[yend])
    {
        return calDistance1(ptrX,xbeg,xend-1,ptrY,ybeg,yend-1);
    }else
    {
        int t1 = calDistance1(ptrX,xbeg,xend-1,ptrY,ybeg,yend);
        int t2 = calDistance1(ptrX,xbeg,xend,ptrY,ybeg,yend-1);
        int t3 = calDistance1(ptrX,xbeg,xend-1,ptrY,ybeg,yend-1);
        t1 = t1 < t2 ? t1 : t2;
        return (t1 < t3 ? t1 : t3) + 1;
    }
}




递归+备忘录算法

/* 编辑距离
 * 设每个字符串长度不超过 30
*/
 
/* 存储子问题的解 i,j表示X，Y长度
 * dp[i][j]表示X[0-i)与Y[0-j)的编辑距离
*/
int dp[31][31];
/* 自顶向下 & 备忘录 */
int calDistance2(char *ptrX, int xbeg, int xend, char *ptrY, int ybeg, int yend)
{
    if(xend == 0)
    {
        if(yend == 0)
            return 0;
        else
            return yend - ybeg + 1;
    }
    if(yend == 0)
    {
        if(xend == 0)
            return 0;
        else
            return xend - xbeg + 1;
    }
    if(ptrX[xend-1] == ptrY[yend-1])
    {
        if(dp[xend-1][yend-1] == 0)
        {
            dp[xend-1][yend-1] = calDistance2(ptrX,xbeg,xend-1,ptrY,ybeg,yend-1);
        }
        return dp[xend-1][yend-1];
    }else
    {
        int t1, t2, t3;
        if(dp[xend-1][yend] == 0)
        {
            dp[xend-1][yend] = calDistance2(ptrX,xbeg,xend-1,ptrY,ybeg,yend);
        }
        t1 = dp[xend-1][yend];
        if(dp[xend][yend-1] == 0)
        {
            dp[xend][yend-1] = calDistance2(ptrX,xbeg,xend,ptrY,ybeg,yend-1);
        }
        t2 = dp[xend][yend-1];
        if(dp[xend-1][yend-1] == 0)
        {
            dp[xend-1][yend-1] = calDistance2(ptrX,xbeg,xend-1,ptrY,ybeg,yend-1);
        }
        t3 = dp[xend-1][yend-1];
        t1 = t1 < t2 ? t1 : t2;
        return (t1 < t3 ? t1 : t3) + 1;
    }
}

Reference：http://www.ahathinking.com/archives/116.html#more-116