背包九讲（闫氏DP分析法）（详细思路及证明）

AC自动寄

已于 2022-08-25 15:58:36 修改

阅读量680

点赞数 2

文章标签：动态规划算法 c++ 蓝桥杯学习

于 2022-05-13 17:06:28 首次发布

本文链接：https://blog.csdn.net/m0_61409183/article/details/124752826

版权

背包问题共同点与区别

简单叙述：
在这里插入图片描述

简单证明：

标题： $证明关于背包问题优化到低维后的正向反向循环问题$

例子01背包：
优化到一维后为从大到小循环，如下图循环所示：
其状态计算为：

	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]);

在这里插入图片描述
例子完全背包问题：
优化到一维后为从小到大循环，如下图所示：
其状态计算为：

 三重循环暴力：
 	f[i][j] = max(f[i][j], f[i-1][j - k*v[i]] + k * w[i]);
 两重循环： 
 	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]);

在这里插入图片描述
可以找到区别：

01背包中， $ma x$ 函数里面的第二位为 $f [i - 1] [j - v [i]]$
完全背包中， $ma x$ 函数里面的第二位为 $f [i] [j - v [i]]$

其中： $f [i - 1] [j - v [i]]$ 为上一层的状态，因为本次计算需要上一层的状态，且 $j - v [i]$ 小于 $j$ ，为保持其上一层的状态不变，要先计算从大到小计算状态

反之， $f [i] [j - v [i]$ 为本层的状态，要保证计算 $f [i] [j]$ 的 $f [i] [j - v [i]$ 为本层的状态，必须从小到大先计算本层之前的状态

如此可知： 若 $ma x$ 函数里第二位为上一层的 $j$ 之前的状态则从大到小
若 $ma x$ 函数里第二位为本层的 $j$ 之前的状态则从小到大
(具体的一维状态的解释，见下面的01背包问题的证明)

01背包问题

题意如下：
有 $N$ 件物品和一个容量是 $V$ 的背包。每件物品只能使用一次。
第 $i$ 件物品的体积是 $v [i]$ ，价值是 $w [i]$ 。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。

输入格式
第一行两个整数， $N$ ， $V$ ，用空格隔开，分别表示物品数量和背包容积。
接下来有 $N$ 行，每行两个整数 $v [i]$ ， $w [i]$ ，用空格隔开，分别表示第 $i$ 件物品的体积和价值。

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

数据范围
$0 < N, V \leq 1000 ， 0 < v [i], w [i] \leq 1000$

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

闫氏DP分析法
分析思路如下：
01背包问题

注意：

$f [i - 1] [j - v [i]] + w [i]$ 不一定存在，特判一下即可

状态计算代码如下：

朴素版：

$二维形式：$
$f [i] [j] = ma x (f [i - 1] [j], f [i - 1] [j - v [i]] + w [i])$

   for(int i = 1; i <= n; 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]);
       }
   }

优化时间版（最终版）：

$一维形式：$

$f [j] = ma x (f [j], f [j - v [i]] + w [i])$

优化方案：

思路：

$(1)$ $f [i]$ 这层只用到了 $f [i - 1]$ 这一层可以简化为滚动数组来做

$(2)$ 求 $f [i] [j]$ 时只用到了 $f [i - 1] [j]$ 与 $f [i - 1] [j - v [i]]$ ,可知 $j$ 与 $j - v [i]$ 均小于等于 $j$ ，所以可以简化为一维的形式

具体实现流程及证明：

$(1)$ 直接删掉第一维， $f [i] [j]$ 变为 $f [j]$

$(2)$ 因为 $j < v [i]$ 时没意义，所以 $j$ 从 $v [i]$ 开始枚举

$(3)$ 倒叙枚举 j ，计算 $f [j]$

对 (3) 倒叙枚举 j 的一些解释：
$(1)$ 一维的本层与上一层值的区别
据上述分析，知：二维形式的 $f [i] [j]$ 为本层的， $f [i - 1] [j]$ 为上一层的，因为 $i$ 与 $i - 1$ 的差别，我们可以显而易见的区分。

