【DP学习总结】背包九讲（模型）

最新推荐文章于 2022-02-05 11:09:55 发布

W⁡angduoyu

最新推荐文章于 2022-02-05 11:09:55 发布

阅读量799

点赞数 1

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

本文链接：https://blog.csdn.net/ecjtu2020/article/details/121809362

版权

学习总结同时被 2 个专栏收录

39 篇文章 0 订阅

订阅专栏

动态规划

10 篇文章 0 订阅

订阅专栏

文章目录

01背包
完全背包
多重背包
混合背包
分组背包
二维费用背包
有依赖的背包
背包问题求具体方案
背包问题求具体方案数
背包的例题

01背包

问题描述：

有 $N$ 件物品和一个容量为 $V$ 的背包。第 $i$ 件物品的体积是 $v [i]$ ，价值是 $w [i]$ 。求解将哪些物品装入背包可使价值总和最大。

思路：

01背包的特点：每件物品可以选择放或者不放。

状态表示： $f [i] [j]$ 表示前 $i$ 个物品，容量不超过 $j$ 的所有方案数中价值的最大值
状态计算：不选： $f [i] [j] = f [i - 1] [j]$ ，选： $f [i] [j] = m a x (f [i] [j], f [i - 1] [j - v [i]) + w [i])$

Code:

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

优化：

滚动数组优化：
观察到，对于第 $i$ 层都只和第 $i - 1$ 层的状态有关。优化如下：

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

经典01背包优化：
用 $f [j]$ 来表示背包容量为 $j$ 的最大价值
在更新状态的时候，我们需要逆序枚举体积(m->v)，
为什么要逆序？优化为1维的时候，对于第选 $i$ 个物品体积为 $v$ ，则 $f [j]$ 由 $f [j - v]$ 得来，原本用到的应该是二维的 $f [i - 1] [j - v]$ ，如果一维去正序枚举的话用到的就是 $f [i] [j - v]$ 。如果是逆序得话，就可以避免了。

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

完全背包

问题描述：

有 $N$ 种物品和一个容量为 $V$ 的背包，每种物品都有无限件可用，第 $i$ 种物品的体积是 $v [i]$ ，价值是 $w [i]$ 。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
思路：

状态表示： $f [i] [j]$ ：表示前 $i$ 个物品，体积不超过 $j$ 的所有方案中价值的最大值
状态计算： $k*w)(j-k*v\ge 0)$

优化一下状态计算：
$\quad f[i-1][j -v] + w, f[i-1][j-2v]+2w, \cdots f[i-1][k*v]+k*w)$
$\qquad \quad \quad f[i - 1][j-v], \quad f[i-1][j -2v] + w, f[i-1][j-3v]+2w, \cdots f[i-1][k*v]+(k-1)*w)\\ \cdots$

所以状态计算可以写成： $f [i] [j] = m a x (f [i - 1] [j], f [i] [j - v] + w)$
code：

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

优化：

滚动数组优化：

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

经典完全背包优化：
$f [j]$ 表示容量为 $j$ 的背包的能得到的最大价值
计算：从小到大去计算（与01背包的区别）

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

多重背包

问题描述：

有 $N$ 种物品和一个容量为 $V$ 的背包。第 $i$ 种物品最多有 $s [i]$ 件可用，每件体积是 $v [i]$ ，价值是 $w [i]$ 。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

思路：

状态表示： $f [j]$ ：体积不超过 $j$ 的所有方案中价值的最大值
状态计算： $f [j] = m a x (f [j], f [j - v] + w)$ （对于第 $i$ 件物品，只需做 $s_i$ 次01背包即可）

code:

for(int i = 1; i <= n; ++i)
    {
        int v, w, s; cin >> v >> w >> s;
        for(int k = 1; k <= s; ++k) // 对s次都做一次01背包
        for(int j = m; j >= v; --j)
            f[j] = max(f[j], f[j - v] + w);
    }
    cout << f[m];

优化：

二进制优化：对于一个数 $x$ ，我们把它分成 $2^0，2^1, 2^2, \cdots, 2^t(2^t <= x),x - 2^t$ 。容易发现，对于 $\sim x$ 都可以用上述拼出来。那么进行 $s_i$ 次的次数就减少到了 $log_{2}s_i$ 次

    cin >> n >> m;
    vector<Good>g;
    for(int i = 1; i <= n; ++i)
    {
        int v, w, s; cin >> v >> w >> s;
        for(int k = 1; k <= s; k <<= 1)
        {
            s -= k;
            g.push_back({k*v,k*w});
        }
        if(s > 0) g.push_back({s*v,s*w});
    }
    for(auto goods : g)
    for(int j = m; j >= goods.v; --j)
        f[j] = max(f[j], f[j-goods.v] + goods.w);
    cout << f[m];

