算法设计与分析课程复习笔记7——动态规划

算法设计与分析课程复习笔记7——动态规划

动态规划

• 和分治法一样,是一种算法设计技术。
• 子问题非独立。
• 分治法通过递归方式解决性质相同的子问题，
  而动态规划每次解决一个子问题，并将结果存储在表格中。
• 用于优化类问题。

算法：

1. 描述最优解的结构特征
2. 定义最优解决方案的递归形式
3. 以自底向上的方式计算最优解决方案的值
4. 从计算信息构造出最优解决方案

装配线排程

$S_{1,1},S_{1,2},\dots \dots ,S_{1,n}；S_{2,1},S_{2,2},\dots \dots ,S_{2,n}$为两条装配线的工序站台
$a_{1,1},a_{1,2},\dots \dots ,a_{1,n}；a_{2,1},a_{2,2},\dots \dots ,a_{2,n}$为两条装配线的各站台工作时间
每条装配线的第j个站台的功能相同,但是效率不一致，即花费时间不同。
另外有上线时间$e_1,e_2$和下线时间$x_1,x_2$
以及从一条装配线变换到另一条装配线需要的时间$t_{1,1},t_{1,2},\dots \dots ,t_{1,n-1}；t_{2,1},t_{2,2},\dots \dots ,t_{2,n-1}$

问题：如何充分利用两条装配线,使得组装一辆汽车的时间最短?

解决方法：
1️⃣蛮力法
计算装配线排程所有可能的组合情况，比较并选择出最短时间的组合
2️⃣动态规划
【1】.构建最优解
考虑所有从起点到达$S_{1,j}$可能途径
只有两种可能：
①从$S_{1,j-1}$直接到$S_{1,j}$
②从$S_{2,j-1}$花费$t_{2,j-1}$时间转换到$S_{1,j}$

如果到达$S_{1,j}$的最快装配路线来自$S_{1,j-1}$那么必须是从装配线起点经过$S_{1,j-1}$的最快装配路线。$S_{2,j-1}$同理分析。

最优解的结构
寻求从起点到达$S_{1,j}$最快装配路线，可分解为寻求从起点经过$S_{1,j-1}$ or $S_{2,j-1}$ 最快装配路线问题。
我们将这种具有分解递归特征的解的形式称为最优化结构特征。
利用这种优化构造特征，从子问题的最优化解获得整个问题的最优化的解。

【2】.递归解
利用子问题的最优解，通过递归的方式求解原问题的最优解
$f\ast$为完成所有装配过程的最短时间。
$f_i[j]$表示从起点经过Si,j工序的最短时间.
$f\ast =min(f_1[n]+x_1,f_2[n]+x_2)$

当$j=1$时
$f_1[1]=e_1+a_{1,1}$
$f_2[1]=e_2+a_{2,1}$

当$j\ge 2$时
$f_1[j]=min(f_1[j-1]+a_{1,j},f_2[j-1]+t_{2,j-1}+a_{1,j})$
$f_2[j]=min(f_2[j-1]+a_{2,j},f_1[j-1]+t_{1,j-1}+a_{2,j})$

【3】.计算最优解
如果自顶向下求最优解：

那么将导致指数增长的计算时间。

所以我们选择按$j$递增，即自底向上的方式求解。

【4】.构建最优方案


算法：
FastestWay(a,t,e,x,n)
　$f_1[1]\leftarrow e_1+a_{1,1}$
　$f_2[1]\leftarrow e_2+a_{2,1}$
　for j=2 to n
　　do if $f_1[j-1]+a_{1,j}$ ≤ $f_2[j-1]+t_{2,j-1}+a_{1,j}$
　　　then $f_1[j]\leftarrow f_1[j-1]+a_{1,j}$
　　　　　 $I_1[j]\leftarrow 1$
　　　else $f_1[j]\leftarrow f_2[j-1]+t_{2,j-1}+a_{1,j}$
　　　　　 $I_1[j]\leftarrow 2$
　　　if $f_2[j-1]+a_{2,j}$ ≤ $f_1[j-1]+t_{1,j-1}+a_{2,j}$
　　　then $f_2[j]\leftarrow f_2[j-1]+a_{2,j}$
　　　　　 $I_1[j]\leftarrow 2$
　　　else $f_2[j]\leftarrow f_1[j-1]+t_{1,j-1}+a_{2,j}$
　　　　　 $I_1[j]\leftarrow 1$
　if $f_1[n]+x_1\le f_2[n]+x_2$
　　then $f\ast =f_1[n]+x_1$
　　　　$I\ast =1$
　　else $f\ast =f_2[n]+x_2$
　　　　$I\ast =2$

PrintStation(I,n)
　i ← I*
　print “line” i “,station” n
　for j ← n downto 2
　　do i ←$I_i[j]$
　　print “line” i “,station” j-1

矩阵链相乘

给定矩阵序列$A_1,A_2,\dots ,A_n$，求它们的积
$C=A\ast B$
$co{l}_A=ro{w}_B$
$ro{w}_C=ro{w}_A$
$co{l}_C=co{l}_B$
$A_1,A_2,\dots ,A_n$
$co{l}_i=ro{w}_{i+1}$

矩阵链相乘的顺序极大的影响计算的代价

