背包入门（包括一维优化）：01背包、完全背包、多重背包、分组背包

最新推荐文章于 2022-11-23 16:37:11 发布

AC粥

最新推荐文章于 2022-11-23 16:37:11 发布

阅读量311

点赞数

分类专栏：算法文章标签：算法 c++ 动态规划

本文链接：https://blog.csdn.net/weixin_43462804/article/details/126719756

版权

算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

背包问题（题目均来自Acwing）

2. 01 背包问题

有 $N$ 件物品和一个容量是 $V$ 的背包。每件物品只能使用一次。

第 $i$ 件物品的体积是 $v_i$ ，价值是 $w_i$ 。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式

第一行两个整数， $N$ ， $V$ ，用空格隔开，分别表示物品数量和背包容积。

接下来有 $N$ 行，每行两个整数 $v_i$ ， $w_i$ 用空格隔开，分别表示第 $i$ 件物品的体积和价值。

输出格式

输出一个整数，表示最大价值。

数据范围

$N,V\le1000$

$v_i,w_i\le1000$

输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
8

$f [i] [j]$ 表示前 $i$ 件物品放到容量为 $j$ 的背包中的最大价值。

动态转移方程：f[i][j] = max(f[i-1][j], f[i-1][j-v[i]] + w[i])

$f [i] [j]$ 只可能来自于两个状态，要么取第 $i$ 件物品，要么不取第 $i$ 件物品。

(1) 如果不装第 $i$ 件物品，那么问题就转化为“前 $i - 1$ 件物品放入容量为 $j$ 的背包中的最大价值”

(2) 如果装第 $i$ 件物品，那么问题就转化为“前 $i - 1$ 件物品放入剩下的容量为 $j - v [i]$ 的背包中的最大价值”

#include<iostream>
using namespace std;
const int N = 1e3 + 10;
int f[N][N], w[N], v[N];
int main(){
    int n, m;
    cin>>n>>m;
    for(int i = 1; i <= n; i++){
        cin>>v[i]>>w[i];
    }
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            f[i][j] = f[i - 1][j];
            if(j - v[i] >= 0)
            f[i][j] = max(f[i][j], f[i - 1][j - v[i]] + w[i]);
        }
    }
    cout<<f[n][m];
    return 0;
}

事实上，我们想要知道最后的状态，也就是 $f [n] [m]$ ，只需要知道体积从 $1\sim{m}$ 的状态。所以，第一维可以约简。

从f[i][j] = max(f[i-1][j], f[i-1][j-v[i]] + w[i])不难发现，当前状态均来自于前 $i - 1$ 个物品的状态。所以，如果状态更新如下：

for(int i = 1; i <= n; i++){
        for(int j = v[i]; j <= m; j++){
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }

那么本轮更新的值，可能就会影响后续更新的值，也就是f[i][j] = max(f[i-1][j], f[i][j-v[i]] + w[i])。比如，这一轮更新了 $f [3]$ ，这一轮更新 $f [7]$ 的时候又用到了 $f [3]$ 。如果按照：

for(int i = 1; i <= n; i++){
        for(int j = m; j >= v[i]; j--){
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }

更新，就不会有上述问题。原因是当前更新时， $f [j]$ 用到的状态来自于 $f [j - v [i]]$ ，倒着遍历时 $f [j]$ 更新总是先于 $f [j - v [i]]$ 。

#include<iostream>
using namespace std;
const int N = 1e3 + 10;
int f[N], w[N], v[N];
int main(){
    int n, m;
    cin>>n>>m;
    for(int i = 1; i <= n; i++){
        cin>>v[i]>>w[i];
    }
    for(int i = 1; i <= n; i++){
        for(int j = m; j >= v[i]; j--){
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
    cout<<f[m];
    return 0;
}

3. 完全背包问题

有 $N$ 种物品和一个容量是 $V$ 的背包，每种物品都有无限件可用。

第 $i$ 种物品的体积是 $v_i$ ，价值是 $w_i$ 。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式

第一行两个整数， $N$ ， $V$ ，用空格隔开，分别表示物品种数和背包容积。

接下来有 $N$ 行，每行两个整数 $v_i$ ， $w_i$ 用空格隔开，分别表示第 $i$ 种物品的体积和价值。

输出格式

输出一个整数，表示最大价值。

数据范围

$N,V\le1000$

$v_i,w_i\le1000$

输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
10

$f [i] [j]$ 表示前 $i$ 件物品放到容量为 $j$ 的背包中的最大价值。

f[i][j] = max(f[i - 1][j - k * v[i]] + k * w[i])，状态转移过程和01背包是一致的，只不过每种物品是无限的。

#include<iostream>
using namespace std;
const int N = 1010;
int f[N][N];
int v[N], w[N];
int n , m;
int main(){
    cin>>n>>m;
    for(int i = 1; i <= n; i++)  cin>>v[i]>>w[i];
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            for(int k = 0; j - k * v[i] >= 0; k++)
                f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + k * w[i]);
        }
    }
    cout<<f[n][m];
}

如果将 $f [i] [j]$ 进行推导，可以得到：

$\times v] + k \times w)\quad k=0,1,2...$