单调队列优化

混合背包

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

第一类物品只能用1次（01背包）；
第二类物品可以用无限次（完全背包）；
第三类物品最多只能用 $s_i$ 次（多重背包）；

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

solution: 对应物品做相应背包即可
题目连接：Acwing 7
code:

#include <bits/stdc++.h>
using namespace std;

const int N = 1010;

int n, m;
int f[N];

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; ++i) {
        int v, w, s;
        cin >> v >> w >> s;
        if(s == 0) {
            for(int j = v; j <= m; ++ j)    
                f[j] = max(f[j], f[j - v] + w);
        }else {
            if(s == -1) {
                for(int j = m; j >= v; -- j) f[j] = max(f[j], f[j - v] + w);
            }else {
                vector<pair<int, int>> good;
                for(int k = 1; k <= s; k <<= 1) {
                    s -= k;
                    good.push_back({k * v, k * w});
                }
                if(s > 0) good.push_back({s * v, s * w});
                for(auto Good : good) 
                    for(int j = m; j >= Good.first; -- j) f[j] = max(f[j], f[j - Good.first] + Good.second);
            }
        }
    }
    cout << f[m] << "\n";
}

分组背包

问题描述：
题目链接： Acwing 9
有 $N$ 组物品和一个容量是 $V$ 的背包。每组物品有若干个，同一组内的物品最多只能选一个。每件物品的体积是 $v_{i,j}$ ，价值是 $w_{i,j}$ ，其中 $i$ 是组号， $j$ 是组内编号。求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。数据范围均小于100

思路：
对每一组进行01背包
Code:

#include<bits/stdc++.h>
using namespace std;
int n, m;
int f[110], v[110][110], w[110][110], s[110];
int main()
{
    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)// 枚举组，然后01背包
    {
        for(int k = m; k >= 0; --k)//每个h对应每组最优解
        {
            for(int h = 1; h <= s[i]; ++h)
            if(k >= v[i][h]) f[k] = max(f[k], f[k - v[i][h] ] + w[i][h]);
        }
    }
    cout << f[m];
    return 0;
}

二维费用背包

题目连接：Acwing 8
有 $N$ 件物品和一个容量是 $V$ 的背包，背包能承受的最大重量是 $M$ 。
每件物品只能用一次。体积是 $v_i$ ，重量是 $m_i$ ，价值是 $w_i$ 。
求解将哪些物品装入背包，可使物品总体积不超过背包容量，总重量不超过背包可承受的最大重量，且价值总和最大。
输出最大价值。

思路：
将一维的01背包扩展为二维

Code:

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int f[N][N];
int n, v, m;
int main()
{
    cin >> n >> v >> m;
    for(int i = 1; i <= n; ++ i) {
        int v_, m_, w_;
        cin >> v_ >> m_ >> w_;
        for(int j = v; j >= v_; -- j)   
            for(int k = m; k >= m_; -- k)
                f[j][k] = max(f[j][k], f[j - v_][k - m_] + w_);
    }
    cout << f[v][m] << "\n";
}

有依赖的背包

题目连接：Acwing 10
在这里插入图片描述

树形DP

状态表示： $f [i] [j]$ 表示，考虑以 $i$ 根节点的子树，选上 $i$ ，且体积不超过 $j$ 的所有方案价值的最大值
状态计算：将以 $i$ 为根节点的子树按照体积划分状态，也就是分给根节点下面的体积 $f [u] [j] = m a x (f [u] [j], f [u] [j - k] + f [s o n] [k])$ 结合代码理解QAQ

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
vector<int> G[N];
int f[N][N], v[N], w[N], n, m;

void dfs(int u) {
    
    for(int x : G[u]) {
        dfs(x); // 从下往上算
        for(int j = m - v[u]; j >= 0; -- j) // 枚举一下需要更新的状态
            for(int k = 0; k <= j; ++ k) // 枚举一下分给i根节点下面的体积
                f[u][j] = max(f[u][j], f[u][j - k] + f[x][k]);
    }
    // 选上了第u件
    for(int j = m; j >= v[u]; -- j) f[u][j] = f[u][j - v[u]] + w[u];
    for(int j = 0; j < v[u]; ++ j ) f[u][j] = 0;  // 小于就不存在以u为根节点的情况
}