MatrixMultiply(A,B)
　if columns[A] ≠ rows[B]
　　then error “incompatible dimensions”
　　else for i ← 1 to rows[A]
　　　　　do for j ← 1 to columns[B]
　　　　　　do C[i,j]=0
　　　　　　　 for k ← 1 to columns[A]
　　　　　　　 　do C[i,j] ← C[i,j] + A[i,k]B[k.j]

$A_1,A_2,\dots \dots ,A_n$
$p_0\ast p_1,p_1\ast p_2,\dots \dots ，p_{n-1}\ast p_n$

如何决定矩阵链相乘的顺序，即如何放置括号，使矩阵链相乘所需要的数量乘法的次数最小
1️⃣蛮力法
逐一比较
2️⃣动态规划
【1】.最优矩阵链相乘顺序结构
标记$A_{i\dots j}$=$A_i,A_{i+1},\dots \dots ,A_j$=$A_{i\dots k}{A}_{k+1\dots j}$

假设矩阵链$A_{i\dots j}$相乘的最优顺序在$A_k$和$A_{k+1}$分割

【2】.递归解
求$A_{i\dots j}$数量乘法的次数最小的运算顺序
利用m[i, j]标记$A_{i\dots j}$最小的数量乘法次数

则
$ifi=j$
$m[i,j]=0$
$ifi<j$
m [ i , j ] = m i n i ≤ k ≤ j { m [ i , k ] + m [ k + 1 , j ] + p i − 1 p k p j } m[i,j]=min_{i≤k≤j}\{m[i,k]+m[k+1,j]+p_{i-1}p_kp_j\} m[i,j]=mini≤k≤j​{m[i,k]+m[k+1,j]+pi−1​pk​pj​}

动态规划的适用性

• 最优解包含子问题的最优解
• 递归算法一次又一次地重复同样的问题；只有Θ(n²)个子问题。

【3】.计算解
Matrix-Chain-Order(p)
　n ← length[p]-1;
　for i ← 1 to n
　　m[i, i] ← 0;
　for I ← 2 to n
　　for i ← 1 to n – l +1
　　　j ← i + l -1;
　　　m[i, j] ← $\infty$;
　　　for k ← i to j -1
　　　　q ← m[i, k] + m[k+1, j] + $p_{I-1}{p}_k{p}_j$;
　　　　if q < m[i, j]
　　　　　m[i,j] ← q;
　　　　　s[i, j] ← k;
　return m and s

【4】.构造最优相乘顺序
s[i, j]:记录了$A_i{A}_{i+1}\dots A_j$的最优分割顺序位置

Matrix-Chain-Multiply(A, s, i, j)
　if j > i
　　X ← Matrix-Chain-Multiply(A, s, i, s[i,j]);
　　Y ← Matrix-Chain-Multiply(A, s, s[i, j]+1, j);
　　return Matrix-Multiply(X, Y);
　else return $A_i$;

最长共同子序列LCS

Z =（B,C,A）是X,Y的一个共同子序列
X = （A,B,C,B,D,A,B）
Y = （B, D, C, A, B, A）
X,Y的最长共同子序列为$Z^{\prime }$=(B, D, A, B)

解决方法
1️⃣蛮力法
穷举X的所有子序列，检查其是否在Y中出现，然后选出LCS
2️⃣动态规划
【1】.最优解结构
$X=(x_1,x_2,\dots \dots ，x_m)$
$Y=(y_1,y_2,\dots \dots ，y_n)$
$LCS=Z=(z_1,z_2,\dots \dots z_k)$

如果$x_m=y_n$,那么$z_k=x_m=y_n$,$Z_{k-1}$是$X_{m-1}$和$Y_{n-1}$的LCS
如果$x_m$≠$y_n$,那么$z_k$≠$x_m$就意味着$Z$是$X_{m-1}$和$Y$的LCS
如果$x_m$≠$y_n$,那么$z_k$≠$y_n$就意味着$Z$是$X$和$Y_{n-1}$的LCS

【2】.递归解
C：X 和Y最长共同子序列的长度
c[i,j]:$X_i$ 和$Y_j$最长共同子序列的长度
问题的解即为c[m,n]

$$c[i,j]=\{\begin{array}{r}0,ifi=0orj=0\\ c[i-1,j-1]+1,if{x}_i=y_j,i,j>0\\ max(c[i,j-1],c[i-1,j]),if{x}_i̸=y_j,i,j>0\end{array}$$

【3】.计算解
LCS算法：
LCSlength(X,Y)
　m ← length(X)
　n ← length(Y)
　for i ← 1 to m
　　c[i,0] ← 0
　for j ← 0 to n
　　c[0,j] ← 0
　for i ← 1 to m
　　for j ← 1 to n
　　　if $x_i$=$y_j$
　　　　c[i,j] ← c[i-1,j-1] + 1
　　　　b[i,j] ← “↖”
　　　else if c[i-1,j] ≥ c[i,j-1]
　　　　　　c[i,j] ← c[i-1,j]
　　　　　　b[i,j] ← “↑”
　　　　　else c[i,j] ← c[i,j-1]
　　　　　　　b[i,j] ← “←”
　return c and b

算法分析：其实就是简单的填表，一个格子的计算量为O(1),总共m*n个格子，所以总计算开销$O(mn)$

【4】.构建最长共同子序列

参考：任课教师邱德红教授的课件