动态规划入门

动态规划入门

什么是动态规划，我相信大多数同学都听过关于他的传说，但是都未真正的见识到他的庐山真面目。动态规划一直是算法竞赛中的重中之重，也是非常难的一类问题。无论是小学竞赛还是后面初高中和大学算法竞赛，都会时常见到他的身影。动态规划作为一类非常复杂的算法问题，因此现阶段，我们只需要对动态规划做一个初步的了解即可，随着我们后面的学习和知识的不断积累，还会继续深入的学习动态规划的其他知识点，所以同学们在学习本章节时也不要有太大的负担。好消息是，最近几年，合肥市信息学竞赛都未涉及动态规划类型的题目。坏消息是，在去年的庐阳区区赛的最后一题考察了动态规划的题目。因此大家对于一些简单的动态规划类型的题目还是需要掌握的，小学阶段的动态规划代码都非常简单，因此学习的重点在于，遇到一道题目的时候我们为什么要选择使用动态规划问题？希望同学们带着这个问题学习动态规划章节。本阶段，我们只讲解动态规划中的两个最简单的问题，分别是线性动态规划问题和01背包问题。现在，我们试着从一个例子带大家一步步来认识什么是动态规划吧。

从一个生活问题谈起

先来看看生活中经常遇到的事吧；假设您是个土豪，身上带了足够的1、5、 10、20、50、100元面值的钞票。现在您的目标是凑出某个金额w，需要用到尽量少的钞票。 依据生活经验，我们显然可以采取这样的策略：能用100的就尽量用100的，否则尽量用50的……依次类推。在这种策略下，666=6×100+1×50+1×10+1×5+1×1，共使用了10张钞票。 很显然，这种算法思想大家非常熟悉，这就是“贪心”。但是，这种贪心策略一定是对的吗？ 举另外一个例子，如果我们换一组钞票的面值，贪心策略就也许就不成立了。如果一个奇葩国家的钞票面额分别是1、5、11，那么我们在凑出15的时候，贪心策略会出错： 15=1×11+4×1 （贪心策略使用了5张钞票） 15=3×5 （正确的策略，只用3张钞票） 为什么会这样呢？贪心策略错在了哪里？

鼠目寸光

刚刚已经说过，贪心策略的纲领是：“尽量使接下来面对的w更小”。这样，贪心策略在w=15的局面时，会优先使用11来把w降到4；但是在这个问题中，凑出4的代价是很高的，必须使用4×1。如果使用了5，w会降为10，虽然没有4那么小，但是凑出10只需要两张5元。 在这里我们发现，贪心是一种只考虑眼前情况的策略。 那么，现在我们怎样才能避免鼠目寸光呢？ 如果直接暴力枚举凑出w的方案，明显复杂度过高。太多种方法可以凑出w了，枚举它们的时间是不可承受的。我们现在来尝试找一下性质。 重新分析刚刚的例子。w=15时，我们如果取11，接下来就面对w=4的情况；如果取5，则接下来面对w=10的情况。我们发现这些问题都有相同的形式：“给定w，凑出w所用的最少钞票是多少张？”接下来，我们用f(n)来表示“凑出n所需的最少钞票数量”。 那么，如果我们取了11，最后的代价（用掉的钞票总数）是多少呢？ 明显cost=f(4)+1=4+1=5 ，它的意义是：利用11来凑出15，付出的代价等于f(4)加上自己这一张钞票。现在我们暂时不管f(4)怎么求出来。 依次类推，马上可以知道：如果我们用5来凑出15，cost就是f(10)+1=2+1=3 。 那么，现在w=15的时候，我们该取那种钞票呢？当然是各种方案中，cost值最低的那一个！取11：cost=f(4)+1=4+1=5取5： cost=f(10)+1=2+1=3取1： cost=f(14)+1=4+1=5 显而易见，cost值最低的是取5的方案。我们通过上面三个式子，做出了正确的决策！这给了我们一个至关重要的启示—— f(n)只与f(n-1),f(n-5),f(n-11) 相关；更确切地说：f(n)=min{f(n-1),f(n-5),f(n-11)}+1; 这个式子是非常激动人心的。我们要求出f(n)，只需要求出几个更小的f值；既然如此，我们从小到大把所有的f(i)求出来不就好了？注意一下边界情况即可。代码如下：

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int f[105],i,n,cost;
    cin>>n;
    f[0]=0;
    for(i=1;i<=n;i++)
    {   
        cost=INT_MAX;
        if(i-1>=0)  cost=min(cost,f[i-1]+1);  
        if(i-5>=0)  cost=min(cost,f[i-5]+1);
        if(i-11>=0) cost=min(cost,f[i-11]+1);
        f[i]=cost;
        cout<<"f["<<i<<"]"<<"="<<f[i]<<endl; 
    }
    cout<<f[n]; 
}

