动态规划算法的笔记

动态规划笔记（一）

算法基础

基本思想

聊一下动态规划算法的思想，动态规算法和分治法有些像，都是将问题分解成若干个子问题，然后通过子问题的解来得到原问题的解，但是与分治法的区别在于，适合动态规划的问题分解的子问题往往不是相互独立的，如果用分治法来解，很多子问题会重复计算很多次，而动态规划会使用表来保存这些子问题的解，避免重复计算

基本性质

可以使用动态规划算法解决的问题有两个重要的性质：最优子结构和重叠子问题

最优子结构 问题的最优解包含了子问题的最优解
重叠子问题 使用递归算法自顶向下解决问题的时候，每次产生的子问题并不总是新的子问题，有些子问题被反复计算多次。动态规划利用这个性质，对每个子问题只求解一次，将结果保存在一张表这， 便于以后直接利用这些子问题的解

基本步骤

step 1：找出问题最优解的结构特征
step 2：按照问题递归定义列出动态规划方程
step 3：自底向上计算最优值
step 4：按照计算的最优值，递归构造最优解

以矩阵连乘为例

问题定义

矩阵$A_i$的行列数量分别为$p_i$和$p_{i+1}$，矩阵连乘是符合结合律的，也就是$A_i{A}_{i+1}{A}_{i+2}=(A_i{A}_{i+1})A_{i+2}=A_i(A_{i+1}{A}_{i+2})$；假设$A_i=A_{10\times 50},A_{i+1}=A_{50\times 30},A_{i+2}=A_{30\times 20}$；
第一种结合方式：括号中乘法数量为$10\times 50\times 30=15000$，结合后再乘以$A_{i+2}$，这部分乘法数量为$10\times 30\times 20=6000$,总的数量为$15000+6000=21000$
第二章结合方式：括号中的乘法数量为$50\times 30\times 20=30000$，$A_i$乘以括号结果，乘法数量为$10\times 50\times 20=10000$，总数量为$30000+10000=40000$；
可以中看出不同结合方式的计算量是显著不同的，现在有$A_1{A}_2...A_n$总共n个矩阵连乘，如何确定最佳矩阵乘法结合（加括号）方式？

问题的解

step 1：寻找最优子结构

假设$A_i{A}_{i+1}...A_j$最优解加括号方式是在$A_k$除分开，即最优的结合方式分成了两个子链$A_i{A}_{i+1}...A_k$和$A_{k+1}{A}_{k+2}...A_j$，则两个子链分别是两个子问题即矩阵连乘$A_i{A}_{i+1}...A_k$和矩阵连乘$A_{k+1}{A}_{k+2}...A_j$的最优加括号方式。反证法：如果子矩阵连乘问题$A_i{A}_{i+1}...A_k$有更优的加括号结合方式，那么将这个方式加入到矩阵$A_i{A}_{i+1}...A_j$中去，就会得到另一种加括号方式，代价小于$A_i{A}_{i+1}...A_j$的最优加括号方式，与假设矛盾。因此矩阵连乘$A_i{A}_{i+1}...A_j$的最优加括号方式也包括了子问题$A_i{A}_{i+1}...A_k$和子问题$A_{k+1}{A}_{k+2}...A_j$的最优加括号方式，符合动态规划问题性质1——最优子结构。

例如要计算矩阵连乘$A_1{A}_2{A}_3{A}_4$问题，我们有很多子问题的计算是重复的，如果有分治法就会有很多重复计算，如下图，这就满足动态规划的性质2——重叠子问题

