动态规划钢条切割问题

Posted CodeLab

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了动态规划钢条切割问题相关的知识,希望对你有一定的参考价值。

0- 动态规划问题的一般步骤

1- 刻画一个最优解的结构特征
2- 递归定义最优解的值
3- 计算最优解的值,通常采用自底向上的方法
4- 利用计算出的信息构造一个最优解

1-动态规划问题的一般步骤

Serling 公司购买长钢条,将其切割为锻钢条出售。切割工序本身没有成本支出。公司管理层希望知道最佳的切割方案。
假定我们知道Serling公司出售一段长度为i英寸的钢条的价格为pi(i = 1, 2,…,单位为美元)。钢条的长度均为整英寸。下表给出了一个价格表的样例。

【动态规划】钢条切割问题

2-  问题分析

钢条切割问题是这样的:给定一段长度为n英寸的钢条和一个价格表p(i)(i = 1, 2,…,n),求切割钢条方案,使得销售收益r(n)最大。注意如果长度为n英寸的钢条价格p(n)足够大,最优解可能是完全不需要切割。


考虑n=4的情况。下图给出了4英寸钢条的所有可能切割方案,包括根本不切割的方案。从下图可以看出,将一段长度为4英寸的钢条切割为两段各长为2英寸的钢条,将产生p(2)+p(2)=5+5=10的收益,为最优解。

【动态规划】钢条切割问题

图1 钢条切割方案

对于最优收益rn (n≥1)可以用更短的钢条的最优收益来描述:

rn = max(pn,r1+rn-1,r2+rn-2,...,rn-1+r1)

第一个参数p对应不切割,直接出售长度为n英寸的钢条的方案。其中n-1个参数对应另外n-1种方案:对每个i = 1, 2, …, n-1,首先将钢条切割为i和n-i的两段,接着求解这两段的最优切割收益ri  和rn-i (每种方案的最优收益为两段的最优收益之和)。由于无法预知那种方案的将获得最佳收益,所以必须考虑所有可能的i,选取其中的收益最大者。如果直接出售圆钢条会获得最大收益,当然可以不做任何切割。


可以看出,通过组合两个子问题(完成首次切割之后,即将问题转化为求解两个独立的钢条切割问题实例)的最优解,并在所有可能得两段切割方案中选取组合收益最大者,构成原问题的最优解。


钢条问题是满足最优子结构的(optimal substructure) 性质的:问题的最优解由相关子问题的最优解组合而成,而且这些子问题可以独立求解。

3-  自顶向下递归实现

简单的递归求解方法: 将钢条从左边切割下长度为i的一段,只对右边剩余的长度为n-i的一段继续进行切割(递归求解),对左边的一段则不再进行切割。问题的分解方式为:将长度为n的钢条分解为左边的开始一段,以及剩余部分继续分解的结果。这样,不做任何切割的方案可以描述为:第一段的长度为你n,收益为pn ,剩余部分的长度为0,对应的收益ro=0 。 于是可以得到如下公式:

rn = max(pi +rn-i) (1≤i≤n)

原问题的最优解只包含一个相关子问题(右边剩余部分)的解。下面给出朴素递归算法的解:

#include <iostream>
#include <vector>
#include <limits.h>
#include <algorithm>

using namespace std;

vector<int> price{1589101717202430};//钢条对应的价格