我们以O(n)的复杂度解决了这个问题。现在回过头来，我们看看它的原理：f(n)只与f(n-1),f(n-5),f(n-11) 的值相关。我们只关心f(w)的值，不关心是怎么凑出w的。 这两个事实，保证了我们做法的正确性。它比起贪心策略，会分别算出取1、5、11的代价，从而做出一个正确决策，这样就避免掉了“鼠目寸光”！ 它与暴力的区别在哪里？我们的暴力枚举了“使用的硬币”，然而这属于冗余信息。我们要的是答案，根本不关心这个答案是怎么凑出来的。譬如，要求出f(15)，只需要知道f(14),f(10),f(4)的值。其他信息并不需要。我们舍弃了冗余信息。我们只记录了对解决问题有帮助的信息——f(n). 我们能这样干，取决于问题的性质：求出f(n)，只需要知道几个更小的f©。我们将求解f©称作求解f(n)的“子问题”。 这就是DP（动态规划，dynamic programming）. 将一个问题拆成几个子问题，分别求解这些子问题，即可推断出大问题的解。思考题：请稍微修改代码，输出我们凑出w的方案。

几个简单的概念

【无后效性】
　　一旦f(n)确定，“我们如何凑出f(n)”就再也用不着了。

要求出f(15)，只需要知道f(14),f(10),f(4)的值，而f(14),f(10),f(4)是如何算出来的，对之后的问题没有影响。

“未来与过去无关”，这就是无后效性。

（严格定义：如果给定某一阶段的状态，则在这一阶段以后过程的发展不受这阶段以前各段状态的影响。）

【最优子结构】
　　回顾我们对f(n)的定义：我们记“凑出n所需的最少钞票数量”为f(n).

f(n)的定义就已经蕴含了“最优”。利用w=14,10,4的最优解，我们即可算出w=15的最优解。

大问题的最优解可以由小问题的最优解推出，这个性质叫做“最优子结构性质”。

引入这两个概念之后，我们如何判断一个问题能否使用DP解决呢？

能将大问题拆成几个小问题，且满足无后效性、最优子结构性质。

【DP的核心思想】
　　DP为什么会快？
　　无论是DP还是暴力，我们的算法都是在可能解空间内，寻找最优解。

来看钞票问题。暴力做法是枚举所有的可能解，这是最大的可能解空间。
　　DP是枚举有希望成为答案的解。这个空间比暴力的小得多。

也就是说：DP自带剪枝。

DP舍弃了一大堆不可能成为最优解的答案。譬如：
　　15 = 5+5+5 被考虑了。
　　15 = 5+5+1+1+1+1+1 从来没有考虑过，因为这不可能成为最优解。

从而我们可以得到DP的核心思想：尽量缩小可能解空间。

在暴力算法中，可能解空间往往是指数级的大小；如果我们采用DP，那么有可能把解空间的大小降到多项式级。

一般来说，解空间越小，寻找解就越快。这样就完成了优化。

【DP的操作过程】
　　一言以蔽之：大事化小，小事化了。

将一个大问题转化成几个小问题；求解小问题；推出大问题的解。

【DP三连】
　　设计DP算法，往往可以遵循DP三连：

我是谁？ ——设计状态，表示局面
　　我从哪里来？
　　我要到哪里去？ ——设计转移

设计状态是DP的基础。接下来的设计转移，有两种方式：一种是考虑我从哪里来；另一种是考虑我到哪里去，这常见于求出f(x)之后，更新能从x走到的一些解。这种DP也是不少的，我们以后会遇到。

