动态规划问题 字符串相似度 和字符串最长公共子序列

#include<stdio.h>
#include <stdlib.h>
#include<string.h>
#include <assert.h>
/*
动态规划问题： 字符串相似度距离 和字符串的最长公共子序列长度
动态规划问题适用于经分解得到的子问题往往不是相互独立的
一般分为下面4个步骤：
1 描述最优解的结构
2 递归定义最优解的值
3 按照自底向上方式计算最优解的值
4 有计算结果构造一个最优解
适合于动态规划方法的最优解问题的两个要素： 最优子结构 重叠子问题
子结构是原问题的子问题 分析时 用整体分析 求解时 从子问题求解
重叠子问题 能够记录中间值（子问题的值）
最后根据子问题的值 求解出整体的值
*/
int min( int a, int b,int c)
{
	int t = a<b ?a:b;
	return t<c?t:c;
}
int max(int a,int b)
{
	return a>b?a:b;
}
int min_distance(const char* a,const char* b) //字符串相似度 求距离 相似度= 距离 +１　的倒数
{
	
	int len_a = strlen(a);
	int len_b = strlen(b);
	//申请临时数组 保存中间值 大小为 (lena + 1) * (lenb + 1); 记得要释放
	int** c = (int**)malloc( sizeof(int*)*(len_a + 1 ) );

	for(int i = 0;i< len_a + 1 ;i++)
		c[i] = (int*)malloc(sizeof(int) * (len_b +1) );
	//数组初始化
	for(int i = 0;i<len_b;i++)
		c[len_a][i] = len_b - i;

	for(int i  =0;i<len_a;i++)
		c[i][len_b] = len_a - i;
	
	c[len_a][len_b] = 0;  //这个初始化特例要考虑
	
	for(int i = len_a-1;i>=0;i--)
		for(int j = len_b -1;j>=0;j--)
		{
			if(a[i] == b[j])
			{
				c[i][j] = c[i+1][j+1];
			}
			else
			{
				c[i][j] = min(c[i+1][j+1],c[i+1][j],c[i][j+1]) + 1;
			}
		}
	int ret = c[0][0];

	//释放空间
	for(int i = 0;i<len_a +1 ;i++)
		free(c[i]);
	free(c);
	return ret;
}
int max_sublen(char*a ,char* b) //两个字符串的最长公共子序列 
{
	int lena = strlen(a);
	int lenb = strlen(b);
	int** c = (int**)malloc(sizeof(int*) * (lena +1));
	for(int i = 0;i<lena+1;i++)
		c[i] = (int*) malloc(sizeof(int) * (lenb +1));
	for(int i = 0;i<lenb ;i++)
		c[lena][i] = 0;
	for(int j = 0;j<lena ;j++)
		c[j][lenb] = 0;
	//c[lena][lenb] = 0; 这个多赋值了一次 还有可能这个值比较特殊 建议单独赋值
	c[lena][lenb] = 0;
	for(int i=lena -1;i>=0;i--)
		for(int j = lenb -1;j >=0;j--)
		{
			if(a[i] ==b[j])
				c[i][j] = 1 +c[i+1][j+1];
			else
				c[i][j] = max(c[i+1][j],c[i][j+1]);
		}
	int ret = c[0][0];
	//释放空间
	for(int i = 0;i<lena +1;i++)
		free(c[i]);
	free(c);
	return ret;
}

int main()
{
	
	
	system("pause");
	return 0;
}