动态规划

动态规划与分治法的区别

动态规划与分治法相似，都是通过组合子问题的解来求解原问题。

分治法将问题划分为互不相交的子问题，递归地求解子问题，再将它们的解组合起来，求出原问题的解。

与之相反，动态规划应用于子问题重叠的情况。这种情况下，分治算法会反复地求解相同的子问题，而动态规划算法会将这些重复子问题的解保存起来（通常使用数组），避免不必要的计算工作。

动态规划算法的步骤

我们通常按如下4个步骤设计一个动态规划算法（最优解跟最优值是不同的概念，下面会举例讲到）：

1.刻画一个最优解的结构特征

2.递归地定义最优值

3.计算最优值，通常采用自底向上的方法

4.利用计算出的信息构造出一个最优解

钢条切割问题

钢条切割问题是这样的：给定一段长度为n英寸的钢条和一张价格表（如下图所示），求切割钢条方案（最优解），使得销售利益（最优值）最大。

长度为n英寸的钢条共有2^n-1种切割方案，因为每一英寸都可以选择切割或不切割。

如果一个最优解将钢条切割成k端(1≤k≤n)  

那么最优切割方案：

得到的最大利益为：

对于r_n(n≥1)，我们可以用更短的钢条的最优切割利益来描述它（r_k(1≤k≤n)代表长度为k英寸的钢条切割之后的最大利益）

为了求解规模为n的原问题，我们先求解形式完全一样，但规模更小的子问题：

在首次切割后，我们将两端钢条看成两个独立的钢条切割问题的实例。

我们通过组合两个相关子问题的最优解，并在所有可能的两段切割方案中选取组合收益最大者，构成原问题的最优解。

我们称钢条切割问题满足最优子结构性质：问题的最优解由相关子问题的最优解组合而成，而这些子问题可以独立求解。

我们可以使用简单递归的方法来求解这个问题：

将长度为n的钢条分解为左面开始一段，以及剩余的一段（继续分解）。于是我们可以得到下面的公式：

下面过程实现了该公式的计算，它采用的是一种直接的自顶而下的递归方法

CUT-ROD(p,n)
if n==0
    return 0
q=-∞
for i=1 to n
    q=max(q,p[i]+CUT-ROD(p,n-i))
return q

过程CUT-ROD以价格数组p[1...n]和整数n位输入，返回长度为n的钢条的最大利益。

CUT-ROD的效率很差，因为CUT-ROD反复地用相同的参数值对自身进行递归调用，即反复求解相同的子问题。

使用动态规划方法求解钢条切割问题：

动态规划对于每个子问题只求解一次，并将结果保存下来。如果随后再次需要此子问题的解，只需查找保存的结果而不必重新计算。

动态规划有两种等价的实现方法，下面以钢条切割问题为例展示这两种方法：

1.带备忘的自顶向下的方法

下面给出的是自顶向下CUT-ROD过程的伪代码，加入了备忘机制：

//初始化
MEMOIZED-CUT-ROD(p,n)
let r[0..n] be a new arrar
for i=0 to n
    r[i]=-∞
return MEMOIZED-CUT-ROD-AUX(p,n,r)

//算法主体
MEMOIZED-CUT-ROD-AUX(p,n,r)
if r[n]≥0
    return r[n]
if n==0
    q=0
else 
    q=-∞
    for i=1 to n
        q=max(q,p[i]+MEMOIZED-CUT-ROD-AUX(p,n-1,r))
r[n]=q
return q

每个子问题的解保存在数组r中，其中每个元素初始化为负无穷来表示未知值。

调用MEMOIZED-CUT-ROD-AUX第一步判断所需值是否已知，如果是，则直接返回保存的值，避免了重复计算子问题。

自顶向下的方法可以这样理解：每次的递归调用会将问题分解为子问题，可以从最终的子问题开始着手，本例可以从MEMOIZED-CUT-ROD-AUX(p,0,r)尝试往上推。

下面是该方法的实现代码

#define N 10
#include <iostream>
#include <algorithm>
using namespace std;

