动态规划

一.基本思想:
动态规划算法通常用于求解具有某种最优性质的问题。
在这类问题中，可能会有许多可行解。
每一个解都对应于一个值，我们希望找到具有最优值的解。
基本思想是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。
二.基本步骤：
找出最优解的性质，并刻画其结构特征；
递归地定义最优值（写出动态规划方程）；
以自底向上的方式计算出最优值；
根据计算最优值时得到的信息，构造一个最优解。
步骤1～3是动态规划算法的基本步骤。
在只需要求出最优值的情形，步骤4可以省略；
若需要求出问题的一个最优解，则必须执行步骤4。
三.特征：
动态规划算法的有效性依赖于问题本身所具有的两个重要性质：
最优子结构：
当问题的最优解包含了其子问题的最优解时，称该问题具有最优子结构性质。
重叠子问题：
在用递归算法自顶向下解问题时，每次产生的子问题并不总是新问题，有些子问题被反复计算多次。动态规划算法正是利用了这种子问题的重叠性质，对每一个子问题只解一次，而后将其解保存在一个表格中，在以后尽可能多地利用这些子问题的解。

连乘积问题：







设有四个矩阵A, B, C, D，它们的维数分别是：
A=50×10, B=10×40, C=40×30, D=30×5
矩阵A和B可乘的条件： 矩阵A的列数等于矩阵B的行数。
设A是p×q的矩阵, B是q×r的矩阵, 乘积是p×r的矩阵;计算量是pqr。
上述5种完全加括号方式的计算工作量为:
(A((BC)D)), (A(B(CD))), ((AB)(CD)), (((AB)C)D), ((A(BC)D))
16000, 10500, 36000, 87500, 34500
BC: 10×40×30 = 12000,
(BC)D: 10×30×5 = 1500,
(A((BC)D)): 50×10×5 = 2500
给定n个矩阵｛A1,A2,…,An｝，其中Ai与Ai+1是可乘的，i=1，2…，n-1。如何确定计算矩阵连乘积的计算次序，使得依此次序计算矩阵连乘积需要的数乘次数最少？
穷举法：列举出所有可能的计算次序，并计算出每一种计算次序相应需要的数乘次数，从中找出一种数乘次数最少的计算次序。


将矩阵连乘积AiAi+1…Aj 简记为A[i:j], 这里i≤j;
考察计算A[1:n]的最优计算次序。
设这个计算次序在矩阵Ak和Ak+1之间将矩阵链断开，1≤k<n，则其相应完全加括号方式为(A1A2…Ak)(Ak+1Ak+2…An)
计算量：A[1:k]的计算量加上A[k+1:n]的计算量，再加上A[1:k]和A[k+1:n]相乘的计算量
特征：计算A[1:n]的最优次序所包含的计算矩阵子链 A[1:k]和A[k+1:n]的次序也是最优的。
矩阵连乘计算次序问题的最优解包含着其子问题的最优解。
这种性质称为最优子结构性质。
问题的最优子结构性质是该问题可用动态规划算法求解的显著特征。
设计算A[i: j]，1≤i≤j≤n，所需要的最少数乘次数m[i, j]，则原问题的最优值为m[1,n]
当i=j时，A[i: j]=Ai，因此，m[i, i]=0，i=1,2,…,n
当i<j 时，

这里Ai的维数是Pi-1×Pi


对于1≤i≤j≤n不同的有序对(i, j)对应于不同的子问题。因此，不同子问题的个数最多只有

在递归计算时，许多子问题被重复计算多次。
这也是该问题可用动态规划算法求解的又一显著特征。
用动态规划算法解此问题，可依据其递归式以自底向上的方式进行计算。
在计算过程中，保存已解决的子问题答案。
每个子问题只计算一次，在后面需要时只要简单查一下，从而避免大量的重复计算，最终得到多项式时间的算法。

#define NUM 51
int p[NUM];
int m[NUM][NUM];
int s[NUM][NUM];
void MatrixChain　(int n)
{
　　for (int i=1; 　i<=n; 　i++)　m[i][i] = 0;
　　for (int r=2;　 r<=n; 　r++)
	for (int i=1;　 i<=n-r+1;　 i++) 
	{
	　　int j=i+r-1;　
	　　//计算初值，从i处断开
	　　m[i][j] = m[i+1][j]+p[i-1]*p[i]*p[j];
	　　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];
		if (t < m[i][j]) {m[i][j] = t; s[i][j] = k;}
	　　}
	}
}

