编程之美--3.3计算字符串的相似度

许多程序会大量使用字符串。对于不同的字符串，我们希望能够有办法判断其相似程序。我们定义一套操作方法来把两个不相同的字符串变得相同，具体的操作方法为：
　　1.修改一个字符（如把“a”替换为“b”）;
　　2.增加一个字符（如把“abdd”变为“aebdd”）;
　　3.删除一个字符（如把“travelling”变为“traveling”）;

　　 　比如，对于“abcdefg”和“abcdef”两个字符串来说，我们认为可以通过增加/减少一个“g”的方式来达到目的。上面的两种方案，都仅需要一 次 。把这个操作所需要的次数定义为两个字符串的距离，而相似度等于“距离+1”的倒数。也就是说，“abcdefg”和“abcdef”的距离为1，相似度 为1/2=0.5。

　　给定任意两个字符串，你是否能写出一个算法来计算它们的相似度呢？

　　原文的分析与解法　　

　　不难看出，两个字符串的距离肯定不超过它们的长度之和（我们可以通过删除操作把两个串都转化为空串）。虽然这个结论对结果没有帮助，但至少可以知道，任意两个字符串的距离都是有限的。
　　我们还是就住集中考虑如何才能把这个问题转化成规模较小的同样的子问题。如果有两个串A=xabcdae和B=xfdfa，它们的第一个字符是 相同的，只要计算A[2,...,7]=abcdae和B[2,...,5]=fdfa的距离就可以了。但是如果两个串的第一个字符不相同，那么可以进行 如下的操作（lenA和lenB分别是A串和B串的长度）。

　　1.删除A串的第一个字符，然后计算A[2,...,lenA]和B[1,...,lenB]的距离。
　　2.删除B串的第一个字符，然后计算A[1,...,lenA]和B[2,...,lenB]的距离。
　　3.修改A串的第一个字符为B串的第一个字符，然后计算A[2,...,lenA]和B[2,...,lenB]的距离。
　　4.修改B串的第一个字符为A串的第一个字符，然后计算A[2,...,lenA]和B[2,...,lenB]的距离。
　　5.增加B串的第一个字符到A串的第一个字符之前，然后计算A[1,...,lenA]和B[2,...,lenB]的距离。
　　6.增加A串的第一个字符到B串的第一个字符之前，然后计算A[2,...,lenA]和B[1,...,lenB]的距离。

　　在这个题目中，我们并不在乎两个字符串变得相等之后的字符串是怎样的。所以，可以将上面的6个操作合并为：
　　1.一步操作之后，再将A[2,...,lenA]和B[1,...,lenB]变成相字符串。
　　2.一步操作之后，再将A[2,...,lenA]和B[2,...,lenB]变成相字符串。
　　3.一步操作之后，再将A[1,...,lenA]和B[2,...,lenB]变成相字符串。

　　这样，很快就可以完成一个递归程序。

 

解法1：采用递归的方法（原文代码）

public static int CalculateStringDistance(String Astr, int Abegin, int Aend,
        String Bstr, int Bbegin, int Bend){
    if(Abegin>Aend){
        if(Bbegin>Bend)
            return 0;
        else
            return Bend-Bbegin+1;
    }
    if(Bbegin>Bend){
        if(Abegin>Aend)
            return 0 ;
        else return Aend -Abegin+1;
    }
    if(Astr.charAt(Abegin)==Bstr.charAt(Bbegin)) //如果首个字符相等，递归比较剩余字符串
        return CalculateStringDistance(Astr,Abegin+1,Aend,Bstr,Bbegin+1,Bend);
    else{ //不相等的三种情况
        int t1 = CalculateStringDistance(Astr,Abegin+1,Aend,Bstr,Bbegin,Bend)+1;
        int t2 = CalculateStringDistance(Astr,Abegin+1,Aend,Bstr,Bbegin+1,Bend)+1;
        int t3 = CalculateStringDistance(Astr,Abegin,Aend,Bstr,Bbegin+1,Bend)+1;
        int tmin = t1<t2?t1:t2;
        return tmin<t3?tmin:t3;
    }
}

main()

String Astr = "abcdefg"; 
String Bstr = "abcefg"; //B比A少一个字符
int dis = CalculateStringDistance(Astr,0,Astr.length()-1,Bstr,0,Bstr.length()-1);
System.out.println("两个字符串的距离为："+dis);

结果：
两个字符串的距离为：1

上面的递归程序，有什么地方需要改进呢？问题在于：在递归的过程中，有些数据被重复计算了。

 

解法2：动态规划

原来的想法是在解法1的基础上增加一个二维数组，每次递归前加一个判断，当数据已经被计算了，则直接从数组中得出结果，否则在得到结果的同时将结果赋给数组。但是发现结果有错误。因为在递归过程中不能保证结果实时保存到数组中。（这里有疑问）

 

另一种动态规划的方法，非递归。

参考：http://blog.csdn.net/flyinghearts/article/details/5605996

　　我们知道适合采用动态规划方法的最优化问题中的两个要素：最优子结构和重叠子问题。另外，还有一种方法称为备忘录（memoization），可以充分利用重叠子问题的性质。

