采药 - 九度教程第 101 题

采药 - 九度教程第 101 题

题目

时间限制：1 秒 内存限制：32 兆 特殊判题：否
题目描述：
辰辰是个很有潜能、天资聪颖的孩子，他的梦想是称为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”如果你是辰辰，你能完成这个任务吗？
输入：
输入的第一行有两个整数 T（1 <= T <= 1000）和 M（1 <= M <= 100），T 代表总共能够用来采药的时间，M 代表山洞里的草药的数目。接下来的 M 行每行包括两个在 1 到 100 之间（包括 1 和 100）的的整数，分别表示采摘某株草药的时间和这株草药的价值。
输出：
可能有多组测试数据，对于每组数据，输出只包括一行，这一行只包含一个整数，表示在规定的时间内，可以采到的草药的最大总价值。
样例输入：
70 3
71 100
69 1
1 2
样例输出：
3
来源：
2008 年北京大学图形实验室计算机研究生机试真题

首先将这个问题抽象：有一个容量为 V 的背包，和一些物品。这些物品分别有两个属性，体积 w 和价值 v，每种物品只有一个。要求用这个背包装下价值尽可能多的物品，求该最大价值，背包可以不被装满。

因为最优解中，每个物品都有两种可能的情况，即在背包中或者不存在（背包中有 0 个该物品或者 1 个），所以把这个问题称为 0-1 背包问题。在该题中，背包的容积和物品的体积等效为总共可用的时间和采摘每个草药所需的时间。

在众多方案中求解最优解，是典型的动态规划问题。为了用动态规划来解决该问题，用 dp[i][j]表示在总体积不超过 j 的情况下，前 i 个物品所能达到的最大价值。初始时，dp[0][j](0<=j<=V)为 0。依据每种物品是否被放入背包，每个状态有两个状态转移的来源。

若物品 i 被放入背包，设其体积为 w，价值为 v，则 dp[i][j] = dp[i - 1][j - w] + v。即在总体积不超过 j-w 时前 i-1 件物品可组成的最大价值的基础上再加上i 物品的价值v；若物品不加入背包，则dp[i][j] = dp[i-1][j]，即此时与总体积不超过 j 的前 i-1 件物品组成的价值最大值等价。选择它们之中较大的值成为状态 dp[i][j]的值。综上所述，0-1 背包的状态转移方程为：

转移时要注意，j-w 的值是否为非负值，若为负则该转移来源不能被转移。

#include <stdio.h>
#define INF 0x7fffffff

int max(int a,int b){
    return a>b ? a : b;
}

struct E{//保存物品信息的结构体
int w;//物品的体积
int v;//物品的价值
}list[101];

int dp[101][1001];
//记录状态数组，dp[i][j]表示前i个物品
//组成的总体积不大于j的最大价值和

int main()
{
    int s,n;
    while(scanf("%d%d",&s,&n)!=EOF){
        for(int i=1;i<=n;i++){
            scanf("%d%d",&list[i].w,&list[i].v);
        }

        for(int i=0;i<=s;i++){
            dp[0][i]=0;
        }//初始化状态

        for(int i=1;i<=n;i++){
            //循环每一个物品
            for(int j=s;j>=list[i].w;j--){
                //对s到list[i].w的每个j，
                //状态转移来源为dp[i-1][j]
                //或dp[i-1][j-list[i].w]+list[i].v
                //选择其中较大的值
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-list[i].w]+list[i].v);

            }
            for(int j=list[i].w-1;j>=0;j--){
                //对list[i].w-1到0的每个j，状态仅能来源于dp[i-1][j]
                //所以直接赋值
                dp[i][j]=dp[i-1][j];
            }
        }
        printf("%d\n",dp[n][s]);//输出答案
    }
    return 0;
}

观察状态转移的特点，发现 dp[i][j]的转移仅与 dp[i-1][j-list[i].w]和dp[i-1][j]有关，即仅与二维数组中本行的上一行有关。根据这个特点，可以将原本的二维数组优化为一维，并用如下方式完成状态转移：

其中在本次更新中未经修改的 dp[j-list[i].w]与 dp[j]与原始写法中的dp[i-1][j-list[i].w]与 dp[i-1][j]等值。为了保证状态正确的转移，必须保证在每次更新中确定状态 dp[j]时，dp[j]和 dp[j-list[i].w]尚未被本次更新修改。考虑到j - list[i].w < j，那么在每次更新中倒序遍历所有 j 的值，就能保证在确定 dp[j]的值时，dp[j - list[i].w]的值尚未被修改，从而完成正确的状态转移。

