编程之美系列之计算字符串的相似度

题目描述：也就是给一个源串和目标串，计算最少的操作数，使得源串进行下列操作之后等于目标串。
1、在给定的位置插入字符
2、将当前字符替换成任意字符
3、删除任意字符
题目分析：
如果当前两个字符相等，则结果就是Src+1和Pattern+1两个字符串的最小操作数。
如果不等，就分三种情况：
1、如果是在给定的位置插入字符，那要求的操作数就是Src和Pattern+1两个字符串的最小操作数
2、如果将当前字符替换，那要求的操作数就是Src+1和Pattern+1两个字符串的最小操作数3、如果是删除Src的当前字符，则要求的操作数就是Src+1和Pattern两个字符串的最小操作数
最终结果就是上面三种情况中最小的操作数+1.
递归解法：程序很容易就可以写出来，递归的出口就是某一个字符串到达串尾，则距离就是没有到达串尾的那个字符串的长度。
非递归的解法：就是动态规划，假设dp[i][j]表示Src从第i个字符开始与Pattern从第j个字符开始所求得的最小操作数，动态规划递推的式子如下：
if Src[i] != Pattern[j], dp[i][j] = min(dp[i][j + 1], dp[i + 1][j + 1], dp[i +1][j];
else, dp[i][j] = dp[i + 1][j + 1];
使用动态规划需要注意的地方：
1、递推式中只出现了后面的数据，所以递推的时候应该是从后到前。
2、注意递推时的边界条件的处理。
核心参考代码如下：

//递归解法
int CalStr(const char* Src, const char *Pattern)
{
	assert(Src && Pattern);
	if(*Src == '\0')
	{
		return strlen(Pattern);
	}
	if(*Pattern == '\0')
	{
		return strlen(Src);
	}
	if(*Src == *Pattern)
	{
		return CalStr(Src + 1, Pattern + 1);
	}
	int t1 = CalStr(Src, Pattern + 1);//插入字符
	int t2 = CalStr(Src + 1, Pattern + 1);//替换字符
	int t3 = CalStr(Src + 1, Pattern);//删除字符
	return min(t1, t2, t3) + 1;
}
//非递归解法，动态规划
int CalStrDP(const char *Src, const char *Pattern)
{
	assert(Src && Pattern);
	memset(dp, 0, sizeof(int) * Max_N * Max_N);
	int nLen1 = strlen(Src);
	int nLen2 = strlen(Pattern);
	int i,j;
	for(i = nLen1 - 1; i >= 0; --i)
	{
		for(j = nLen2 - 1; j >= 0; --j)
		{
			if(Src[i] == Pattern[j])
			{
				dp[i][j] = dp[i + 1][j + 1];
			}
			else
			{
				if(i < nLen1 - 1 || j < nLen2 - 1)//如果在两个字符串的末尾，则默认初始值为0，直接计算
				{			
					if(i + 1 >= nLen1)//设置边界值
					{
						dp[i + 1][j + 1] = Max_N;
						dp[i + 1][j] = Max_N;
					}
					if(j + 1 >= nLen2)//设置边界值
					{
						dp[i][j + 1] = Max_N;
						dp[i + 1][j + 1] = Max_N;
					}
				}
				dp[i][j] = min(dp[i][j + 1], dp[i + 1][j + 1], dp[i + 1][j]) + 1;
			}
		}
	}
	return dp[0][0];
}

下面给出main函数和辅助函数：

#include<stdio.h>
#include<string.h>
#include<assert.h>
const int Max_N = 100;
int dp[Max_N][Max_N];

inline int min(const int a, const int b, const int c)
{
	int t = a < b ? a : b;
	return t < c ? t : c;
}

int main()
{
	char Src[Max_N];
	char Pattern[Max_N];
	while(gets(Src) && gets(Pattern))
	{
		printf("递归：%d\n", CalStr(Src, Pattern));
		printf("非递归：%d\n", CalStrDP(Src, Pattern));
	}
	return 0;
}