数据结构-练习 17 动态规划 2

参考文献《算法导论》

LCS问题：

 描述，LCS英文：longest common string。中文：最长公共子序列。即找出两个字符串里，最长的子序列。比如：

A  D  F  G   C  和 B  F  C   则最长的子序列为F  C.

对应任意给点俩个字符串，我们尝试给出通用的算法。

采用动态规划，因为满足动态规划的特征：

1.寻找的是最优问题

2.子问题互相间独立

3.子问题能重叠，即子子最优是子最优的最优

递推公式，引用书本上的，如下：

进行递归时，我们脑子里时刻记住两样东西：

子问题是什么

最优问题是什么

子问题是程序递归的体现，最优问题是程序if的体现

看了半天，说实话，《算法导论》上的方法 真没看懂，结合代码 终于开窍了。

尝试自己分析一下，书上不是一堆公式，就是言简意赅。

比如，给出两个字符串：“b d c a b a”和"a b c b d a b",采用动态规划的思想，最优问题是：字符串最长，用c[i,j]表示，其中 i，j是字符串的位置标号 ；子问题是：c[i,j-1]和c[i-1,j]。引用书上的表格分析法

结合递推公式，分析：i=1是，取A ,依次与j=1,2,3...比较，分两种情况，当在i=1这行也取到A时，此时单元格里填入的数字，应该是对角线上的左上角的数字再加1，否则，比较单元格上面和左面的数字，取大的放到单元格里。如：在坐标（1,1）处，对应的是：A和B,不相等，观察上边和左边的单元格都是0，则填入0.在坐标（1,4）处，A终于碰着了A，此时先查看坐标(0,3)处的单元格里是0，则填入0+1=1.其余类似，箭头代表的就是取数据的来源，记下箭头，可以在找到最长子序列时进行回溯哦。

上代码：

void findLCS(string str1,string str2 ) 
 {   
	 
	 int m=str1.length();
	 int n=str2.length();
	 int c[50][50];
	 int mark[50][50]={0};
     

	 for(int i=0;i<m+1;++i)
		 c[i][0]=0;
	 for(int j=0;j<n+1;++j)
		 c[0][j]=0;

	 for(int i=1;i<=m;++i)
	   for(int j=1;j<=n;++j)
	   {
		   if(str1[i-1]==str2[j-1])
		   {
			   c[i][j]=c[i-1][j-1]+1;
			   mark[i][j]=1;//表示↖
			   
		   }
		   else if(c[i-1][j]>=c[i][j-1])
		   {
		    c[i][j]=c[i-1][j];
			mark[i][j]=2;//表示↑
		   }
		   else
		   {
		    c[i][j]=c[i][j-1];
		    mark[i][j]=3;//表示←
		   }
	   }
	   for(int i=0;i<=m;++i)
	   {
		   for(int j=0;j<=n;++j)
			   cout<<mark[i][j];
		   cout<<endl;
	   }
	   cout<<mark[0]<<" "<<mark[1]<<mark;
     printLCS(mark,m,n,str1);

 }

复杂度为：O(m*n)。
打印LCS:

void printLCS(int(* a)[50],int r,int c,string str)
{
      if(r==0||c==0) return;
      if(a[r][c]==1)
		 
	  {
		  printLCS(a,r-1,c-1,str);
	      cout<<str[r-1];
	  }
	  else
		  if(a[r][c]==2) printLCS(a,r-1,c,str);
		  else printLCS(a,r,c-1,str); 

}

复杂度：O(m+n)
测试：

int main()
{
string a="bdcaba";
string b="abcbdab";
findLCS(b,a); 

return 0;
}

推荐一个解决矩阵相乘的动态规划：http://blog.csdn.net/liguisen/article/details/2158127