//初始化在main函数中实现 
int memoized_cut_rod(int p[],int n,int r[])
{
    if(r[n]>=0)
        return r[n];
    int q;
    if(n==0)
        q=0;
    else
    {
        q=-1;
        for(int i=1;i<=n;++i)
            q=max(q,p[i]+memoized_cut_rod(p,n-i,r)); 
    }
    r[n]=q;
    return q;
}

int main()
{
    //数组p从1开始，因此把p[0]设置为0 
    int p[]={0,1,5,8,9,10,17,17,20,24,30};
    int r[N+1];
    for(int i=0;i<=N;++i)
        r[i]=-1;
    for(int i=1;i<=N;++i)
        cout<<"n="<<i<<" r="<<memoized_cut_rod(p,i,r)<<endl;
    return 0;
}

2.自底向上法

BOTTOM-UP-CUT-ROD(p,n)
let r[0..n] be a new array
r[0]=0
for j=1 to n
    q=-∞
    for i=1 to j
        q=max(q,p[i]+r[j-i])
    r[j]=q
return r[n]

自底向上版本更为简单，先创建一个数组r来保存子问题的解。对j=1,2,...,n按升序求解每个规模为j的子问题。

自底向上的方法似乎更容易理解：钢条长度从1开始每次递增并记录当前长度的最优值。

下面是该方法的实现代码。为了打印最优值，数组r的初始化放在了main函数中，然后作为参数传进botton_up_cut_rod函数中

#define N 10
#include <iostream>
#include <algorithm>

using namespace std;

int botton_up_cut_rod(int p[],int n)
{
    int r[N+1];
    r[0]=0;
    int q;
    for(int j=1;j<=n;++j)
    {
        q=-1;
        for(int i=1;i<=j;++i)
            q=max(q,p[i]+r[j-i]);
        r[j]=q;
        cout<<"n="<<j<<" r="<<r[j]<<endl;
    }    
    return q;
}

int main()
{
    int p[]={0,1,5,8,9,10,17,17,20,24,30};
    botton_up_cut_rod(p,N);
    return 0;
}

重构解

上面给出了使用动态规划方法求解钢条切割问题的最优值。

修改我们的BOTTON-UP-CUT-ROD方法，让它保存最优解的信息（数组s），根据这些信息来构造最优解。

EXTENDED-BOTTOM-UP-CUT-ROD(p,n)
let r[0..n] and s[0..n] be new arrays
r[0]=0
for j=1 to n
    q=-∞
    for i=1 to j
        if q<p[i]+r[j-i]
            q=p[i]+r[j-i]
            s[j]=i
    r[j]=q
return r and s

跟BOTTON-UP-CUT-ROD有一点不同的是：

在求解规模为j的子问题时将第一段钢条的最优切割长度i保存在s[j]中。EXTENDED-BOTTOM-UP-CUT-ROD(p,10)会返回下面的数组

s[1..n]记录了每条钢条的长度，可以根据数组s构造最优解。

下面是实现代码。为了输出最优值跟最优解，数组r跟数组s的定义都放在main函数中。

#define N 10
#include <iostream>

using namespace std;

int extened_botton_up_cut_rod(int p[],int r[],int s[],int n)
{
    int q;
    for(int j=1;j<=n;++j)
    {
        q=-1;
        for(int i=1;i<=j;++i)
        {
            if(q<p[i]+r[j-i])
            {
                q=p[i]+r[j-i];
                s[j]=i;
            }
        }
        r[j]=q;
    }    
    return q;
}

int main()
{
    int p[]={0,1,5,8,9,10,17,17,20,24,30};
    int r[N+1]={0};
    int s[N+1]={0}; 
    extened_botton_up_cut_rod(p,r,s,N);
    for(int i=1;i<=N;++i)
    {
        cout<<"n="<<i<<" r="<<r[i]<<" ";
        //构造最优解  
        cout<<"solution:";
        int n=i;
        while(n>0)
        {
            cout<<s[n]<<" ";
            n=n-s[n];
        }
        cout<<endl; 
    }
    return 0;
}