#include <stdio.h>
#define INF 0x7fffffff

int max(int a,int b){
    return a>b ? a : b;
}

struct E{
int w;
int v;
}list[101];

int dp[1001];

int main()
{
    int s,n;
    while(scanf("%d%d",&s,&n)!=EOF){
        for(int i=1;i<=n;i++){
            scanf("%d%d",&list[i].w,&list[i].v);
        }

        for(int i=0;i<=s;i++){
            dp[i]=0;
        }

        for(int i=1;i<=n;i++){
            for(int j=s;j>=list[i].w;j--){
                //必须倒序跟新每个dp[j]的值，
                //j小于list[i].w的各dp[j]不作更新，保持原值
                //即等价于dp[i][j]=dp[i-1][j]
                dp[j]=max(dp[j],dp[j-list[i].w]+list[i].v);
                //dp[j]在原值和dp[j-list[i].w]+list[i].v中选择较大的那个
            }
        }
        printf("%d\n",dp[s]);
    }
    return 0;
}

分析求解 0-1 背包问题的算法复杂度，其状态数量为 ns，其中 n 为物品数量，s 为背包的总容积，状态转移复杂度为 O(1)，所以综合时间复杂度为 O(ns)。经优化过后的空间复杂度仅为 O(s)（不包括保存物品信息所用的空间）。

0-1 背包问题是最基本的背包问题，其它各类背包问题都是在其基础上演变而来。牢记 0-1 背包的特点：每一件物品至多只能选择一件，即在背包中该物品数量只有 0 和 1 两种情况。

0-1 背包存在一个简单的变化，即要求所选择的物品必须恰好装满背包。此时，设计新的状态 dp[i][j]为前 i 件物品恰好体积总和为 j 时的最大价值，其状态转移与前文中所讲的 0-1 背包完全一致，而初始状态发生变化。其初始状态变为，dp[0][0]为 0，而其它 dp[0][j]（前 0 件物品体积总量为 j）值均变为负无穷或不存在，经过状态转移后，得出 dp[n][s]即为答案。综上所述，该变化与原始0-1 背包的差别仅体现在初始值方面，其它各步骤均保持不变。

接着扩展 0-1 背包问题，使每种物品的数量无限增加，便得到完全背包问题：有一个容积为 V 的背包，同时有 n 种物品，每种物品均有各自的体积 w和价值 v，每个物品的数量均为无限个，求使用该背包最多能装的物品价值总和。

先按照 0-1 背包的思路试着求解该问题。设当前物品的体积为 w，价值为 v，考虑到背包中最多存放 V/w 件该物品，可以将该物品拆成 V/w 件，即将当前可选数量为无限的物品等价为 V/w 件体积为 w、价值为 v 的不同物品。

对所有的物品均做此拆分，最后对拆分后的所有物品做 0-1 背包即可得到答案。但是，这样的拆分将使物品数量大大增加，其时间复杂度为：

可见，当 S 较大同时每个物品的体积较小时其复杂度会显著增大，固将该问题转化为 0-1 背包的做法较不可靠。但是由该解法可窥见 0-1 背包的重要性，很多背包问题均可以推到 0-1 背包上来。

这里提出一种时间复杂度为 O(n*s)的解法，其使用如前文中经过空间优化过的 0-1 背包所使用的一维数组，按如下方法进行状态转移：

for (int i = 1;i <= n;i ++) {
    for (int j = list[i].w;j <= s;j ++) {
        dp[j] = max(dp[j],dp[j - list[i].w] + list[i].v);
    }
} 

注意到该代码片段与上文中所讲的 0-1 背包相比，似乎只存在着对状态 j 的遍历顺序有所差异，这是有原因的。在 0-1 背包中，之所以逆序循环更新状态是为了保证更新 dp[j]时，dp[j - list[i].w]的状态尚未因为本次更新而发生改变，即等价于由 dp[i - 1][j - list[i].w]转移得到 dp[i][j]。逆序循环，保证了更新 dp[j]时，dp[j - list[i].w]是没有放入物品 i 时的数据(dp[i - 1][j - list[i].w])，这是因为 0-1 背包中每个物品至多只能被选择一次。而在完全背包中，每个物品可以被无限次选择，那么状态 dp[i][j]恰好可以由可能已经放入物品 i 的状态 dp[i][j - list[i].w]转移而来，固在这里将状态的遍历顺序改为顺序，使在更新状态 dp[j]时，dp[j - list[i].w]可能因为放入物品 i 而发生改变，从而达到目的。