最后，我们一起念一遍DP三连吧——我是谁？我从哪里来？我要到哪里去？

01背包问题

假设你是一名经验丰富的探险家，背着背包来到野外进行日常探险。天气晴朗而不燥热，山间的风夹杂着花香，正当你欣赏这世外桃源般的美景时，突然，你发现了一个洞穴，这个洞穴外表看起来其貌不扬，但凭借着惊为天人的直觉，这个洞穴不简单。
于是，你开始往洞穴内探索，希望能发现一些有意思的东西。终于，皇天不负有心人，你在洞穴的尽头，发现了一堆珠宝，凭借你惊人的阅历，一眼便看出了它们各自的价值，心想着下下下下下下下下半辈子都有着落了。
然而，天有不测风云，正准备将它们收入囊中，却不小心触碰到一个防御机关，洞穴马上就要崩塌了。在此危机时刻，你只有一个背包，你必须尽快做出抉择，从中选择最值钱的珠宝塞到你的背包，让背包中珠宝的总价值最大。
好了好了，啰里啰嗦了大半天，我还是来精简一下问题吧。简而言之，你只有一个容量有限的背包，总容量为c，有n个可待选择的物品，每个物品只有一件，它们都有各自的重量和价值，你需要从中选择合适的组合来使得你背包中的物品总价值最大。
问题分析：
那还不简单，不管是什么，先往背包里塞，塞满赶紧走，狗命要紧，狗命要紧。。。
好了好了，开个玩笑，言归正传。
简单起见，我们来将上面的问题具体化，举一个更具体的栗子：
假设有4个物品，它们的价值(v)和重量(w)如下图：

背包总容量为10，现在要从中选择物品装入背包中，要求物品的重量不能超过背包的容量，并且最后放在背包中物品的总价值最大。
emmm，等等，为什么叫做0/1背包呢？为什么不叫1/2背包，2/3背包？？？
仔细想想，这里每个物品只有一个，对于每个物品而言，只有两种选择，盘它或者不盘，盘它记为1，不盘记为0，我们不能将物品进行分割，比如只拿半个是不允许的。这就是这个问题被称为0/1背包问题的原因。
所以究竟选还是不选，这是个问题。
让我们先来体验一下将珠宝装入背包的感觉，为了方便起见，用xi代表第i个珠宝的选择（xi = 1 代表选择该珠宝，0则代表不选），vi代表第i个珠宝的价值，wi代表第i个珠宝的重量。于是我们就有了这样的限制条件：

我们的初始状态是背包容量为10，背包内物品总价值为0，接下来，我们就要开始做选择了。对于1号珠宝，当前容量为10，容纳它的重量2绰绰有余，因此有两种选择，选它或者不选。我们选择一个珠宝的时候，背包的容量会减少，但是里面的物品总价值会增加。就像下面这样：

这样就分出了两种情况，我们继续进行选择，如果我们选择了珠宝1，那么对于珠宝2，当前剩余容量为8，大于珠宝2的容量3，因此也有两种选择，选或者不选。

现在，我们得到了四个可能结果，我们每做出一个选择，就会将上面的每一种可能分裂成两种可能，后续的选择也是如此，最终，我们会得到如下的一张决策图：

这里被涂上色的方框代表我们的最终待选结果，本来应该有16个待选结果，但有三个结果由于容量不足以容纳下最后一个珠宝，所以就没有继续进行裂变。
然后，我们从这些结果中，找出价值最大的那个，也就是13，这就是我们的最优选择，根据这个选择，依次找到它的所有路径，便可以知道该选哪几个珠宝，最终结果是：珠宝4，珠宝2，珠宝1。
简单的看，对于每个物品，无外乎两种可能：选，或者不选。
不选的话，背包的容量不变，最大价值还是之前的价值；
选的话，背包的容量变小，价值变大。
最优方案就是比较这两种方案，哪个会更好些：

01背包问题

[算法分析]
定义状态∶d(i,j)表示为前i个物品分配j容量的背包,可以获得的最大价值。

对于物品i有2种选择∶

选择1∶ 不选择将i放入背包∶ d(i, j) = d(i-1,j)。