step 2：列出动态规划方程
定义$A_i{A}_{i+1}...A_j$需要的最少计算次数为$m[i][j]$，原问题的的最优解就是$m[1][n]$，当$i==j$时，只有一个矩阵，此时$m[i][j]=0$当$i<j$可以用最优子结构来解。设$A_i{A}_{i+1}...A_j$最优加括号方式在$A_k$和$A_{k+1}$处分开，则
$m[i][j]=m[i][k]+m[k+1][j]+p_{i-1}{p}_k{p}_j$
这个公式我们假设已经知道最优分开位置在$k$处，但是实际上我们是不知道的，然后最优的分开的位置只有$j-i$种可能，即$k=i,i+1,...,j-1$。因此，递归方程可以写为如下
m [ i ] [ j ] = { 0 , i = j m i n { m [ i ] [ k ] + m [ k + 1 ] [ j ] + p i − 1 p k p j } , i &lt; = k &lt; j m[i][j]=\left\{\begin{array}{cc} 0, &amp; i=j\\ min\{m[i][k] + m[k+1][j] +p_{i-1}p_kp_j\}, &amp; i &lt;= k &lt; j \end{array}\right. m[i][j]={0,min{m[i][k]+m[k+1][j]+pi−1​pk​pj​},​i=ji<=k<j​

我们的目标是计算$m[1][n]$，
m [ 1 ] [ n ] = { 0 , n = 1 m i n { m [ 1 ] [ k ] + m [ k + 1 ] [ n ] + p 0 p k p n } , 1 &lt; = k &lt; n m[1][n]=\left\{\begin{array}{cc} 0, &amp; n=1\\ min\{m[1][k] + m[k+1][n] +p_{0}p_kp_n\}, &amp; 1 &lt;= k &lt; n \end{array}\right. m[1][n]={0,min{m[1][k]+m[k+1][n]+p0​pk​pn​},​n=11<=k<n​
这里有n个矩阵相乘，我们分解为子问题，单个矩阵乘法运算为0，即下表中第一条对角线$m[i][i]$，有乘法运算的最小粒度为两个矩阵，所以最先计算所有的两个相邻矩阵的连乘结果，即下表中第二条对角线$m[i][i+1]$，相邻两个计算完成后，再计算第三条对角线$m[i][i+2]$的结果，一直到最后一条对角线$m[1][n]$

-	1	2	3	…	n
1	m[1][1]	m[1][2]	m[1][3]	…	m[1][n]
2		m[2][2]	m[2][3]	…	m[2][n]
3			m[3][3]	…	m[3][n]
k				m[k][k]	m[k][n]
n					m[n][n]

step 3：计算最优值

void MartrixChain(int n,int *p,int **m,int **s)
{
	for(int t=0;t<n;t++)                
	{
		m[t][t]=0;             //单一矩阵的情况 
		s[t][t]=-1;
	}                                 
	for(int l=2;l<=n;l++)               //l为段长 
	{
		for(int i=0;i<=n-l;i++)
		{
			int j=i+l-1;              //j为每段的起点   
			m[i][j]=m[i][i]+m[i+1][j]+p[i]*p[i+1]*p[j+1];     //类似于赋初值的功能，其可取i<=k<j中的任意一个
			s[i][j]=i;
			for(int k=i+1;k<j;k++)                         //改变断点，试探出最小的情况
			{
				if(m[i][k]+m[k+1][j]+p[i]*p[k+1]*p[j+1]<m[i][j])
				{
					m[i][j]=m[i][k]+m[k+1][j]+p[i]*p[k+1]*p[j+1];
					s[i][j]=k;                            //记录断点位置（构造最优值需要）
				}
			}
		}
	}
	cout<<"\n最少数乘为 "<<m[0][n-1]<<endl<<endl;
}

step 4：构造最优解
上面求解的时候记录了矩阵分开时的端点位置，用$A[1,n]$表示$A_1{A}_2...A_n$的连乘结果，假设$s[1][n]=k$，则$A[1,n]$的最佳加括号方式为$(A[1,k])(A[k+1,n])$，即$(A[1,s[1][n]])(A[s[1][n]]+1,n)$，而$A[1,s[1][n]]$的最优加括号方式如下
$(A[1,s[1][s[1][n]]])(A[s[s[1][n]]]+1,s[1][n])$
不断递归就能找到最优解了

void TraceBask(int i,int j,int **s)
{
	if(i==j)
		{cout<<"A"<<i;}
	cout<<"(";
	TraceBask(i,s[i][j],s);
	TraceBask(s[i][j]+1,j,s);
	cout<<")";
}