$f[i][j-2\times v] + 2 \times w,f[i][j-3\times v] + 3 \times w, ...)$

$f[i][j-v]=max(\quad\quad\quad f[i][j-v], \quad\quad f[i][j-2\times v]+w,\quad\quad f[i][j-3\times v] + 2 \times w+...)$

用极限的思想来看， $f [i] [j]$ 就可以被转化为：

f[i][j] = max(f[i - 1][j], f[i][j - v[i] + w[i])

#include<iostream>
using namespace std;
const int N = 1010;
int f[N][N];
int v[N], w[N];
int n , m;
int main(){
    cin>>n>>m;
    for(int i = 1; i <= n; i++)  cin>>v[i]>>w[i];
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            f[i][j] = f[i - 1][j];
            if(j >= v[i])
                f[i][j] = max(f[i][j], f[i][j - v[i]] + w[i]);
        }
    }
    cout<<f[n][m];
}

从更新公式f[i][j] = max(f[i-1][j], f[i][j - v[i]] + w[i])来看，完全背包和01背包一样都可以被优化为一维。由于当前更新可能来自于本轮的更新，所以只需要正序遍历即可。

#include<iostream>
using namespace std;
const int N = 1010;
int f[N];
int v[N], w[N];
int n , m;
int main(){
    cin>>n>>m;
    for(int i = 1; i <= n; i++)  cin>>v[i]>>w[i];
    for(int i = 1; i <= n; i++){
        for(int j = v[i]; j <= m; j++){
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
    cout<<f[m];
}

4. 多重背包问题

有 $N$ 种物品和一个容量是 $V$ 的背包。

第 $i$ 种物品最多有 $s_i$ 件，每件体积是 $v_i$ ，价值是 $w_i$ 。

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

输入格式

第一行两个整数， $N$ ， $V$ ，用空格隔开，分别表示物品种数和背包容积。

接下来有 $N$ 行，每行三个整数 $v_i$ ， $w_i$ ， $s_i$ ，用空格隔开，分别表示第 $i$ 种物品的体积、价值和数量。

输出格式

输出一个整数，表示最大价值。

数据范围

$N,V\le100$

$v_i,w_i,s_i\le 100$

输入样例
4 5
1 2 3
2 4 1
3 4 3
4 5 2
输出样例：
10

解释一下为什么多重背包不能直接做 $O(n^2)$ 的优化：
f[i][j] = max(f[i - 1][j], f[i - 1][j - v] + w, f[i - 1][j - 2v] + 2w,...,f[i - 1][j - sv] + sw]) f[i][j - v] = max( f[i - 1][j - v], f[i - 1][j - 2v] + w),...,f[i - 1][j - sv] + (s-1)w, f[i - 1][j - (s+1)v] + sw)

因为这里每种物品的数量是有限的，所以不能转化。

