字符串相似度(距离)

编程之美上有一道这样的题目：

许多程序会大量使用字符串。对于不同的字符串，我们希望能够有办法判断其相似程度。我们定义了一套操作方法来把两个不相同的字符串变得相同，具体的操作方法为：
1.修改一个字符（如把“a”替换为“b”）。
2.增加一个字符（如把“abdd”变为“aebdd”）。
3.删除一个字符（如把“travelling”变为“traveling”）。
比如，对于“abcdefg”和“abcdef”两个字符串来说，我们认为可以通过增加/减少一个“g“的方式来达到目的。上面的两种方案，都仅需要一次操作。把这个操作所需要的次数定义为两个字符串的距离，给定任意两个字符串，你是否能写出一个算法来计算出它们的距离？

 

这道题主要在于求出 最小两个字符串的距离最小值。而动态规划可以用于求最优值。

 

令f[i][j] 表示字符串a的前i个字符与字符串b前j个字符的距离最小值。

如果 a[i]=b[j] 则两个字符串不用任何操作，f[i][j]=f[i-1][j-1];

如果a[i]!=b[j]，则此时这两个字符串，其中一个字符串或者删除个字符，或者添加一个字符，或者修改一个字符，总而言之需要一次操作。而且添加与删除是等效的, 可等价其中一个字符串少了一个字符，只考虑a的前i-1个或b的前j-1个；而修改意味着，这两个字符串同时删除了一个字符，考虑a的前i-1个和b的j-1个字符。

 

综上所述，转移方程为：

if a[i]=a[j]

      f[i][j]=f[i-1][j-1];

else

      f[i][j]=min{ f[i-1][j],f[i][j-1],f[i-1][j-1]}+1;

f[0][j]=j; // 一个0长度字符串与1个长度为j的字符串的距离当然为j

f[i][0]=i; // 同上

 

使用动态规划方法的代码：时间复杂度O(n1*n2),空间复杂度0(n1*n2);

int main(){
	char s1[100]="a";
	char s2[100];
	while(s1[0]!='#'){
		cin>>s1;
		cin>>s2;
		int n1=strlen(s1);
		int n2=strlen(s2);
		cout<<n1<<n2<<endl;
		cout<<"similarity degree="<<f(s1,0,n1,s2,0,n2)<<endl;
		int f[101][101];
		int i,j;
		for(i=0;i<=100;i++)
			f[0][i]=i;
		for(j=0;j<=100;j++)
			f[j][0]=j;


		for(i=1;i<=n1;i++){
			for(j=1;j<=n2;j++)
			{
				if(s1[i-1]==s2[j-1])
					f[i][j]=f[i-1][j-1];
				else{
					int t=min(f[i-1][j],(min(f[i][j-1],f[i-1][j-1])));
					f[i][j]=1+t;
				}
			
			}
		}
		cout<<"distance="<<f[n1][n2]<<endl;
	}
	return 0;
}

以S1=“saldfsfsdf” S2=“sasdfcabbbbcd” 为例， 可以看出 每个f[i][j] (i>0,j>0)都是求二维数组左边，上边，及左上对角元素的最小值，

 

 

 

为了优化空间复杂度，其实我们可以用一维数组保存左边及上边的值，而左上对角的元素可以额外使用一个变量保存。

代码如下：空间复杂度O(min(n1,n2)

int main(){
	char s1[100]="a";
	char s2[100];
	while(s1[0]!='#'){
		cin>>s1;
		cin>>s2;
		int n1=strlen(s1);
		int n2=strlen(s2);
		int i,j;
	
		//选择min(n1,n2)长度作为一维数组的的长度，假设此时n2<n1
		int last=0;
		int dp[101];
		for(i=0;i<=n2;i++)
			dp[i]=i;

		for(i=1;i<=n1;i++){
			last=dp[0];
			dp[0]=i;
			for(j=1;j<=n2;j++)
			{
				if(s1[i-1]==s2[j-1]){
					int tmp=last;
					last=dp[j];
					dp[j]=tmp;
				}
				else{
					int t=min(dp[j],min(dp[j-1],last));
					last=dp[j];
					dp[j]=1+t;
				}
			}
		}
		cout<<"dis="<<dp[n2];

	}
	return 0;
}

 

递归方法为：时间复杂度O(n^3)

int f(char *s1,int i1,int n1,char *s2,int i2,int n2){


	while((i1<n1) && (i2<n2) && (s1[i1]==s2[i2])){
		i1++;
		i2++;
	}
	if((i1==n1) || (i2==n2)){
		if(n1>i1)
			return n1-i1;
		else if(n2>i2)
			return n2-i2;
		else
			return 0;
	}
	else{
		int m=min(f(s1,i1,n1,s2,i2+1,n2),f(s1,i1+1,n1,s2,i2,n2));
		m=min(m,f(s1,i1+1,n1,s2,i2+1,n2));
		return m+1;
	}
	
}

int main(){
	char s1[100]="a";
	char s2[100];
	while(s1[0]!='#'){
		cin>>s1;
		cin>>s2;
		int n1=strlen(s1);
		int n2=strlen(s2);
		cout<<n1<<n2<<endl;
		cout<<"similarity degree="<<f(s1,0,n1,s2,0,n2)<<endl;
		
	}
	return 0;
}