那么当一维形式的 $f [j]$ 由上一层更新为本层，没有了 $i$ ，如何区别？

答：通过 $ma x$ 计算过，为本层值。我们知道，本层的 $f [j]$ 一定是经过上一层的 $f [j]$ 取 $ma x$ 计算得来；那么我们可以得出小结论，在本层的 $f [j]$ 中，还未计算 $ma x$ 的为上一层的值，计算过 $ma x$ 的为本层的值

$(2)$ 解释一维变量并明确目标

目标：将二维数据直接去除一维以后，与原数据的含义相等。

解释一维数据：

$f [i] [j] = ma x (f [i] [j], f [i - 1] [j - v [i]] + w [i])$ 如果直接删除第一维，将变成 $f [j] = ma x (f [j], f [j - v [i] + w [i]) 。$

此方程的 $f [j - v [i]]$ 在计算 $f [j]$ 之前就在本层被计算过。所以 $f [j - v [i]]$ 对应为 $f [i] [j - v [i]]$ （本层值）与原题意的对应为 $f [i - 1] [j - v [i]]$ （上一层值）不符合。

转化目标：
所以我们的现在的目标是让 $f [j]$ 在 $f [j - v [i]]$ 之前被计算，如此做之在计算 $f [j]$ 时， $f [j - v [i]]$ 还没被计算过，其对应为 $f [i - 1] [j - v [i]]$ （上一层的值）。
$(3)$ 具体方法
将 $j$ 从最大值 $m$ 开始枚举，倒叙枚举，使 $f [j]$ 在 $f [j - v [i]]$ 之前更新，如此可以使当计算 $f [j]$ 时， $f [j - v [i]]$ 还未计算 $ma x$ （未上一层的值）。到此，一维简化完毕；

$一维形式：$

  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]);
      }
  }

最终版（一维形式）全部代码：

#include <bits/stdc++.h>

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int f[N];

int main()
{
    cin >> n >> m;
    
    for(int i = 1; i <= n; i ++ ) scanf("%d%d", &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] << endl; 
    return 0;
}

完全背包问题

题意如下：
有 $N$ 件物品和一个容量是 $V$ 的背包。每件物品可以无限次用。
第 $i$ 件物品的体积是 $v [i]$ ，价值是 $w [i]$ 。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。

输入格式
第一行两个整数， $N$ ， $V$ ，用空格隔开，分别表示物品数量和背包容积。
接下来有 $N$ 行，每行两个整数 $v [i]$ ， $w [i]$ ，用空格隔开，分别表示第 $i$ 件物品的体积和价值。

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

数据范围
$0 < N, V \leq 1000 ， 0 < v [i], w [i] \leq 1000$

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

闫氏DP分析法
分析思路如下：
完全背包问题

注意：

$f [i] [j - v [i]] + w [i]$ 不一定存在，特判一下即可

状态计算代码如下：

暴力版：

$二维三重循环形式：$

$f [i] [j] = ma x (f [i] [j], f [i - 1] [j - k * v [i]] + k * w [i])$

注意： $N$ 为 $1000$ ，一定会 $T L E$ （时间超限）

具体实现：

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

优化时间版：

$二维两重循环形式：$
$f [i] [j] = ma x (f [i - 1] [j], f [i] [j - v [i]] + w [i])$

优化方案：

思路：
由上图的闫氏DP分析法的图可以知道：
$f or (in t k = 0; k * v [i] <= j; k + +)$
$f [i] [j] = ma x (f [i] [j], f [i - 1] [j - k * v [i]] + k * w [i])$
$f [i] [j - v [i]] = ma x (f [i - 1] [j], f [i - 1] [j - k * v [i]] + (k - 1) * w [i])$
所以： $f [i] [j]$ 的 $ma x$ 的第二项循环可以转化为一个表达式，即 $f [i] [- v [i]] + w [i]$ ，所以可以优化掉一重循环

