算法设计与分析——动态规划

一、动态规划的基本思想

• 动态规划算法通常用于求解具有某种最优性质的问题。
• 在这类问题中，可能会有许多可行解。
  每一个解都对应于一个值，我们希望找到具有最优值的解。
• 基本思想是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
  适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。
• 如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，这样就可以避免大量的重复计算，节省时间。
  我们可以用一个表来记录所有已解的子问题的答案。不管该子问题以后是否被用到，只要它被计算过，就将其结果填入表中。
• 这就是动态规划法的基本思路。
  具体的动态规划算法多种多样，但它们具有相同的填表格式。

二、设计动态规划法的步骤

1. 找出最优解的性质，并刻画其结构特征；
2. 递归地定义最优值（写出动态规划方程）；
3. 以自底向上的方式计算出最优值；
4. 根据计算最优值时得到的信息，构造一个最优解。

三、动态规划问题的特征

动态规划算法的有效性依赖于问题本身所具有的两个重要性质：

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

矩阵连乘积问题






















最长公共子序列

#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; }   //←
　　}
}
……
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 || 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);
}

最大子段和

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

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背包问题

#define NUM 1001
int a[NUM];
#define NUM 50 //物品数量的上限
#define CAP 1500 //背包容量的上限
int w[NUM];  //物品的重量
int v[NUM];  //物品的价值
int p[NUM][CAP]; //用于递归的数组
//形参c是背包的容量W，n是物品的数量
void knapsack(int c, int n) 
{ 
　　//计算递推边界
　　int jMax=min(w[n]-1,c);   //分界点
　　for( int j=0; j<=jMax; j++)   p[n][j]=0; 
　　for( int j=w[n]; j<=c; j++)    p[n][j]=v[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]); 
}
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; 
}