设 A 和 B 是两个字符串。我们要用最少的字符操作次数,将字符串 A 转换为字符串 B 。这里所说的字符操作共有三种:
- 删除一个字符;
- 插入一个字符;
- 将一个字符改为另一个字符。
对任给的两个字符串 A 和 B ,计算出将字符串 A 变换为字符串 B 所用的最少字符操作次数。
这个问题本质上是一个无向图的问题,固定了起点和终点,起点为字符串 A ,终点为字符串 B 。但是每一个点所对应的分支太多。所以我们需要对其进行转化。在以下特殊情况下,最短编辑距离容易求出:
- 当 A 、 B 的长度都为 0 时,最短编辑距离为 0
- 当 A 的长度为 0,B 的长度不为0,最短编辑距离为 A 的长度
- 当 A 的长度不为0,B的长度为0,最短编辑距离为 B 的长度
我们可以将所有的字符串转化为以上的三种情况。
可以尝试使用动态规划来解决。动态规划对于有向无环图比较合适,如果我们只对字符串 A 、 B 的最后一个字符做操作,而且将“增删改”变为“删改”,那么无向图就变成了有向无环图。使用动态规划,首先需要定义状态。我们可以把 A,B 变换成的子串的长度 (i,j) 看成一个状态,然后定义状态 (i,j) 的指标函数 d(i,j)为 (i,j) 变为相同子串所需的最小编辑次数。然后观察不同状态之间是如何转移的,从状态 (i,j) 出发有三种决策,分别对应题目中所给出的三种字符操作(三种字符操作都是对最后一个字符的操作)。
- 删除一个字符 ==> 删除 A 字符串的最后一个字符,转移到了 (i−1,j)
- 插入一个字符 ==> 在 A 字符串末尾插入 B 字符串的一个字符,相当于 B 字符串删除一个字符,转移到了 (i,j−1)
- 将一个字符改为另一个字符。 ==> 将 A 的最后一个字符改为 B 的最后一个字符,将状态转移到了 (i−1,j−1)
则状态转移方程为:d(i,j)=min{d(i−1,j)+1,d(i,j−1)+1,d(i−1,j−1)+c}
式中,当子串的最后一个字符相同时, AB 的最小编辑距离与 AB 都去掉最后一个字母的最小编辑距离相同,所以 c=0,否则 c=1。
实验原理:
先从一个问题谈起:对于字符串"xyz"和"xcz",它们的最短距离是多少?我们从两个字符串的最后一个字符开始比较,它们都是’z’,是相同的,我们可以不用做任何操作,此时二者的距离实际上等于"xy"和"xc"的距离,即d(xyz,xcz) = d(xy,xc)。也即是说,如果在比较的过程中,遇到了相同的字符,那么二者的距离是除了这个相同字符之外剩下字符的距离。即d(i,j) = d(i - 1,j-1)。
接着,我们把问题拓展一下,最后一个字符不相同的情况:字符串A(“xyzab”)和字符串B(“axyzc”),问至少经过多少步操作可以把A变成B。
我们还是从两个字符串的最后一个字符来考察即’b’和’c’。显然二者不相同,那么我们有以下三种处理办法:
(1) 增加:在A末尾增加一个’c’,那么A变成了"xyzabc",B仍然是"axyzc",由于此时末尾字符相同了,那么就变成了比较"xyzab"和"axyz"的距离,即d(xyzab,axyzc) = d(xyzab,axyz) + 1。可以写成d(i,j) = d(i,j - 1) + 1。表示下次比较的字符串B的长度减少了1,而加1表示当前进行了一次字符的操作。
(2) 删除:删除A末尾的字符’b’,考察A剩下的部分与B的距离。即d(xyzab,axyzc) = d(xyza,axyzc) + 1。可以写成d(i,j) = d(i - 1,j) + 1。表示下次比较的字符串A的长度减少了1。
(3) 替换:把A末尾的字符替换成’c’,这样就与B的末尾字符一样了,那么接下来就要考察出了末尾’c’部分的字符,即d(xyzab,axyzc) = d(xyza,axyz) + 1。写成d(i,j) = d(i -1,j-1) + 1表示字符串A和B的长度均减少了1。
实验程序:
#include <iostream>
#include <stdio.h>
#include <time.h>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxn = 1000 + 2;
char a[maxn];
char b[maxn];
int step[maxn][maxn];
int findStep(int i, int j)
{
int &ans = step[i][j];
if (ans != -1)
{
return ans;
}
if (i == 0 && j == 0)
{
return ans = 0;
}
if (i == 0)
{
return ans = j;
}
else if (j == 0)
{
return ans = i;
}
int c;
if (a[i - 1] != b[j - 1])
{
c = 1;
}
else
{
c = 0;
}
ans = min(min(findStep(i - 1, j) + 1,
findStep(i, j - 1) + 1),
findStep(i - 1, j - 1) + c);
return ans;
}
int main()
{
#ifdef LOCAL
freopen("data.in", "r", stdin);
freopen("data.out", "w", stdout);
#endif // LOCAL
int n;
int m1, n1;
while (cin >> n && n)
{
for (int j = 0; j < n; j++)
{
memset(step, -1, sizeof(step));
cin >> a >> b;
cout << strlen(a) << " " << strlen(b) << endl;
m1 = strlen(a);
n1 = strlen(b);
cout << findStep(m1, n1) << endl;
}
}
return 0;
}
实验测试:
复杂度分析:
由上面可以看出,动态规划就是逐行逐列地运算,逐渐填满整个数组,最后得到结果恰好保存在数组的最后一行和最后一列的元素上。动态规划中,i和j的增加需要两层循环来完成,外层循环遍历i,内层循环遍历j,也即是,对于每一行,会扫描行内的每一列的元素进行运算。因此,时间复杂度为o(n²),空间复杂度为o(n²)。