注意：
此处与01背包很像，两者区别为 $ma x$ 中的第二项
见如下对比：
01 背包： $f [i] [j] = ma x (f [i - 1] [j], f [i - 1] [j - v [i]] + w [i])$
完全背包: $f [i] [j] = ma x (f [i - 1] [j], f [i] [j - v [i]] + w [i])$

具体实现：

for(int i = 1; i <= n; 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][j-v[i]] + w[i]);
            }

优化时间和空间版：（最终版）

$一维两重循环形式：$
$f [j] = ma x (f [j], f [j - v [i]] + w [i]);$

优化方案：

思路：
与 01背包类似
$(1)$ 求 $f [i] [j]$ 时只用到了 $f [i - 1] [j]$ 与 $f [i] [j - v [i]]$ ,可知 $j$ 与 $j - v [i]$ 均小于等于 $j$ ，所以可以简化为一维的形式

具体实现流程及证明：

$(1)$ 直接删掉第一维， $f [i] [j]$ 变为 $f [j]$

$(2)$ 因为 $j < v [i]$ 时没意义，所以 $j$ 从 $v [i]$ 开始枚举

$(3)$ 正序枚举 j ，计算 $f [j]$

对 (3) 正叙枚举 j 的一些解释：

$(1)$ 变量的解释
关于变量 $f [j]$ 的理解与01背包的理解一样，没经过 $ma x$ 处理的为上一层的数据，经过 $ma x$ 处理的为本层 $f [j]$ （具体分析流程见 01 背包问题的一维解析，此处不再赘述）

$(2)$ 明确目的并对比二维与一维变量
目标：
将二维数据直接去除一维以后，与原数据的含义相等。
解释一维数据：

对 $f [i] [j] = f [i - 1] [j]$ 变为 $f [j] = f [j]$ 的解释：
左 $f [j]$ 本来就是本层数据，待更新
右 $f [j]$ 为经过本层的 $ma x$ ，为上一层的数据
与原数据含义相符

对 $f [i] [j] = ma x (f [i] [j], f [i] [j - v [i]] + w [i])$ 变为 $f [j] = ma x (f [j], f [j - v [i]] + w [i])$ 的解释：
左 $f [j]$ 待更新没什么好的说的
右 $ma x$ 中第一项 $f [j]$ ，为未更新的 $f [j]$ 含义为本层的，
右 $ma x$ 中第二项 $f [j - v [i]] + w [i]$ 因为正序枚举 $j$ 所以 $f [j - v [i]]$ 在本层的 $f [j]$ 之前计算过，为本层的 $f [j - v [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]);
        }
    }

最终版（一维形式）完整代码如下：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
int v[N], w[N];
int f[N];

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] << endl;
    
    return 0;
}

多重背包问题 $I$

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

输入格式
第一行两个整数， $N$ ， $V$ ，用空格隔开，分别表示物品数量和背包容积。
接下来有 $N$ 行，每行两个整数 $v [i]$ ， $w [i]$ ，用空格隔开，分别表示第 $i$ 件物品的体积和价值。

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

数据范围
$0 < N, V \leq 100 ， 0 < v [i], w [i], s [i] \leq 100$

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

思路：
题目范围较小，按照完全背包的暴力版枚举即可，在循环个数时，加一个限制条件即可

暴力版：

$二维三重循环形式：$

$f [i] [j] = ma x (f [i] [j], f [i - 1] [j - k * v [i]] + k * w [i])$

具体实现：

for(int i = 1; i <= n; i ++ )
        for(int j = 0; j <= m; j ++ )
            for(int k = 0; k * v[i] <= j && k <= s[i]; k ++ )
                f[i][j] = max(f[i][j], f[i-1][j - k*v[i]] + k * w[i]);

整体代码如下：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

int n,m;
int v[N],w[N],s[N];
int f[N][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 = 0; j <= m; j ++ )
        {
            for(int k = 0; k <= s[i] && k * v[i] <= j; k ++ )
            {
                f[i][j] = max(f[i][j],f[i-1][j - v[i] * k ] + w[i] * k);
            }
        }
    }
    
    cout << f[n][m] << endl;
    
    return 0;
}

