LeetCode学习:动态规划 矩阵连乘

基本思想:待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同：子问题往往不是互相独立。

特征：1.最优解包含着其子问题的最优解（最优子结构）。2.子问题重叠性质。

用一个表来记录所有已解决的子问题的答案。不管该子问题是否被用到，只要它被计算过，就将其结过填入表中。

设计算法步骤：

（1）找出最优解的性质，并刻画其结构特征。

（2）递归地定义最优解。

（3）以自底向上的方式计算出最优值。

（4）根据计算最优值时得到的信息，构造最优解。

 

备忘录方法是动态规划算法的变形。与动态规划算法一样，备忘录方法用表格保存已解决的子问题的答案，在下次需要解此子问题时，只要简单地查看该子问题的解答，而不必重新计算。

与动态规划不同的是：1.备忘录方法的递归方式是自顶向下。2.动态规划算法则是自底向上递归的。

一、矩阵连乘问题：

建立递归关系：

 #include<iostream>
 using namespace std;
  
 static void matrixChain(int p[],int m[][7],int s[][7],int n)//m存最优值，s存断开位置。 
 {
	 for(int i=1;i<=n;i++)m[i][i]=0;
	 for(int r=2;r<=n;r++)//r子问题个数 
	 	for(int i=1;i<=n-r+1;i++)
		 {
 			int j=i+r-1;
 			m[i][j]=m[i+1][j]+p[i-1]*p[i]*p[j];//m[i][i]=0,从i处分开
			s[i][j]=i;
			for(int k=i+1;k<j;k++)
			{
				int t=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];//k为可分开的位置，遍历得到最小值
				if(t<m[i][j]){
					m[i][j]=t;
					s[i][j]=k;
				} 
			} 
 		}	
 } 
 
 static void traceback(int s[][7],int i,int j)
 {
 	if(i==j) return;
	traceback(s,i,s[i][j]);
	traceback(s,s[i][j]+1,j);
	//System.out.println("Multiply A"+i+","+s[i][j]+"and A"+(s[i][j]+1)+","+j);
	cout<<"Multiply A"<<i<<","<<s[i][j]<<"and A"<<(s[i][j]+1)<<","<<j<<endl;
 }
 int main()
 {
 	int p[]={30,35,15,5,10,20,25};
 	int m[7][7];
 	int s[7][7];
 	matrixChain(p,m,s,6);
	for(int i=1;i<=6;i++)
	{
		for(int j=i;j<=6;j++)
		{
			cout<<m[i][j]<<" ";
		}
		cout<<endl;
	} 
	traceback(s,1,6);
 }