Java 字符串匹配相似度 java字符串相似度算法

一直不理解，为什么要计算两个字符串的相似度呢。什么叫做两个字符串的相似度。经常看别人的博客，碰到比较牛的人，然后就翻了翻，终于找到了比较全面的答案和为什么要计算字符串相似度的解释。因为搜索引擎要把通过爬虫抓取的页面给记录下来，那么除了通过记录url是否被访问过之外，还可以这样，比较两个页面的相似度，因为不同的url中可能记录着相同的内容，这样，就不必再次记录到搜索引擎的存储空间中去了。还有，大家毕业的时候都写过论文吧，我们论文的查重系统相信也会采用计算两个字符串相似度这个概念。

以下叙述摘自编程之美一书：

许多程序会大量使用字符串。对于不同的字符串，我们希望能够有办法判断其相似程序。我们定义一套操作方法来把两个不相同的字符串变得相同，具体的操作方法为：
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和6,2和5，3和4的结合操作，最后两个字符串每个对应的字符会相同，但是这三种操作产生的最终的两个字符串是不一样的。我们不知道通过上述的三种结合那种使用的操作次数是最少的。所以我们要比较操作次数来求得最小值。

下面这幅图是摘自编程之美：从中我们可以看出一些信息。

                                             

可以看到，在计算的过程中，有索引越界的情况，抓住这个特点，就可以尽早的结束程序，同时还有重复计算的情况，比如(strA, 2, 2, strB, 2, 2).为了减少计算的次数，可以采用临时数组存储中间的结果。下面给出程序：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int min(int a, int b, int c) {
	if(a < b) {
		if(a < c)
			return a;
		else 
			return c;
	} else {
		if(b < c)
			return b;
		else 
			return c;
	}
}
int compute_distance(char *strA, int pABegin, int pAEnd, char *strB, int pBBegin, int pBEnd, int **temp) {
	int a, b, c;
	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]) {
		if(temp[pABegin + 1][pBBegin + 1] != 0) {
			a = temp[pABegin + 1][pBBegin + 1];
		} else {
			a = compute_distance(strA, pABegin + 1, pAEnd, strB, pBBegin + 1, pBEnd, temp);
		}
		return a;
	} else {
		if(temp[pABegin + 1][pBBegin + 1] != 0) {
			a = temp[pABegin + 1][pBBegin + 1];
		} else {
			a = compute_distance(strA, pABegin + 1, pAEnd, strB, pBBegin + 1, pBEnd, temp);
			temp[pABegin + 1][pBBegin + 1] = a;
		}

		if(temp[pABegin + 1][pBBegin] != 0) {
			b = temp[pABegin + 1][pBBegin];
		} else {
			b = compute_distance(strA, pABegin + 1, pAEnd, strB, pBBegin, pBEnd, temp);
			temp[pABegin + 1][pBBegin] = b;
		}

		if(temp[pABegin][pBBegin + 1] != 0) {
			c = temp[pABegin][pBBegin + 1];
		} else {
			c = compute_distance(strA, pABegin, pAEnd, strB, pBBegin + 1, pBEnd, temp);
			temp[pABegin][pBBegin + 1] = c;
		}

		return min(a, b, c) + 1;
	}

}

void main() {
	char a[] = "efsdfdabcdefgaabcdefgaabcdefgaabcdefgasfabcdefgefsdfdabcdefgaabcdefgaabcdefgaabcdefgasfabcdefg";
	char b[] = "efsdfdabcdefgaabcdefgaaefsdfdabcdefgaabcdefgaabcdefgaabcdefgasfabcdabcdefggaabcdefgasfabcdefg";
	int len_a = strlen(a);
	int len_b = strlen(b);

	int **temp = (int**)malloc(sizeof(int*) * （len_a + 1）);
	for(int i = 0; i < len_a + 1; i++) {
		temp[i] = (int*)malloc(sizeof(int) * (len_b + 1));
		memset(temp[i], 0, sizeof(int) * (len_b + 1));
	}
	memset(temp, 0, sizeof(temp));
	int distance = compute_distance(a, 0, len_a - 1, b, 0, len_b - 1, temp);
	printf("%d\n", distance);
}

