算法设计与分析---第4章 动态规划

动态规划的基本思想
动态规划算法通常用于求解具有某种最优性质的问题。基本思想是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。我们可以用一个表来记录所有已解的子问题的答案。不管该子问题以后是否被用到，只要它被计算过，就将其结果填入表中。
设计动态规划法的步骤
1、找出最优解的性质，并刻画其结构特征；
2、递归地定义最优值（写出动态规划方程）；
3、以自底向上的方式计算出最优值；
4、根据计算最优值时得到的信息，构造一个最优解。
动态规划问题的特征
动态规划算法的有效性依赖于问题本身所具有的两个重要性质：

1. 最优子结构： 当问题的最优解包含了其子问题的最优解时，称该问题具有最优子结构性质。
2. 重叠子问题： 在用递归算法自顶向下解问题时，每次产生的子问题并不总是新问题，有些子问题被反复计算多次。动态规划算法正是利用了这种子问题的重叠性质，对每一个子问题只解一次，而后将其解保存在一个表格中，在以后尽可能多地利用这些子问题的解。

4.1 矩阵连乘积问题
定义：给定n个矩阵{A1,A2,…,An}，其中Ai与Ai+1是可乘的，i=1,2,…n-1。考察这n个矩阵的连乘积A1A2…An。
由于矩阵乘法满足结合律，所以计算矩阵的连乘可以有许多不同的计算次序。 这种计算次序可以用加括号的方式来确定。 若一个矩阵连乘积的计算次序完全确定，也就是说该连乘积已完全加括号，则可以依此次序反复调用2个矩阵相乘的标准算法计算出矩阵连乘积。
完全加括号的矩阵连乘积可递归地定义为：
单个矩阵是完全加括号的；
矩阵连乘积A是完全加括号的，则A可表示为2个完全加括号的矩阵连乘积B和C的乘积并加括号，即A=(BC)
矩阵A和B可乘的条件： 矩阵A的列数等于矩阵B的行数。
设A是p×q的矩阵, B是q×r的矩阵, 乘积是p×r的矩阵;计算量是pqr。
4.1.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]的次序也是最优的。
矩阵连乘计算次序问题的最优解包含着其子问题的最优解。

#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;
			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;
				}  　　
			}
		}
}

算法复杂度分析：

1. 算法matrixChain的主要计算量取决于算法中对r，i和k的3重循环。
2. 循环体内的计算量为O(1)。
3. 3重循环的总次数为O(n3)。

因此算法的计算时间上界为O(n3)。
算法所占用的空间显然为O(n2)。
s[i][j]已经存储了构造最优解所需要的足够的信息。
计算矩阵连乘积最优解的递归算法

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(")");   
	} 
}

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

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; 
}

4.3 最长公共子序列
若给定序列X={x1,x2,…,xm}，则另一序列Z={z1,z2,…,zk}，是X的子序列是指存在一个严格递增下标序列{i1,i2,…,ik}使得对于所有j=1,2,…,k有：zj=xij。
给定2个序列X和Y，当另一序列Z既是X的子序列又是Y的子序列时，称Z是序列X和Y的公共子序列。
给定2个序列X={x1,x2,…,xm}和Y={y1,y2,…,yn}，找出X和Y的最长公共子序列。
4.3.1 最长公共子序列的结构
设序列X={x1,x2,…,xm}和Y={y1,y2,…,yn}的最长公共子序列为Z={z1,z2,…,zk} ，则

1. 若xm=yn，则zk=xm=yn，且zk-1是xm-1和yn-1的最长公共子序列。
2. 若xm≠yn且zk≠xm，则Z是xm-1和Y的最长公共子序列。
3. 若xm≠yn且zk≠yn，则Z是X和yn-1的最长公共子序列。

4.3.2 子问题的递归结构
用c[i][j]记录序列和的最长公共子序列的长度。 Xi={x1,x2,…,xi}；Yj={y1,y2,…,yj}。 当i=0或j=0时，空序列是Xi和Yj的最长公共子序列。
故此时C[i][j]=0。
其它情况下，由最优子结构性质可建立递归关系如下：

4.3.3 计算最优值
算法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;
	for (i = 1; i <= m; i++) 
		c[i][0] = 0; 　　
	for (i = 1; i <= n; i++) 
		c[0][i] = 0; 　　
	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.3.4 构造最长公共子序列
算法4.6计算最长公共子序列的动态规划算法

void LCS(int i,int j,char x[]) 
{  
	if (i ==0 || j==0) 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); 
}

4.4 最大子段和
给定由n个整数（包含负整数）组成的序列a1,a2,…,an，求该序列子段和的最大值。 当所有整数均为负值时定义其最大子段和为0。
例如，当(a1,a2, ……a7,a8)=(1,-3, 7,8,-4,12, -10,6)时，最大子段和为：23
bj是1到j位置的最大子段和，由bj的定义易知，当bj-1>0时bj=bj-1+aj，否则bj=aj。 则计算bj的动态规划递归式： bj=max{bj-1+aj，aj}，1≤j≤n。
算法4.7计算最大子段和的动态规划算法

#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; 
}

算法4.8计算最大子段和的动态规划算法的最优解
令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，bestj＝i。

扫描二维码关注公众号，回复： 10802436 查看本文章

#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; 
}

4.5 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时，表示把物品装入背包。
4.5.1 递归关系分析
i≤k≤n的最优值为p(i，j)，是背包容量为j，可选物品为i，i＋1，…，n时0-1背包问题的最优值。
则建立计算p(i，j)的递归式如下：

算法4.9计算0-1背包问题的动态规划算法

#define NUM 50
#define CAP 1500
int w[NUM];  
int v[NUM]; 
int p[NUM][CAP];
void knapsack(int c, int n)  
{
	for( int i=n-1; i>1; i--)　
	{   
		jMax=min(w[i]-1,c);  
		for( int j=0; j<=jMax; j++)   　　
			p[i][j]=p[i+1][j]; 
		for(int j=w[i]; j<=c; j++)   　　
			p[i][j]=max(p[i+1][j], p[i+1][j-w[i]]+v[i]);  　　
	} 
	p[1][c]=p[2][c]; 
	if (c>=w[1])   
		p[1][c]=max(p[1][c], p[2][c-w[1]]+v[1]);  
}

算法4.10 计算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;  
}