#include<iostream>
using namespace std;
const int N = 110;
int f[N][N];
int n, m;
int v[N], w[N], s[N];
int main(){
    cin>>n>>m;
    for(int i = 1; i <= n; i++) cin>>v[i]>>w[i]>>s[i];
    for(int i = 1; i <= n ; i++){
        for(int j = 1; j <= m; j++){
            for(int k = 0; j - k * v[i] >= 0 && k <= s[i]; k++){
                f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + k * w[i]);
            }
        }
    }
    cout<<f[n][m];
    return 0;
}

不难发现，朴素做法的时间复杂度是 $O(n^3)$ （假设 $N$ ， $V$ ， $S$ 同一数量级），如果想要优化到 $O(n^2log(n))$ ，就不能将每种物品的数量一个个枚举。我们知道，十进制可以转换为二进制，例如 $10_D = 1010_B \iff 10_D = 0 \times2^0 + 1 \times 2^1 + 0 \times 2^2 + 1 \times2^3$ 。我们只需要将 $2^0$ ， $2^1$ ， $2^2$ ， $3(10-2^2-2^1-2^0)$ 对应的体积以及价值计算出来，再按照01背包的方式取 $2^0$ ， $2^1$ ， $2^2$ ， $6(10-1\times2^2-0\times2^1-0\times2^0)$ 或者不取。

问：为什么最后一堆取3而不取 $2^3$ 呢？

答：分为1，2，4，3按照0，1背包的选法最多为10个，但是1，2，4，8有可能超过10个，实际上没有10个。

#include<iostream>
using namespace std;
const int N = 20000;
int v[N], w[N];
int f[N];
int main(){
    int n, m;
    cin>>n>>m;
    int vv, cnt = 0, ww, ss;
    for(int i = 1; i <= n; i++){
        int  k = 1;
        cin>>vv>>ww>>ss;
        while(k <= ss){
            cnt ++;
            v[cnt] = vv * k;
            w[cnt] = ww * k;
            ss -= k;
            k *= 2;
        }
        if(ss > 0){
            cnt ++;
            v[cnt] = vv * ss;
            w[cnt] = ww * ss;
        }
    }
    for(int i = 1; i <= cnt; i++){
        for(int j = m; j >= v[i]; j--){
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
    cout<<f[m];
}

9. 分组背包问题

有 $N$ 组物品和一个容量是 $V$ 的背包。

每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 $v_{ij}$ ，价值是 $w_{ij}$ ，其中 $i$ 是组号， $j$ 是组内编号。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。

输出最大价值。

输入格式

第一行有两个整数 $N$ ， $V$ ，用空格隔开，分别表示物品组数和背包容量。

接下来有 $N$ 组数据：

每组数据第一行有一个整数 $S_i$ ，表示第 $i$ 个物品组的物品数量；
每组数据接下来有 $S_i$ 行，每行有两个整数 $v_{ij}$ ， $w_{ij}$ ，用空格隔开，分别表示第 $i$ 个物品组的第 $j$ 个物品的体积和价值；

输出格式

输出一个整数，表示最大价值。

数据范围

$0 < N, V \leq 100$

$0 < S_i≤100$

$0 < v ij, w ij \leq 100$

输入样例
3 5
2
1 2
2 4
1
3 4
1
4 5
输出样例：
8

每组只取一个，对于不同组来说，可以转换为01背包；组内循环，最终只会保留一次更新。

#include<iostream>
using namespace std;
const int N = 111;
int f[N], s[N], v[N][N], w[N][N];
int main(){
    int n, m;
    cin>>n>>m;
    for(int i = 1; i <= n; i++){
        cin>>s[i];
        for(int j = 1; j <= s[i]; j++){
            cin>>v[i][j]>>w[i][j];
        }
    }

    for(int i = 1; i <= n; i++){
        for(int j = m; j >= 1; j--){
            for(int k = 1; k <= s[i]; k++){
                if(j - v[i][k] >= 0)
                    f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);
            }
        }
    }
    cout<<f[m];
}