计算字符串的相似度

  字符串相似度计算是查找两个字符串的公共子串，利用公共子串的长度根据相应的公式来衡量两个字符串的相似程度。字符串相似度计算算法很多，如LCS算法、Levenshtein Distance算法、Heckel算法、GST算法等。

下面我们根据Levenshtein Distance算法（编辑距离算法）来求字符串的相似度

原文的问题描述：（编程之美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]变成相字符串。

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

代码如下：

#include<stdio.h>
int minValue(int a,int b,int c)
{
	if(a>b)
	{
		if(b>c)
			return c;
		return b;
	}
	else
	{
		if(c<a)
			return c;
		return a;
	}
}
int calculateStringDistance(char strA[], int pABegin, int pAEnd, char strB[], int pBBegin, int pBEnd)
  {
      if(pABegin > pAEnd)
      {
          if(pBBegin > pBEnd)
              return 0;
          else
              return pBEnd - pBBegin + 1;
      }
 
     if(pBBegin > pBEnd)
     {
         if(pABegin > pAEnd)
             return 0;
         else
             return pAEnd - pABegin + 1;
     }
 
     if(strA[pABegin] == strB[pBBegin])
     {
         return calculateStringDistance(strA, pABegin+1, pAEnd, strB, pBBegin+1, pBEnd);
     }
     else
     {
         int t1 = calculateStringDistance(strA, pABegin, pAEnd, strB, pBBegin+1, pBEnd);
         int t2 = calculateStringDistance(strA, pABegin+1, pAEnd, strB, pBBegin, pBEnd);
         int t3 = calculateStringDistance(strA, pABegin+1, pAEnd, strB, pBBegin+1, pBEnd);
         return minValue(t1, t2, t3) + 1;
     }
}

void main()
{
	char strA[5]="abcd";
	char strB[4]="ddf";

	printf("%d",calculateStringDistance(strA,0,3,strB,0,2));


}

但是上面的递归过程有一个地方需要注意，有些数据被重复计算了。

试着用动态规划问题解决

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

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

　　1）描述最优解的结构。
2）递归定义最优解的值。
3）按自底向上的方式计算最优解的值。
4）由计算出的结果构造一个最优解。

代码如下：

int calculateStringDistance(string strA, string strB)
 {
      int lenA = (int)strA.length();
      int lenB = (int)strB.length();
      int c[lenA+1][lenB+1]; // Record the distance of all begin points of each string
 
    // i: begin point of strA
     // j: begin point of strB
     for(int i = 0; i < lenA; i++) c[i][lenB] = lenA - i;
     for(int j = 0; j < lenB; j++) c[lenA][j] = lenB - j;
     c[lenA][lenB] = 0;
 
     for(int i = lenA-1; i >= 0; i--)
         for(int j = lenB-1; j >= 0; j--)
         {
             if(strB[j] == strA[i])
                 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;
         }
 
     return c[0][0];
 }

还有一种方法跟上面有点类似：

a.首先是有两个字符串,这里写一个简单的 abc和abe

b.将字符串想象成下面的结构。

	abc	a	b	c
abe	0	1	2	3
a	1	A处
b	2
e	3

c.来计算 A处 出得值
d.于是表成为下面的样子

	abc	a	b	c
abe	0	1	2	3
a	1	0
b	2	B处
e	3

e.于是表就更新了

	abc	a	b	c
abe	0	1	2	3
a	1	0
b	2	1
e	3	C处

f.于是依次推得到

		a	b	c
	0	1	2	3
a	1	A处 0	D处 1	G处 2
b	2	B处 1	E处 0	H处 1
e	3	C处 2	F处 1	I处 1

A处 是一个标记，为了方便讲解，不是这个表的内容。

 

它的值取决于：左边的1、上边的1、左上角的0.

按照Levenshtein distance的意思：

上面的值和左面的值都要求加1，这样得到1+1=2。

A处 由于是两个a相同，左上角的值加0.这样得到0+0=0。

这是后有三个值，左边的计算后为2，上边的计算后为2，左上角的计算为0，所以A处 取他们里面最小的0.

在B处 会同样得到三个值，左边计算后为3，上边计算后为1，在B处 由于对应的字符为a、b，不相等，所以左上角应该在当前值的基础上加1，这样得到1+1=2，在（3,1,2）中选出最小的为B处的值。

 

C处 计算后：上面的值为2，左边的值为4，左上角的：a和e不相同，所以加1，即2+1，左上角的为3。

在（2,4,3）中取最小的为C处 的值。

 

I处: 表示abc 和abe 有1个需要编辑的操作。这个是需要计算出来的。

同时，也获得一些额外的信息。

A处: 表示a      和a      需要有0个操作。字符串一样

B处: 表示ab    和a      需要有1个操作。

C处: 表示abe  和a      需要有2个操作。

D处: 表示a      和ab    需要有1个操作。

E处: 表示ab    和ab    需要有0个操作。字符串一样

F处: 表示abe  和ab    需要有1个操作。

G处: 表示a      和abc   需要有2个操作。

H处: 表示ab    和abc    需要有1个操作。

I处: 表示abe   和abc    需要有1个操作。

代码如下

package code;

public class MyLevenshtein {

	public static void main(String[] args) {
		//要比较的两个字符串
		String str1 = "今天星期四";
		String str2 = "今天是星期五";
		levenshtein(str1,str2);
	}

	public static void levenshtein(String str1,String str2) {
		//计算两个字符串的长度。
		int len1 = str1.length();
		int len2 = str2.length();
		//建立上面说的数组，比字符长度大一个空间
		int[][] dif = new int[len1 + 1][len2 + 1];
		//赋初值，步骤B。
		for (int a = 0; a <= len1; a++) {
			dif[a][0] = a;
		}
		for (int a = 0; a <= len2; a++) {
			dif[0][a] = a;
		}
		//计算两个字符是否一样，计算左上的值
		int temp;
		for (int i = 1; i <= len1; i++) {
			for (int j = 1; j <= len2; j++) {
				if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
					temp = 0;
				} else {
					temp = 1;
				}
				//取三个值中最小的
				dif[i][j] = min(dif[i - 1][j - 1] + temp, dif[i][j - 1] + 1,
						dif[i - 1][j] + 1);
			}
		}
		System.out.println("字符串\""+str1+"\"与\""+str2+"\"的比较");
		//取数组右下角的值，同样不同位置代表不同字符串的比较
		System.out.println("差异步骤："+dif[len1][len2]);
		//计算相似度
		float similarity =1 - (float) dif[len1][len2] / Math.max(str1.length(), str2.length());
		System.out.println("相似度："+similarity);
	}

	//得到最小值
	private static int min(int... is) {
		int min = Integer.MAX_VALUE;
		for (int i : is) {
			if (min > i) {
				min = i;
			}
		}
		return min;
	}

}