一、动态规划的基本思想
- 动态规划算法通常用于求解具有某种最优性质的问题。
- 在这类问题中,可能会有许多可行解。
每一个解都对应于一个值,我们希望找到具有最优值的解。 - 基本思想是将待求解问题分解成若干个子问题,先求解子问题,然后从这些子问题的解得到原问题的解。
适合于用动态规划求解的问题,经分解得到子问题往往不是互相独立的。若用分治法来解这类问题,则分解得到的子问题数目太多,有些子问题被重复计算了很多次。 - 如果我们能够保存已解决的子问题的答案,而在需要时再找出已求得的答案,这样就可以避免大量的重复计算,节省时间。
我们可以用一个表来记录所有已解的子问题的答案。不管该子问题以后是否被用到,只要它被计算过,就将其结果填入表中。 - 这就是动态规划法的基本思路。
具体的动态规划算法多种多样,但它们具有相同的填表格式。
二、设计动态规划法的步骤
- 找出最优解的性质,并刻画其结构特征;
- 递归地定义最优值(写出动态规划方程);
- 以自底向上的方式计算出最优值;
- 根据计算最优值时得到的信息,构造一个最优解。
三、动态规划问题的特征
动态规划算法的有效性依赖于问题本身所具有的两个重要性质:
- 最优子结构:
当问题的最优解包含了其子问题的最优解时,称该问题具有最优子结构性质。 - 重叠子问题:
在用递归算法自顶向下解问题时,每次产生的子问题并不总是新问题,有些子问题被反复计算多次。动态规划算法正是利用了这种子问题的重叠性质,对每一个子问题只解一次,而后将其解保存在一个表格中,在以后尽可能多地利用这些子问题的解。
矩阵连乘积问题
最长公共子序列
#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;
}