选择2∶选择将i放入背包d(i,j)=d(i-1,j-w_iwi)+ v_ivi(j>=w_iwi)。

状态转移方程∶ d(i,j)= max(d(i-1,j), d(i-1,j-w_iwi)+ v_ivi)。
完整代码如下：

#include<bits/stdc++.h>
using namespace std;
int w[1001],v[1001],dp[1001][1001];
int main()
{
    int n,m;
    cin>>m>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>w[i]>>v[i];  //输入重量跟价值，有些题目是相反的
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(j<w[i])    //如果要选的物品重量超过了剩余的容量
            {
                dp[i][j]=dp[i-1][j];  //最大价值还是之前一次的价值
            }
            else     //如果要选的物品重量小于剩余的容量
            {
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);  //比较一下选与不选该物品谁的价值更大。不选则为之前的价值是dp[i-1][j]，选择的话这个时候的价值就是dp[i-1][j-w[i]]+v[i]，即在之前的基础上容量少了w[i]，但是价值大了v[i];
            }
        }
    }
    cout<<dp[n][m];
}

背包

有个背包可承受重量N,现有T件物品,每件物品重量为w_iwi,价值为v_ivi ,每件物品只有一个,这个背包可以装载物品的最大价值是多少?
输入格式
第一行,两个整数,分别表示N和T,用空格隔开(N≤1000,T≤100)
接下来T行,每行两个整数,分别表示T件物品的重量w_iwi和价值v_ivi(1≤w_iwi,v_ivi≤100)
输出格式
一行,表示这个背包可以装载物品的最大价值
输入输出样列

输入样例1：
100 5
77 92
22 22
29 87
50 46
99 90

输出样例1：
133

[算法分析]
定义状态∶d(i,j)表示为前i个物品分配j容量的背包,可以获得的最大价值。

对于物品i有2种选择∶

选择1∶ 不选择将i放入背包∶ d(i, j) = d(i-1,j)。

选择2∶选择将i放入背包d(i,j)=d(i-1,j-w_iwi)+ v_ivi(j>=w_iwi)。

状态转移方程∶ d(i,j)= max(d(i-1,j), d(i-1,j-w_iwi)+ v_ivi)。
完整代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=1005,T=105;
int dp[T][N],v[T],w[T];
int main()
{
    int n,t;
    cin>>n>>t;
    for(int i=1;i<=t;i++)
    {
        cin>>w[i]>>v[i];
    }
    for(int i=1;i<=t;i++)  //t件物品
    {
        for(int j=1;j<=n;j++)  //背包大小为n
        {
            if(j>=w[i])
                dp[i][j]=max(dp[i-1][j],v[i]+dp[i-1][j-w[i]]);
            else
                dp[i][j]=dp[i-1][j];
        }
    }
    cout<<dp[t][n];
    return 0;
} 

开心的金明 [happy]

说明
NOIP2006年普及组第二题
[算法分析]
金明拥有的钱是背包大小,物品的价格是其占用的背包容量,物品的价格*重要度是其带来的价值,题目要求价值最大。

定义状态∶ d(i,j)表示为前i个物品分配i容量的背包,可以获得的最大价值。

对于物品i有2种选择∶

选择1∶ 不选择将i放入背包∶ d(i,j)= d(i-1, j)。

选择2∶选择将i放入背包d(i,j)=d(i-1,j- w_iwi)＋ v_ivi (j>=w_iwi)。
状态转移方程∶ d(i, j)= max(d(i-1,j), d(i-1,j-w_iwi)+ v_ivi)。

注意∶物品价值是他的价格和重要度的乘积!

完整的代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=30,M=30005;
int n,m,w[N],v[N],d[N][M];
int main()
{ 
    //n件物品,承重量为c 
    cin>>m>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>w[i]>>v[i];
        v[i]=v[i]*w[i]; //重要度乘以价格 
    }
    for(int i=1;i<=n;i++)  
    {
        for(int j=1;j<=m;j++)  
        {
            if(j>=w[i])
                d[i][j]=max(d[i-1][j],d[i-1][j-w[i]]+v[i]);
            else
                d[i][j]=d[i-1][j];
        }
    }
    cout<<d[n][m];
    return 0;
}