算法4.2计算矩阵连乘积最优解的递归算法
void TraceBack(int i, int j)
{
if(i==j) printf(“A%d”, i);
else
{
printf("(");
TraceBack(i,s[i][j]);
TraceBack(s[i][j]+1,j);
printf(")");
}
}4.2.1 最优子结构
设计动态规划算法的第一步是刻画最优解的结构。
当问题的最优解包含其子问题的最优解时，称该问题具有最优子结构性质。
问题的最优解子结构性质提供了该问题可用动态规划求解的重要线索。
动态规划算法中，利用问题的最优子结构性质，以自底向上的方法递归的从子问题的最优解逐步构造出整个问题的最优解。
使我们能在相对小的子问题空间中考虑问题。
4.2.2 重叠子问题
递归算法求解问题时，每次产生的子问题并不总是新问题，有些子问题被反复计算多次。
这种性质称为子问题的重叠性质。
动态规划算法，对每一个子问题只解一次，而后将其解保存在一个表格中，当再次需要解此子问题时，只是简单地用常数时间查看一下结果。

算法4.3 计算矩阵连乘积的递归算法

int Recurve(int i, int j)
{
　　if (i == j) return 0;
　　int u = Recurve(i, i)+Recurve(i+1,j)+p[i-1]*p[i]*p[j];
　　s[i][j] = i;
　　for (int k = i+1; k<j; k++) 
　　{
	int t = Recurve(i, k) + Recurve(k+1,j)+p[i-1]*p[k]*p[j];
	if (t<u) { u = t; s[i][j] = k;}
　　}
　　m[i][j] = u;
　　return u;
} 

4.1.3 备忘录方法
备忘录方法是动态规划算法的变形。
与动态规划算法一样，备忘录方法用一个表格保存已解决的子问题的答案，再碰到该子问题时，只要简单地查看该子问题的解答，而不必重新求解。
备忘录方法的控制结构与直接递归方法的控制结构相同，区别仅在于备忘录方法为每个解过的子问题建立了备忘录以备需要时查看，避免了相同子问题的重复求解。
int LookupChai (int i, int j)
{
　　if (m[i][j]>0) return m[i][j];
　　if (i==j) return 0;
　　int u = LookupChain(i,i)+LookupChain(i+1,j)+p[i-1]*p[i]*p[j];
　　s[i][j] = i;
　　for (int k = i+1; k<j; k++)
　　{
int t = LookupChain(i,k)+LookupChain(k+1,j)+p[i-1]*p[k]*p[j];
if (t < u) { u = t; s[i][j] = k;}
　　}
　　m[i][j] = u;
　　return u;
}
若给定序列X={x1,x2,…,xm}，则另一序列Z={z1,z2,…,zk}，是X的子序列是指存在一个严格递增下标序列{i1,i2,…,ik}使得对于所有j=1,2,…,k有：zj=xij。
例如，序列Z={B，C，D，B}是序列X={A，B，C，B，D，A，B}的子序列，相应的递增下标序列为{2，3，5，7}。
给定2个序列X和Y，当另一序列Z既是X的子序列又是Y的子序列时，称Z是序列X和Y的公共子序列。
给定2个序列X={x1,x2,…,xm}和Y={y1,y2,…,yn}，找出X和Y的最长公共子序列。 设序列X={x1,x2,…,xm}和Y={y1,y2,…,yn}的最长公共子序列为Z={z1,z2,…,zk} ，则
若xm=yn，则zk=xm=yn，且zk-1是xm-1和yn-1的最长公共子序列。
若xm≠yn且zk≠xm，则Z是xm-1和Y的最长公共子序列。
若xm≠yn且zk≠yn，则Z是X和yn-1的最长公共子序列。

由最长公共子序列问题的最优子结构性质可知，要找出X和Y的最长公共子序列，可按以下方式递归地进行：
当xm＝yn时，找出Xm－1和Yn－1的最长公共子序列，然后在其尾部加上xm（＝yn）即可得X和Y的一个最长公共子序列。
当xm≠yn时，必须解两个子问题，即找出Xm－1和Y的一个最长公共子序列及X和Yn－1的一个最长公共子序列。这两个公共子序列中较长者为X和Y的一个最长公共子序列。


算法4.5计算最长公共子序列的动态规划算法
#define NUM 100
int c[NUM][NUM];
int b[NUM][NUM];
void LCSLength　(int m, int n, const char x[],char y[])
{
　　int i,j;
　　//数组c的第0行、第0列置0
　　for (i = 1; i <= m; i++) c[i][0] = 0;
　　for (i = 1; i <= n; i++) c[0][i] = 0;
　　//根据递推公式构造数组c
　　for (i = 1; i <= m; i++)
　　for (j = 1; j <= n; j++)
　　{
if (x[i]y[j])
　　{c[i][j]=c[i-1][j-1]+1; b[i][j]=1; } //↖
else if (c[i-1][j]>=c[i][j-1])
{c[i][j]=c[i-1][j]; b[i][j]=2; } //↑
else { c[i][j]=c[i][j-1]; b[i][j]=3; } //←
　　}
}算法4.5计算最长公共子序列的动态规划算法
……
void LCSLength　(int m, int n, const char x[],char y[])
{
　　int i,j;
　　//数组c的第0行、第0列置0
　　……;
　　//根据递推公式构造数组c
　　for (i = 1; i <= m; i++)
　　for (j = 1; j <= n; j++)
　　{
if (x[i]y[j])
　　{c[i][j]=c[i-1][j-1]+1; b[i][j]=1; } //↖
else if (c[i-1][j]>=c[i][j-1])
{c[i][j]=c[i-1][j];　 b[i][j]=2; } //↑
else { c[i][j]=c[i][j-1]; b[i][j]=3; } //←
　　}
}
算法4.6计算最长公共子序列的动态规划算法
void LCS(int i,int j,char x[])
{
if (i 0 || j0) return;
if (b[i][j] 1){ LCS(i-1,j-1,x);　 printf("%c",x[i]); }
else if (b[i][j] 2) LCS(i-1,j,x);
else LCS(i,j-1,x);
}
给定由n个整数（包含负整数）组成的序列a1,a2,…,an，求该序列子段和的最大值。
当所有整数均为负值时定义其最大子段和为0。
所求的最优值为：