$一维两重循环形式$

思路：
因为涉及第 $i - 1$ 层的状态，所以我们从大到小枚举（至于为什么，可以看上面01背包问题的讲解）

具体实现：

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

整体代码如下：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

int n,m;
int v[N],w[N],s[N];
int f[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 = m; j >= 0; j -- )
        {
            for(int k = 0; k <= s[i] && k * v[i] <= j; k ++ )
            {
                f[j] = max(f[j],f[j - v[i] * k ] + w[i] * k);
            }
        }
    }
    
    cout << f[m] << endl;
    
    return 0;
}

多重背包问题 $II$

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

输入格式
第一行两个整数， $N$ ， $V$ ，用空格隔开，分别表示物品数量和背包容积。
接下来有 $N$ 行，每行两个整数 $v [i]$ ， $w [i]$ ，用空格隔开，分别表示第 $i$ 件物品的体积和价值。

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

数据范围
$0 < N \leq 1000 ， 0 < V < 2000 ， 0 < v [i], w [i], s [i] \leq 2000$

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

思路：
题目范围较大，按照完全背包的暴力版枚举时间复杂度为O(10^9)，一定会TLE，

考点：
多重背包问题的二进制优化方案，
将第 $i$ 个物品可以选 $s [i]$ 次，分为可以选 $c n t$ 个组， $c n t$ 组的总和为 $s [i]$

结论：

$c n t$ 为 $l o g (2)$ + $s [i]$ 剩余的部分(无法分为2的整次幂的部分）

验证正确性：
7 = 111[2]
7 = 1 + 2 + 4
8 = 111[2]+1[10]
8 = 1 + 2 + 4 + 1
20 = 1111[2] + 4[10]
20 = 1 + 2 + 3 + 4 + 8 + 4

具体实现：

struct Good
{
    int v, w;
};

vector<Good> goods;
for(int i = 0; i < n; i ++ )
{
    int v, w, s;
    cin >> v >> w >> s;
    for(int k = 1; k <= s; k *= 2)
    {
        s -= k;
        goods.push_back({v*k, w*k});
    }
    if(s > 0) goods.push_back({v*s, w*s});
   }

整体代码如下：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>

using namespace std;

const int N = 2010;

int n, m;
int f[N];

struct Good
{
    int v, w;
};

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

分组背包问题

题意如下：
有 $N$ 组物品和一个容量是 $V$ 的背包。
每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 $v [i] [j]$ ，价值是 $w [i] [j]$ ，其中 $i$ 是组号， $j$ 是组内编号。
求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。
输出最大价值。

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

接下来有 $N$ 组数据：

每组数据第一行有一个整数 $s [i]$ ，表示第 $i$ 个物品组的物品数量；每组数据接下来有 $s [i]$ 行，每行有两个整数 $v [i] [j]$ , $w [i] [j]$ ，用空格隔开，分别表示第 $i$ 个物品组的第 $j$ 个物品的体积和价值；
输出格式
输出一个整数，表示最大价值。

数据范围
$0 < N, V \leq 1000 < s [i] \leq 100$
$0 < v [i] [j], w [i] [j] \leq 100$

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

思路：
多重背包问题 $I$ 的普通版，与多重背包问题 $I$ 相比，此问题是将 $s [i]$ 个分开计算，多重背包问题 $I$ 是打包成 $s [i]$ 组，暴力枚举即可，与多重背包问题 $I$ 思路一样

暴力版：

$二维形式：$

$f [i] [j] = ma x (f [i] [j], f [i - 1] [j - v [i] [k]] + w [i] [k])$

$一维形式：$
$f [j] = ma x (f [j], f [j - v [i] [k]] + w [i] [k])$

具体实现：

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

整体代码如下：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 210;

int n, m;
int v[N][N], w[N][N], s[N];
int f[N];

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