int CutRod(vector<int> &price, int length){
    if(length == 0return 0;//如果钢条长度为0,直接返回
    int maxvalue = INT_MIN;//因为钢条价格为正值,所以首先默认maxvalue为最小值
    for(int i = 1; i <= length; ++i){
    //取前一次迭代算得的maxvalue与本次迭代结果的最大值
    //迭代:当前钢条段的价值 + 剩余右边钢条的价值
    //(这里因为下标从0开始,所以有-1)
        maxvalue = max(maxvalue, price[i - 1] + CutRod(price, length - i));
    }
    return maxvalue;
}
int main() {
    int length = 0;
    cin >> length;
    cout << "maxvalue: " << CutRod(price,length)<<endl;
    return 0;
}

以上利用纯递归调用的方法效率很差,运行时间会呈爆炸性增长。可以取n = 4绘制递归调用树进行观察:

【动态规划】钢条切割问题


图2  n = 4的递归调用树
这棵递归调用树共有2 n 个结点, 其中有2 n-1  个叶结点。

4-  使用动态规划方法求解

动态规划有两种等价的实现方法:

1- 带备忘录的自顶向下法(top-down with memoization) :此方法仍然按照自然的递归形式编写,但过程会保存每个子问题的解。当需要一个子问题的解时,过程首先检查是否已经保存过此解。如果是,则直接返回保存的值,从而节省了计算时间;否则,按通常方式计算这个子问题。


2-自底向上法(bottom-up method):这种问题一般需要恰当定义子问题的“规模”的概念,使得任何子问题的求解都只依赖于“更小的”子问题的求解。因而我们可以将子问题按规模排序,按由小到大的顺序进行求解。当求解某个子问题时,它依赖的那些更小的子问题都已求解完毕,结果已经保存。每个子问题只需求解一次,当我们求解该问题时(第一次遇到),其所有的子问题均已求解完毕。

  • 带备忘录的自顶向下法,备忘机制

#include <iostream>
#include <vector>
#include <limits.h>
#include <algorithm>

using namespace std;

vector<int> price{1589101717202430};//钢条对应的价格

int MemoCutRodAux(vector<int> &price,vector<int> &memoprice,int cutlength){
    int  maxvalue = INT_MIN;
    if(memoprice[cutlength] >= 0){
        return memoprice[cutlength];//入口进行检查,看所需值是否已知,如果是,则直接返回保存的值
    }     
    if(cutlength == 0) { maxvalue = 0; }
    else{
        for(int j = 1; j <= cutlength; ++j){
            maxvalue = max(maxvalue, price[j - 1] + MemoCutRodAux(price, memoprice, cutlength - j));
        }
    }
    memoprice[cutlength] = maxvalue;
    return memoprice[cutlength];
}

int MemoCutRod(vector<int> &price,int length){
    vector<int> memoprice{};
    for(int i = 0; i <= length; ++i){//特别注意的是,备忘录是包含长度为0的情况的,所以范围是[0,length]
        memoprice.push_back(INT_MIN);//已知收益非负,所以可以这样处理“未知值”
    }
    return  MemoCutRodAux(price,memoprice,length);
}

int main() {
    int length = 0;
    cin >> length;
    cout << "MemoCutRod maxvalue: " << MemoCutRod(price,length)<<endl;
    return 0;
}
  • 自底向上方法:采用子问题的自然顺序,若i < j,则规模为i的子问题比规模为j的子问题“更小”,因此过程依次求解规模为j= 0, 1, …, n的子问题

#include <iostream>
#include <vector>
#include <limits.h>
#include <algorithm>

using namespace std;

vector<int> price{1589101717202430};//钢条对应的价格

int BottomUpCutRod(vector<int> &price, int length){
    vector<int> value(length + 1);
    value[0] = 0;//长度为0即没有收益

    for(int j = 1; j <= length; ++j){
        int maxvalue = INT_MIN;
        for(int i = 1; i <= j; ++i){
            maxvalue = max(maxvalue,price[i - 1] + value[j - i]);//直接访问存好的解,来获得j-i这一子问题的解,省去了递归调用
        }
        value[j] = maxvalue;//规模为j的子问题的解直接存入
    }
    return value[length];

}

int main() {
    int length = 0;
    cin >> length;
    cout << "BottomUpCutRod maxvalue: " << BottomUpCutRod(price,length)<<endl
    return 0;
}

5-  重构解

上面的解决方法中知识返回了切割问题的最优解的收益值,但并没有返回解本身(一个长度列表,给出切割后每段钢条的长度)。下面对算法进行扩展,以输出最优解的切割方案:

#include <iostream>
#include <vector>
#include <limits.h>
#include <algorithm>

using namespace std;

vector<int> price{1589101717202430};//钢条对应的价格

typedef struct {//结构体进行数据保存
    vector<int> value{};
    vector<int> cutlen{};
}stResult;

stResult ExtendedBottomUpCutRod(vector<int> &price, int length){
    stResult stresult;
    vector<int> valuetmp(length + 1);
    vector<int> cutlentmp(length + 1);
    stresult.value = valuetmp;
    stresult.cutlen = cutlentmp;
    stresult.value[0] = 0;

    for(int j = 1; j <= length; ++j){
        int maxvalue = INT_MIN;
        for (int i = 1; i <= j; ++i){
            if( maxvalue < price[ i -1] + stresult.value[j - i]){
                maxvalue = price[ i -1] + stresult.value[j - i];
                stresult.cutlen[j] = i;//保存最优切割方案
            }
        }
        stresult.value[j] = maxvalue;
    }
    return stresult;
}

int main() {
    int length = 0;
    cin >> length;
    stResult stresult = ExtendedBottomUpCutRod(price,length);

    while(length > 0){
        cout<<stresult.cutlen[length]<<" ";//输出最佳切割方案
        length = length - stresult.cutlen[length];
    }
    return 0;
}

对上面的解决方案:

ExtendedBottomUpCutRod(price,10)会返回如下的表格:

更多精彩内容,请长按二维码


以上是关于动态规划钢条切割问题的主要内容,如果未能解决你的问题,请参考以下文章

动态规划算法 ——钢条切割问题

算法导论动态规划 15.1-3 钢条切割问题

动态规划实现钢条切割问题

动态规划学习笔记--对于钢条切割方案的思考

动态规划钢条切割

动态规划 - 钢条切割