　　下面简述一下动态规划的基本思想。和分治法一样，动态规划是通过组合子问题的解而解决整个问题的。我们知道，分治算法是指将问题划分成独立的子问题，递归地求解各子问题，然后合并子问题的解而得到原问题的解。与此不同，动态规划适用于子问题不是独立的情况，也就是各子问题包含公共的子子问题。在这种情况下，若用分治法则会做许多不必要的工作，即重复地求解公共的子问题。动态规划算法对每个子问题只求解一次，将其结果保存在一张表中，从而避免每次遇到 各个子问题时重新计算答案。

动态规划通常应用于最优化问题。此类问题可能有很多种可行解，每个解有一个值，而我们希望找出一个具有最优（最大或最小）值的解。称这样的解为该问题的“一个”最优解（而不是“确定的”最优解），因为可能存在多个取最优值的解。

　　动态规划算法的设计可以分为如下4个步骤：

　　1）描述最优解的结构。

　　2）递归定义最优解的值。

　　3）按自底向上的方式计算最优解的值。

　　4）由计算出的结果构造一个最优解。

　　第1~3步构成问题的动态规划解的基础。第4步在只要求计算最优解的值时可以略去。如果的确做了第4步，则有时要在第3步的计算中记录一些附加信息，使构造一个最优解变得容易。

　　该问题明显完全符合动态规划的两个要素，即最优子结构和重叠子问题特性。该问题的最优指的是两个字符串的最短距离，子问题的重叠性可以从原书中的那个递归算法中看出。

　　下面再来详细说说什么是重叠子问题。适用于动态规划求解的最优化问题必须具有的第二个要素是子问题的空间要“很小”，也就是用来解原问题的递归 算法可以反复地解同样的子问题，而不是总在产生新的子问题。典型地，不同的子问题数是输入规模的一个多项式。当一个递归算法不断地调用同一问题时，我们说 该最优问题包含重叠子问题。相反地，适合用分治法解决的问题只往往在递归的每一步都产生全新的问题。动态规划算法总是充分利用重叠子问题，即通过每个子问 题只解一次，把解保存在一个需要时就可以查看的表中，而每次查表的时间为常数。

 

对于本问题

1. 当strA[i]等于strB[j]时 则c(i, j)=c(i-1, j-1)
2. 若strA[i]!=strB[j],
　　(1)若将它们修改为相等，则对两个字符串至少还要操作c(i-1, j-1)次
　　(2)若删除strA[i]或在strB[j]后添加strA[i]，则对两个字符串至少还要操作c(i-1, j)次
　　(3)若删除strB[j]或在strA[i]后添加strB[j]，则对两个字符串至少还要操作c(i, j-1)次
此时c(i, j)=min( c(i-1, j-1), c(i-1, j), c(i, j-1) ) + 1

初始化c[i][0] = i ; c[0][j]=j,利用上述递推公式可计算出c数组，c[lenA][lenB]就是两个字符的距离
这里的初始化很重要。（为什么这样初始化？走读一遍代码应该就明白意思了，大概意思如下图）

程序代码：

//解法2：动态规划。非递归
public static int calculateStringDistance(String strA, String strB) {
    int lenA = (int) strA.length();
    int lenB = (int) strB.length();
    //c[i][j]存放的为strA从0到i-1与strB从0到j-1两个子串的距离。（因为c的边界不算）
    int[][] c = new int[lenA + 1][lenB + 1];
    // Record the distance of all begin points of each String
    // 初始化边界
    for (int i = 0; i <= lenA; i++)
        c[i][0] = i;
    for (int j = 0; j <= lenB; j++)
        c[0][j] = j;
    c[0][0] = 0;
    //递推求出所有c元素
    for (int i = 1; i <= lenA; i++)
        for (int j = 1; j <= lenB; j++) {
            if (strB.charAt(j - 1) == strA.charAt(i - 1))
                c[i][j] = c[i - 1][j - 1];
            else
                c[i][j] = minValue(c[i][j-1], c[i-1][j],c[i-1][j-1]) + 1;
        }

    for (int i = 0; i <= lenA; i++) {
        for (int j = 0; j <= lenB; j++) {
            System.out.print(c[i][j] + " ");
        }
        System.out.println();
    }
    return c[lenA][lenB];
}

//计算3个数的最小值
public static int minValue(int A, int B, int C) {
    int tmin = A < B ? A : B;
    return tmin < C ? tmin : C;
}

main()

int dis3 = calculateStringDistance(Astr,Bstr);
System.out.println("两个字符串的距离为："+dis3);

运行结果：

0 1 2 3 4 5 6 
1 0 1 2 3 4 5 
2 1 0 1 2 3 4 
3 2 1 0 1 2 3 
4 3 2 1 1 2 3 
5 4 3 2 1 2 3 
6 5 4 3 2 1 2 
7 6 5 4 3 2 1 
两个字符串的距离为：1

 

其他资料：http://www.cnblogs.com/yujunyong/articles/2004724.html

转自：https://www.cnblogs.com/gnivor/articles/4604733.html