例如，当(a1,a2, ……a7,a8)=(1,-3, 7,8,-4,12, -10,6)时，最大子段和为：
bj是1到j位置的最大子段和:
由bj的定义易知，当bj-1>0时bj=bj-1+aj，否则bj=aj。
则计算bj的动态规划递归式：
bj=max{bj-1+aj，aj}，1≤j≤n。
#define NUM 1001
int a[NUM];
int MaxSum(int n)
{
int sum=0;
int b=0;
for (int i=1;i<=n;i++)
{
if (b>0) b+=a[i]; else b=a[i];
if (b>sum) sum=b;
}
return sum;
}
令besti，bestj为最大子段和sum的起始位置和结束位置；
在当前位置i，如果b[i-1] ≤0时，在取b[i]=a[i] 的同时，保存该位置i到变量begin中，显然：
当b(i-1)≤0时，begin＝i；
当b(i)≥sum时，besti＝begin，bes
tj＝i。
#define NUM 1001
int a[NUM];
int MaxSum(int n, int &besti, int &bestj)
{
　　int sum=0;
　　int b=0;
　　int begin = 0;
　　for (int i=1;　i<=n;　i++)
　　{
if (b>0)　 b+=a[i];
else {b=a[i];　begin = i;}
if (b>sum) //得到新的最优值时，更新最优解
{
　　sum = b;
　　besti = begin;
　　bestj = i;
}
　　}
　　return sum;
}
0-1背包：
给定一个物品集合s＝｛1，2，3，…，n｝，物品i的重量是wi，其价值是vi，背包的容量为W，即最大载重量不超过W。在限定的总重量W内，我们如何选择物品，才能使得物品的总价值最大。
如果物品不能被分割，即物品i要么整个地选取，要么不选取；
不能将物品i装入背包多次，也不能只装入部分物品i，则该问题称为0—1背包问题。
如果物品可以拆分，则问题称为背包问题，适合使用贪心算法。
假设xi表示物品i装入背包的情况，xi＝0，1。
当xi＝0时，表示物品没有装入背包；
当xi＝1时，表示把物品装入背包。
约束方程： ≤W

目标函数：
因此问题就归结为找到一个满足上述约束方程，并使目标函数达到最大的解向量：
X＝{x1，x2，…，xn},
0—1背包问题具有最优子结构性质，设所给0—1背包问题的子问题：

i≤k≤n的最优值为p(i，j)。
是背包容量为j，可选物品为i，i＋1，…，n时0-1背包问题的最优值。
void traceback( int c, int n, int x[ ])
{
　for(int i=1; i<n; i++)
　{
　　if (p[i][c]==p[i+1][c]) x[i]=0;
　　else { x[i]=1; c-=w[i]; }
　}
　x[n]=(p[n][c])? 1:0;
}
砖块叠塔
int DP(int serial) //形参serial是砖块的编号
{
　　//如果第serial块砖已经计算过，直接返回结果（记忆式搜索）
　　if (height[serial] != -1) return height[serial];
　　//所有砖块计算完毕
　　if (serial > number) return 0;
　　//搜索每一块砖
　　int t = 0;
　　for (int i=1; i<=number; ++i)
　　{
　　　　//第serial块砖能够放上去，直放/横放各一次
　　　　if ((box[serial][0]>box[i][0] && box[serial][1]>box[i][1]) ||
　　　　　　(box[serial][0]>box[i][1] && box[serial][1]>box[i][0]))
　　　　　　t = DP(i) + box[i][2];
　　　　//能够获得最优解
　　　　if (t > height[serial]) height[serial] = t;
　　}
　　return height[serial];
}
//最优值在height[0]单元中，因为第0号单元是地板。
搜索算法
如果把一块砖的所有6种摆放方式，转化为6种不同的砖块，相当于有6n种砖块；
按一个方向从大到小排序，就像叠罗汉一样将它们全部叠起来；
依次检查每一块与其下面的所有砖块是否满足摆放条件；
将每一块砖放到塔中能够获得的的最大高度记录到数组中：
int height[200];
再从数组height中查找最大值，该最大值就是答案answer。