动态规划

一、动态规划的基本思想
动态规划算法通常用于求解具有某种最优性质的问题。
在这类问题中，可能会有许多可行解。
我们希望找到具有最优值的解。
基本思想是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
二、动态规划问题的特征
动态规划算法的有效性依赖于问题本身所具有的两个重要性质：
最优子结构：
当问题的最优解包含了其子问题的最优解时，称该问题具有最优子结构性质。
重叠子问题
动态规划算法的有效性依赖于问题本身所具有的两个重要性质：
最优子结构：
重叠子问题：
在用递归算法自顶向下解问题时，每次产生的子问题并不总是新问题，有些子问题被反复计算多次。动态规划算法(自底向上)正是利用了这种子问题的重叠性质，对每一个子问题只解一次，而后将其解保存在一个表格中，在以后尽可能多地利用这些子问题的解。
三、设计动态规划法的步骤
找出最优解的性质，并刻画其结构特征；
递归地定义最优值（写出动态规划方程）；
以自底向上的方式计算出最优值；
根据计算最优值时得到的信息，构造一个最优解。
步骤1～3是动态规划算法的基本步骤。
在只需要求出最优值的情形，步骤4可以省略；
若需要求出问题的一个最优解，则必须执行步骤4。
五.矩阵连乘问题
设有四个矩阵A,B,C,D，它们的维数分别是：A=50×10，B=10×40，C=40×30，D=30×5
总共有五种完全加括号的方式：
(A((BC)D))
(A(B(CD)))
((AB)(CD))
(((AB)C)D)
((A(BC))D)
将矩阵连乘积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[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
可以递归地定义m[i][ j]为
m[i,j]=0;i=j
m[i,j]=min{m[i,k]+m[k+1,j]+Pi-1PkPj};i<j;
#define NUM 51
int p[NUM];//记录矩阵的行列数的值，p[0]记录第一个矩阵行数，之后的数组分量依次记录其他矩阵的列数。数组分量的个数等于矩阵的个数+1

int m[NUM][NUM];//状态，记录子问题的最优值
int s[NUM][NUM];//记录子问题的最优解
void MatrixChain　(int n){
　　for (int i=1; 　i<=n; 　i++)　m[i][i] = 0;//长度是1的矩阵链连乘的计算次数
　　for (int r=2; r<=n; 　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][j]的假设值
　　s[i][j] = i;　//断开位置的初值，记录即最优解的初值
　　//计算m[i][j]的最小值，即确定断开的最佳位置，子问题的最优解
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;}
　　}
}
}
计算矩阵连乘积的递归算法
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;
}
备忘录方法
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的最长公共子序列。
用c[i][j]记录序列的最长公共子序列的长度。
Xi={x1,x2,…,xi}；Yj={y1,y2,…,yj}。
当i=0或j=0时，c[i][j]=？
故此时c[i][j]=0。
其它情况下：
x[i]==y[j], c[i][j]=?
c[i][j]=c[i-1][j-1]+1
x[i]!=y[j], c[i][j]=?
c[i][j]=max(c[i-1][j], c[i][j-1])
#define NUM 100
int c[NUM][NUM]; //x[1-i] 和 y[1-j]之间的公共子序列的长度。
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; } //←
　　}
}
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; } //←
　　}
}
void LCS(int i,int j,char x[]){
if (i 0 || j0) return;
if (b[i][j] 1){
LCS(i-1,j-1,x);　
cout<<x[i];
}
else if (b[i][j] 2)
LCS(i-1,j,x);
else
LCS(i,j-1,x);
}

4.5 0-1背包问题
给定一个物品集合s＝｛1，2，3，…，n｝，物品i的重量是wi，其价值是vi，背包的容量为W，即最大载重量不超过W。在限定的总重量W内，我们如何选择物品，才能使得物品的总价值最大。
如果物品不能被分割，即物品i要么整个地选取，要么不选取；
不能将物品i装入背包多次，也不能只装入部分物品i，则该问题称为0-1背包问题。
如果物品可以拆分，则问题称为背包问题，适合使用贪心算法。
阶段:
i~n ，依次处理每一件物品
状态：
背包的容量：0~V
决策：
在第i阶段,在背包容量是V 的情况下，如何处理第i 件物品，才能使装入背包中的物品最大。
f[i][v]表示前i件物品(部分或全部)放入一个容量为v的背包可以获得的最大价值。
处理方案：在W[i]>V的情况下，不装入；否则，根据
max{f[i-1][v],f[i-1][v-w[i]]+c[i]}
进行决策
状态转移方程便是：
f[i][v]=max{f[i-1][v],f[i-1][v-w[i]]+c[i]}。
　　#include
using namespace std;
const int maxm = 201, maxn = 31;
int m, n; int w[maxn], c[maxn]; int f[maxn][maxm];
int max(int x,int y) { x>y?x:y;} //求x和y最大值
int main(){
scanf("%d%d",&m, &n); //背包容量m和物品数量n
for (int i = 1; i <= n; i++)
scanf("%d%d",&w[i],&c[i]); //每个物品的重量和价值
for (int i = 1; i <= n; i++) // f[i][v]表示前i件物品，总重量不超过v的最优价值
for (int v = m; v > 0; v–)
if (w[i] <= v)
f[i][v] = max(f[i-1][v],f[i-1][v-w[i]]+c[i]);
else
f[i][v] = f[i-1][v];
printf("%d",f[n][m]); // f[n][m]为最优解
return 0;
}

4.6 最长单调递增子序列
设计一个O(n2)时间的算法, 找出由n个数组成的序列的最长单调递增子序列。
输入: 第1个整数n(0<n<100),表示后面有n个数据，全部为整数。
输出: 输出最长单调递增子序列的长度；
样例输入
8 65 158 170 155 239 300 207 389
样例输出
6
用数组b[0:i]记录以a[i] (0≤i<n) 为结尾元素的最长递增子序列的长度。
序列a的最长递增子序列的长度为：max {b[i]} (0≤i<n)
显然，b[i]满足最优子结构性质。
证明：根据b[i] 的定义：
b[i]为以a[i] (0≤i<n) 结尾的最长单调子序列长度。
即 存在一个 a[k],1<=k<=i-1 ,并且 a[i]>=a[k],并且 b[k]=max(b[ j]), 1<=j<=i-1
所以：b[i]=b[k]+1.
如果存在k’, b[k’]>b[k] ,并且 a[i]>=a[k’],即
b[i]不是满足条件的最大值。这与定义矛盾。
因此， 该问题满足最优子结构性质。
用数组b[0:i]记录以a[i] (0≤i<n) 为结尾元素的最长递增子序列的长度。
序列a的最长递增子序列的长度为：max {b[i]}
显然，b[i]满足最优子结构性质，可以递归的定义为：
b[0] = 1;
b[i] = max {b[k]} + 1

即k在0~(i-1)范围内, 若a[k] ≤a[i], 寻找最大的b[k].
据此将计算b[i]转化为i个规模更小的子问题。
#define NUM 100
int a[NUM];　　　　　　//序列L
int LIS_n2(int n) 　{　　
　int b[NUM]={0};　　　//辅助数组b
　int i,j;
　b[1] = 1; //以a[1]结尾的子序列中只包含一个元素
　int max = 0;　　　　　//数组b的最大值
　for (i=2;i<=n; i++) {
　　int k = 0;
　　for (j=1; j<i; j++)　　//0~i-1之间，b的最大值
　　　if (a[j]<=a[i] && k<b[j]) k=b[j];
　　b[i] = k+1;
　　if (max<b[i])
max=b[i];
　}
　return max;
}