之所以在return min(a, b, c) + 1,进行加1的操作，是为了表示在当前两个对应位置的字符不相等的时候，我们采取了一次操作，不管是上述6种情况中的哪一种。而当两个字符相等的时候，就不需要加1，因为没有进行操作。这种方法是从前向后的操作，还有一种就是采用动态规划的形式。如果想理解动态规划的这种方式，建议先学习求两个字符串的最常公共子序列。所谓最常公共子序列就是给定两个字符串s1，s2，找出一个最常的字符串s3，s3中的每个字符同时在s1，s2中出现，但是不必连续。下面给出应用动态规划解决字符串相似度的解释和程序源码.

设Ai为字符串A(a1a2a3 … am)的前i个字符（即为a1,a2,a3 … ai）
设Bj为字符串B(b1b2b3 … bn)的前j个字符（即为b1,b2,b3 … bj）
设 L(i,j)为使两个字符串和Ai和Bj相等的最小操作次数。
当ai==bj时 显然 L(i,j) = L(i-1,j-1)
当ai!=bj时 
 若将它们修改为相等，则对两个字符串至少还要操作L(i-1,j-1)次
 若删除ai或在bj后添加ai，则对两个字符串至少还要操作L(i-1,j)次
 若删除bj或在ai后添加bj，则对两个字符串至少还要操作L(i,j-1)次
 此时L(i,j) = min( L(i-1,j-1), L(i-1,j), L(i,j-1) ) + 1 
显然，L(i,0)=i，L(0,j)=j, 再利用上述的递推公式，可以直接计算出L(i,j)值。L(i,0)代表Ai和B0，如果想把一个字符串和一个空字符串变的相同，那么之后删除非空串中的字符或者把空串变成和非空串相同的字符串，那么所需要操作的次数为i次。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int min(int a, int b, int c) {
	if(a < b) {
		if(a < c)
			return a;
		else 
			return c;
	} else {
		if(b < c)
			return b;
		else 
			return c;
	}
}
int compute_distance(char *strA, int len_a, char *strB, int len_b, int **temp) {
	int i, j;

	for(i = 1; i <= len_a; i++) {
		temp[i][0] = i;
	}

	for(j = 1; j <= len_b; j++) {
		temp[0][j] = j;
	}

	temp[0][0] = 0;

	for(i = 1; i <= len_a; i++) {
		for(j = 1; j <= len_b; j++) {
			if(strA[i -1] == strB[j - 1]) {
				temp[i][j] = temp[i - 1][j - 1];
			} else {
				temp[i][j] = min(temp[i - 1][j], temp[i][j - 1], temp[i - 1][j - 1]) + 1;
			}
		}
	}
	return temp[len_a][len_b];
}

void main() {
	char a[] = "efsdfdabcdefgaabcdefgaabcdefgaabcdefgasfabcdefgefsdfdabcdefgaabcdefgaabcdefgaabcdefgasfabcdefg";
	char b[] = "efsdfdabcdefgaabcdefgaaefsdfdabcdefgaabcdefgaabcdefgaabcdefgasfabcdabcdefggaabcdefgasfabcdefg";
	int len_a = strlen(a);
	int len_b = strlen(b);

	int **temp = (int**)malloc(sizeof(int*) * (len_a + 1));
	for(int i = 0; i < len_a + 1; i++) {
		temp[i] = (int*)malloc(sizeof(int) * (len_b + 1));
		memset(temp[i], 0, sizeof(int) * (len_b + 1));
	}
	int distance = compute_distance(a, len_a, b, len_b, temp);
	printf("%d\n", distance);
}

最终两个解法的运行结果是一样的。敬请读者验证。