int main()
{
    cin >> n >> m;
    int root, p;
    for(int i = 1; i <= n; ++ i) {
        cin >> v[i] >> w[i] >> p;
        if(p == -1) root = i;
        else G[p].push_back(i);
    }
    dfs(root);
    cout << f[root][m] << "\n";
    return 0;
}

背包问题求具体方案

题目链接：Acwing 12
题意：

有 $N$ 件物品和一个容量是 $V$ 的背包。每件物品只能使用一次。
第 $i$ 件物品的体积是 $v_i$ ，价值是 $w_i$ 。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出 字典序最小的方案。这里的字典序是指：所选物品的编号所构成的序列。物品的编号范围是 $\cdots N$ 。

solution:
要求方案，其实就是求一下状态转移的路径。也就是说，对于第 $i$ 件物品，是选了还是没有选。倒着退一下就好
因为本题要求字典序最小的方案，在从 $\sim n$ 推路径的时候，遇到可以选要先选。所有采用 $\sim 1$ 来进行背包DP

状态表示： $f [i] [j]$ ，表示考虑后 $i$ 件物品，体积不超过 $j$ 的所有方案的价值的最大值
状态转移: 不选： $f [i] [j] = f [i + 1] [j]$ ，选 $f [i] [j] = m a x (f [i] [j], f [i + 1] [j - v] + w)$

#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n, m;
int f[N][N];
int v[N], w[N], path[N], cnt;
int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; ++ i) cin >> v[i] >> w[i];
    for(int i = n; i >= 1; -- i) {
        for(int j = 0; j <= m; ++ j) {
            f[i][j] = f[i + 1][j];
            if(j >= v[i]) f[i][j] = max(f[i][j], f[i + 1][j - v[i]] + w[i]);
        }
    }
    for(int i = 1, j = m; i <= n; ++ i) {// 能选就先选
        if(j >= v[i] && f[i + 1][j - v[i]] + w[i] == f[i][j]) {
            path[cnt ++ ] = i;
            j -= v[i];
        }
    }
    for(int i = 0; i < cnt; ++ i) cout << path[i] << " ";
}

背包问题求具体方案数

题目链接：Acwing 11

题意：
有 $N$ 件物品和一个容量是 $V$ 的背包。每件物品只能使用一次。
第 $i$ 件物品的体积是 $v_i$ ，价值是 $w_i$ 。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出 最优选法的方案数。注意答案可能很大，请输出答案模 $10^9 + 7$ 的结果。

solution：
01背包模型：

状态表示： $f [i] [j]$ 表示考虑前 $i$ 个物品，体积不超过 $j$ 的所有方案当中的最大值
状态计算： $f [i] [j] = f [i - 1] [j]$ , $f [i] [j] = m a x (f [i] [j], f [i - 1] [j - v] + w)$

路径：

状态表示： $g [i] [j]$ 表示前 $i$ 个物品，体积为 $j$ 且价值大的方案数
状态计算： $g [i] [j] = g [i] [j] + g [i - 1] [j]$ ， $g [i] [j] = g [i] [j] + g [i - 1] [j - v])$

code:

#include <bits/stdc++.h>
using namespace std;
const int N = 1010, mod = 1e9 + 7;
int f[N][N], g[N][N];
int n, m, v[N], w[N];

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; ++ i) {
        cin >> v[i] >> w[i];
        for(int j = 0; j <= m; ++ j) {
            f[i][j] = f[i - 1][j];
            if(j >= v[i]) f[i][j] = max(f[i][j], f[i - 1][j - v[i]] + w[i]);
        }
    }
    g[0][0] = 1;
    for(int i = 1; i <= n; ++ i) {
        for(int j = 0; j <= m; ++ j) {
            if(f[i][j] == f[i - 1][j]) {
                g[i][j] = (g[i][j] + g[i - 1][j]) % mod;
            }
            if(j >= v[i] && f[i - 1][j - v[i]] + w[i] == f[i][j]) {
                g[i][j] = (g[i][j] + g[i - 1][j - v[i]]) % mod;
            }
        }
    }
    int res = 0;
    for(int i = 0; i <= m; ++ i) {
        if(f[n][i] == f[n][m]) {
            res = (res + g[n][i]) % mod;
        }
    }
    cout << res << "\n";
}