[算法与数据结构] - No.12 动态规划之01背包以及01背包一维数组优化

背包问题是我们使用动态规划的一个最常见的场景。所谓动态规划，就是基于一个递推公式及一个或多个初始状态，我们要找到某个状态的最优解，然后在它的帮助下，找到下一个状态的最优解。 

当前子问题的解将由上一次子问题的解推出。使用动态规划来解题只需要多项式时间复杂度， 因此它比回溯法、暴力法等要快许多。

那么什么是背包问题呢？我们以最简单的01背包来描述以下场景：.

有 N 件物品和一个容量为 V 的背包。放入第 i 件物品耗费的费用是 Ci，得到的价值是 Wi。求解将哪些物品装入背包可使价值总和最大？注意，这一的每个物体都只有一个，所以对于每个物体都只有装不装两个选择，所以称为01背包

解决思路：

我们用F [i， v] 表示前 i 件物品恰放入一个容量为 v 的背包可以获得的最大价值。我们这个问题可以化为至于两部分量有关：第i个物体和前i-1个物体

我们假设前i-1个物体放入v容量背包中的最大价值已经得到。那么我们只需要考虑第i个物体放与不放的问题即可。

如果i个物体不放入背包，那么问题就变成了前i-1的物体放入容量为v的背包求最大价值的问题

如果i个物体放入背包，那么问题就变成了求前i-1个物体放入容量v-ci的背包的问题，即

F [i，v] = max { F [i − 1，v]，F [i − 1;，v − Ci] + Wi }

代码（NOIP2005普及组第3题 采药）：

 

#include <iostream>
using namespace std;

int main()
{
    int dp[102][1002];
    int v[120];
    int w[120];
    int T,M;
    while(cin >>T>>M&&T>0&&M>0)
    {
        for(int i = 1; i<=M; i++)
        {
            cin>>v[i]>>w[i];
        }
        for(int j = 0; j<=T; j++)
        {
            dp[0][j] = 0;
        }
        for(int j = 0 ; j<=M; j++)
        {
            dp[j][0] = 0;
        }
        for(int i = 1; i <= M; i++)
        {

            for(int j = 1 ; j<=T; j++)
            {
                if(j>=v[i]&&dp[i-1][j]<dp[i-1][j-v[i]]+w[i])
                {
                    dp[i][j] = dp[i-1][j-v[i]]+w[i];
                }
                else
                {
                    dp[i][j] = dp[i-1][j];
                }
            }
        }
        cout<<dp[M][T]<<endl;
    }
    return 0;
}

 

 

 

 

 

这道题可以直接作为模板使用，解题思路：

1.首先，定义边界条件：V(0,j)=V(i,0)=0

分别表示当我们一个物体都不考虑的时候，最大收益为0；当背包容量为0时。最大收益为0

2. 考虑物体i

当物体重量小于背包容量，并且放进去以后背包收益增大，则放进物体；dp[i][j] = dp[i-1][j-v[i]]+w[i]

3.否则不放进物体 dp[i][j] = dp[i-1][j]

01背包空间优化：

01背包问题，的时间复杂度和空间复杂度均为o(NV),时间复杂度无法再减小，但是空间复杂度可以再次减少，我们使用一维数组来优化算法

我们使用F[v]来代替上面的F[i,v];我们知道F [i; v] 是由 F [i − 1，v] 和F [i − 1， v − Ci] 两个子问题递推而来的，那么我们如何保证在推 F [i，v] 时（也即在第 i 次主循环中
推 F [v] 时）能够取用 F [i − 1， v] 和 F [i − 1，v − Ci] 的值呢？我们先给出答案;

F [v] = max{F [v], F [v − Ci] + Wi}

但是要注意一个问题，我们需要对v进行逆序的遍历为什么要逆序遍历呢？就是为了保证，我们的F [v] 是由之前的F [i − 1，v − Ci]递推而来而不是F [i ，v − Ci]递推而来

这里是不是很绕？

依据我们的算法：

F [0...V ] = 0
for i = 1 to N
for v = V to Ci
F [v] = max { F [v]，F [v − Ci] + Wi }

我们来看一个例子：

我们假设有一个背包，最大容量为10，我们有以下三本书，书包最多能装多贵的书？

 

序号	重量	价钱
1	4	5
2	7	9
3	5	6

我们首先使用算法中的逆序来执行算法：

按照逆序，执行之后的表如上所示，显示最大为11

如果我们按照顺序来：

 

如图所示，我们显示了便利的过程，例如F[4]由F[0]得到，F[5]由F[1]得到.....

但是注意看F[8],我们知道F[v]表示容量为v时候的最大价钱。当i = 1时候，w[1] = 5,但是F[8]却是10，也就是说，装进了两个。这是怎么回事呢？

当我们从前往后遍历的时候，先确定的是v比较小的F[v]，这样的话，如果我们后边的某些v较大的F[v]使用了 F[v - ci]的值，这样F[v]就会出错。原因就是，此时F [v] 不是由之前的F [i − 1，v − Ci]递推而来，而是F [i ，v − Ci]递推而来。

想想我们在已经确定课F[4] = 5的时候，是不是相当于已经把i = 1 的物品放入背包了，但是当我们使用F[4] 来确定F[8]的时候，此时 i = 1 是已经放入背包的，与我们所预想的算法是不一样的，此时的F[1,8] 不是由f[0,8-4]推导而来，而是F[1,4]推导而来

完整算法如下所示（NOIP2005普及组第3题 采药）：

 

#include <iostream>
using namespace std;


int main()
{
    int dp[1002];
    int v[120];
    int w[120];
    int T,M;
    while(cin >>T>>M&&T>0&&M>0)
    {
        for(int i = 1; i<=M; i++)
        {
            cin>>v[i]>>w[i];
        }
        for(int j = 0; j<=T; j++)
        {
            dp[j] = 0;
        }
        for(int i = 1; i <= M; i++)
        {

            for(int j = T; j>=0; j--)
            {
                if(j>=v[i]&&dp[j]<dp[j-v[i]]+w[i])
                {
                    dp[j] = dp[j-v[i]]+w[i];
                }
            }
        }
        cout<<dp[T]<<endl;
    }
    return 0;
}

P.S.文章不妥之处还望指正