[编程之美] PSet3.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.如果A[0]==B[0]，则只需要计算countDis(A[1,LenA-1],B[1,LenA-1]);
2.如果A[0]!=B[0],只需要一步修改后计算三者中的最小值：Dis(A[0,LenA-1],B[1,LenB-1])、
  Dis(A[1,LenA-1],B[0,LenB-1])、Dis(A[1,LenA-1],B[1,LenB-1]).
*/
int MIN(int a,int b)
{
	return a>b?b:a;
}
int countDis(string strA , int pAbegin , int pAend , string strB , int pBbegin , int pBend)
{
	//---递归边界条件
	if(pAbegin > pAend){
		if(pBbegin > pBend)
			return 0;
		else
			return pBend-pBbegin+1;//A为空且B非空
	}
	if(pBbegin > pBend){
		if(pAbegin > pAend)
			return 0;
		else
			return pAend-pAbegin+1;//B为空且A非空
	}
	if(strA[pAbegin] == strB[pBbegin])
		return countDis(strA,pAbegin+1,pAend,strB,pBbegin+1,pBend);
	else{
		int val1 = countDis(strA,pAbegin+1,pAend,strB,pBbegin+1,pBend);
		int val2 = countDis(strA,pAbegin,pAend,strB,pBbegin+1,pBend);
		int val3 = countDis(strA,pAbegin+1,pAend,strB,pBbegin,pBend);
		int min = MIN(val1,val2);
		min = MIN(min,val3);
		return min+1;
	}
}

上面的递归程序，有什么地方需要改进呢？问题在于：在递归的过程中，有些数据被重复计算了。
　　我们知道适合采用动态规划方法的最优化问题中的两个要素：最优子结构和重叠子问题，还有一种方法称为备忘录（memoization），通过存储已获得的解来减少重复计算。

       解法二：动态规划法

       设状态c[i][j]为strA对应第i个字符，和strB对应第j个字符时的距离。对strA或strB而言，第i个状态只与第i+1个状态有关，而与第i+2、····状态无直接关系，满足无后效性。因此可以得到如下的状态转移方程:

    
由此得到如下代码：

//解法二：动态规划法
//由于符合无后效性（后一个状态只与前一个状态有关，而与前前一个状态无直接关系），所以使用动态规划
int MIN(int a,int b)
{
	return a>b?b:a;
}
int countDis(string strA , string strB)
{
	int result = 0;
	int LenA = strA.size();
	int LenB = strB.size();
	//---定义动态二维数组c[LenA+1][LenB+1]
	int **c = new int* [LenA+1];//定义指针数组，数组大小LenA
	for(int i=0 ; i<LenA+1 ; i++){
		c[i] = new int[LenB+1];
		memset(c[i] , 0 , sizeof(int)*(LenB+1));
	}
	//---边界条件
	c[LenA][LenB] = 0;
	for(int i=0 ; i<LenA ; i++)
		c[i][LenB] = LenA-i;//B空A非空
	for(int i=0 ; i<LenB ; i++)
		c[LenA][i] = LenB-i;//A空B非空
	//---自底向上求解
	for(int i=LenA-1 ; i>=0 ; i--)
		for(int j=LenB-1 ; j>=0 ; j--){
			if(strA[i] == strB[j])
				c[i][j] = c[i+1][j+1];
			else{
				c[i][j] = MIN(c[i+1][j],c[i][j+1]);
				c[i][j] = MIN(c[i][j] , c[i+1][j+1])+1;
			}
		}
	result = c[0][0];
	//---注销数组所占空间
	for(int i=0 ; i<LenA ; i++){//先释放指针数组指向的内存
		delete[]c[i];
		c[i] = NULL;
	}
    //再释放指针数组
	delete[]c;
	c=NULL;
	return result;	
}

       解法三：备忘录法

       动态规划的一种变形，它既具有通常的动态规划方法的效率，又采用了一种自顶向下的策略。其思想就是备忘原问题的自然但低效的递归算法。像在通常的动态规划中一样，维护一个记录了子问题解的表，但有关填表动作的控制结构更像递归算法。见下面代码：

//解法三：备忘录法
//递归算法的变形，当遇到一个子问题时，如果表中有解则直接填入，不用重复计算
//下面代码通过memorize来控制是否使用备忘录，额外采用表格countDisTable[i][j]保存得到的结果
int MIN(int a,int b,int c)
{
	if(a>b){
		if(a>c)
			return c;
		else
			return b;
	}else{
		if(a>c)
			return c;
		else
			return a;
	}
}
const int Max = 100;
int countDisTable[Max][Max];
int countDis(string strA , int pAbegin , int pAend , string strB , int pBbegin , int pBend)
{
	if(countDisTable[pAbegin][pBbegin] >= 0)//备忘录中存在，则直接返回
		return countDisTable[pAbegin][pBbegin];
	//---下面的与递归方法近似相同，只是多了个查表和填表的操作
	if(pAbegin > pAend){
		if(pBbegin > pBend){
			int temp = 0;
			countDisTable[pAbegin][pBbegin] = temp;
			return temp;
		}
		else{
			int temp = pBend-pBbegin+1;
			countDisTable[pAbegin][pBbegin] = temp;
			return temp;
		}
	}
	if(pBbegin > pBend){
		if(pAbegin > pAend){
			int temp = 0;
			countDisTable[pAbegin][pBbegin] = temp;
			return temp;
		}
		else{
			int temp = pAend-pAbegin+1;
			countDisTable[pAbegin][pBbegin] = temp;
			return temp;
		}
	}
	if(strA[pAbegin] == strB[pBbegin]){
		int temp = countDis(strA,pAbegin+1,pAend,strB,pBbegin+1,pBend);
		countDisTable[pAbegin][pBbegin] = temp;
		return temp;
	}
	else{
		int val1 = countDis(strA,pAbegin+1,pAend,strB,pBbegin+1,pBend);
		int val2 = countDis(strA,pAbegin,pAend,strB,pBbegin+1,pBend);
		int val3 = countDis(strA,pAbegin+1,pAend,strB,pBbegin,pBend);
		int temp = MIN(val1,val2,val3);
		countDisTable[pAbegin][pBbegin] = temp;
		return temp;
	}
}

int main()
{
	//---清空表格
	for(int i=0 ; i<Max ; i++){
		memset(countDisTable[i],-1,sizeof(int)*Max);
	}
	string str1 = "agbe";
	string str2 = "aebdde";
	cout<<countDis(str1,0,str1.size()-1,str2,0,str2.size()-1)<<endl;
	return 0;
}