原来背包不简单

最新推荐文章于 2022-08-16 11:13:28 发布

波风一一水门

最新推荐文章于 2022-08-16 11:13:28 发布

阅读量2.1k

点赞数 14

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

本文链接：https://blog.csdn.net/weixin_50909982/article/details/114355810

版权

笔记专栏收录该内容

56 篇文章 1 订阅

订阅专栏

简单背包？

重新整理背包的思路，详细分析：

01背包

「0-1 背包」即是不断对第 i 个物品的做出决策，「0-1」正好代表不选与选两种决定。
状态f[i][j]定义：前 i个物品，背包容量 j下的最优解（最大价值）：

当前背包容量不够（j < v[i]），没得选，因此前 i 个物品最优解即为前 i−1 个物品最优解。
当前背包容量够，可以选，因此需要决策选与不选第 i 个物品：
（1）选：f[i][j] = f[i - 1][j - v[i]] + w[i]
（2）不选：f[i][j] = f[i - 1][j]
（3）此时两种情况取max即可。

二维01

#include<bits/stdc++.h>

using namespace std;

const int MAXN = 1005;
int v[MAXN];    // 体积
int w[MAXN];    // 价值 
int f[MAXN][MAXN];  // f[i][j], j体积下前i个物品的最大价值 

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++)
        {
            //  当前背包容量装不进第i个物品，则价值等于前i-1个物品
            if(j < v[i]) 
                f[i][j] = f[i - 1][j];
            // 能装，需进行决策是否选择第i个物品
            else    
                f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]] + w[i]);
        }           

    cout << f[n][m] << endl;

    return 0;
}

二维优化到一维的等价变形：

我们用二维的f[i][j]可以求得任意合法的i与j最优解，而题目只需要求n个物品，v的体积下的最优解，所以我们不需要保存第几个物品这一维的信息，直接保存从第一个物品筛选到第n个物品，在第n个物品决策完之后不同体积 j 对应的最优解即可——f[j]。
在变形之前必须懂得完全背包和01背包的区别。完全背包就是对每件物品不限拿取数量。这里需要看一组数据：

物品    体积     价值 
  i = 1     4       5  
  i = 2     5       6  
  i = 3     6       7

当还未进入循环时:
    f[0] = 0;  f[1] = 0;  f[2] = 0;  f[3] = 0;  f[4] = 0;  
    f[5] = 0;  f[6] = 0;  f[7] = 0;  f[8] = 0;  f[9] = 0; f[10] = 0;
    当进入循环 i == 1 时：
    f[4] = max(f[4], f[0] + 5); 即max(0, 5) = 5; 即f[4] = 5;
    f[5] = max(f[5], f[1] + 5); 即max(0, 5) = 5; 即f[5] = 5;
    f[6] = max(f[6], f[2] + 5); 即max(0, 5) = 5; 即f[6] = 5;
    f[7] = max(f[7], f[3] + 5); 即max(0, 5) = 5; 即f[7] = 5;
    重点来了！！！
    f[8] = max(f[8], f[4] + 5); 即max(0, 5 + 5) = 10; 即f[8] = 10;
    这里就已经出错了，f[4]已经拿过i=1这一物品了，f[8]又重复拿了一次。
    因为此时处于 i=1 这一层，即物品只有一件，不存在单件物品满足价值为10的f[8]。
    所以已经出错了。

看懂数据就可以发现如果顺序更新对第一次物品的决策，f[4]拿了，f[8]又拿，这显然不合法。但如果我们对于i==1这一维倒着枚举，f[8]=f[4]+5，此时f[4]并没有拿走物品1，此时的f[8]和f[4]的解是没有问题。显然可见，如果把 i 从1 推广到n，f[4]保存的总是f[8]的前一维，即f[4]总是处于i-1维，这种枚举顺序恰巧可以保证在对 i 这件物品决策的时候，不会出现重复选取的情况。
实际上倒着枚举的时候当背包体积 j <v[i] 时就不需要更新之后的状态了（小于j的f[j]），因为他们拿不动这个物品了，所以保存上一维的最大价值就可以。
一维01

#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 = m; j >= v[i]; j -- )
            f[j] = max(f[j], f[j - v[i]] + w[i]);

    cout << f[m] << endl;

    return 0;
}

完全背包

状态f[i][j]定义：从前 i个物品中选，背包容量不超过 j 的最优解（最大价值）：
状态表示：
在这里插入图片描述
状态计算：

#include<iostream>
#include<cstring>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N];
int f[N][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=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]<<endl;
}

直接删掉 i 这一维：

#include<iostream>
#include<cstring>
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=1;j<=m;j++)
        {
            f[j]=f[j];//因为f[j]是上一个循环更新过来的
            //所以f[j]=f[j]即f[i][j]=f[i-1][j]
            if(j>=v[i]) f[j]=max(f[j],f[j-v[i]]+w[i]);
            //因为j是从小到大枚举,j>j-v[i]所以f[j-v[i]]与f[j]是同一维(f[j-v[i]被先算出来了])
            //所以f[i][j]=max(f[i][j],f[i][j-v[i]]+w[i]);
        } 
        cout<<f[m]<<endl;
}

最后把f[j]=f[j]删掉，循环里只有if，j是从小到大加到v[i]才开始进入判断，所以就直接让j=v[i]开始枚举，得到一维完全背包。

#include <algorithm>
#include <cstring>
#include <iostream>
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;
}

多重背包（完全背包变形）

加上了商品个数的循环，展开的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][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;k<=s[i]&&k*v[i]<=j;k++)
            {
                f[i][j]=max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
            }
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}

二进制优化多重背包

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

第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。

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

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

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

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

数据范围
0<N≤1000
0<V≤2000
0<vi,wi,si≤2000
提示：
本题考查多重背包的二进制优化方法。

输入样例

输出样例：

由数学归纳法：
每一个二进制的组合2^i可以凑出∑1~i中所有的数，所以{1.2,3…k}可以凑出 1 ~2 ^ (k+1) -1里的全部的数。可以通过s-=2 ^ k的方法判断最后一位k，当s<2 ^k时，最后剩下的s就是离拼出最终答案的距离，最后把剩下的s个数再打包一次即可。
在这里插入图片描述
二进制优化就是把第三重循环的时间从 n 优化到log(n)。
这样就相当于把k个物品打包起来枚举，这样大大减少了枚举次数，相当于01背包：

#include <algorithm>
#include <iostream>

using namespace std;

const int N = 12010, M = 2010;

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

int main() 
{
    cin >> n >> m;

    int cnt = 0;
    for (int i = 1; i <= n; i++) 
    {
        int a, b, s;
        cin >> a >> b >> s;
        int k = 1;//用2^n 枚举每一个组合
        while (k <= s) 
        {
            cnt++;//保存每一个物品的价值和体积
            v[cnt] = a * k;//打包每一个组的体积
            w[cnt] = b * k;//打包每一个组的价值
            s -= k;//依次减掉能总体积范围内可以拼出的数
            k *= 2;//用二进制依次枚举每一个打包组合
        }
        if (s > 0) //最后剩下的那个常数c
        {
            cnt++;
            v[cnt] = a * s;
            w[cnt] = b * s;
        }
    }

    n = cnt;//做一遍01 背包

    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 的背包。

每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 vij，价值是 wij，其中 i 是组号，j 是组内编号。

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

输出最大价值。

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

接下来有 N 组数据：

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

数据范围
0<N,V≤100
0<Si≤100
0<vij,wij≤100
输入样例

输出样例：

在这里插入图片描述
思路有点像01背包，这个是每一类选一个物品，01是每一件物品只能选一件。所以前者 i 表示种类，后者 i 表示第几件物品。从一类里选出一个物品就要多一层循环，但本质上一样。

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

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 -- )//用到更新前一维状态用倒序-01
            for (int k = 0; k < s[i]; k ++ )//枚举这一类的每一件
                if (v[i][k] <= j)//找最大值
                    f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);

    cout << f[m] << endl;

    return 0;
}

分组背包求更新路径：机器分配

有依赖的背包问题

分组背包的方案表示——二进制枚举金明的预算方案
分组背包的体积表示——树形dp 有依赖的背包问题（分享acwing大佬的打卡题解，非常详细了）

背包问题求方案数

感觉就是一道题

买书
 数字组合
也包括DP里面的整数划分
货币系统
在这里插入图片描述
离散化+背包求方案数 Contest Setting
(转自一位csdn大佬的代码)

完全背包求方案数：

#include <algorithm>
#include<cstring>
#include <iostream>
using namespace std;
const int mod = 1e6 + 7;
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>>s[i];
    }  
    memset(f,0,sizeof f); 
    for(int i =0;i<=n;i++) f[i][0] =1;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            for(int k = 0 ; k <= s[i]&&k<=j;k++)
            {
                f[i][j] = (f[i][j] + f[i-1][j-k])%mod; 
            }
        }
    }
    cout << f[n][m] << endl;
    return 0;
}

背包问题求具体方案

本题要与机器分配做区分。

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

第 i 件物品的体积是 vi，价值是 wi。

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

输出 字典序最小的方案。这里的字典序是指：所选物品的编号所构成的序列。物品的编号范围是 1…N。

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

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

输出格式
输出一行，包含若干个用空格隔开的整数，表示最优解中所选物品的编号序列，且该编号序列的字典序最小。

物品编号范围是 1…N。

数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例

输出样例：

1 4

字典序问题大多数都是在算法中加入贪心策略，比如在更新最短路时如果有相同路径，找标号小的去更新。这道题也是一样，与机器分配的区别也在这里。我们需要用倒序dp的方式去存求f[i][j]。这里的f[i][j]的含义也转变成了在i ~ n 个物品里选，体积不超过 j 的最大价值，而不再是在1 ~ i 个物品中选。
原因很简单，如果最终我们求出了正序的f[n][m]，我们无法用贪心去求字典序：
在这里插入图片描述
就像上图描述的，选不选“8”这个编号的物品，我们都不知道两个序列谁的字典序更小。但如果我们的序列是从前往后推，那么每一步只需要贪较小序号的物品，那么最优解一定是字典序最小。

#include <iostream>

using namespace std;

const int N = 1010;

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

int main() 
{
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> v[i] >> w[i];

    for (int i = n; i >= 1; i--)//倒序dp解决字典序问题
        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]);
        }

    int j = m;//正序推路径，保证字典序最小
    for (int i = 1; i <= n; i++)//如果可以选第 i 件物品就必须选，因为选与不选相等时选i满足字典序
        if (j >= v[i] && f[i][j] == f[i + 1][j - v[i]] + w[i]) //如果选 i 的价值大，那更应该选 i
        {
            cout << i << ' ';//选 i 则输出 路径 ，不选跳过该步
            j -= v[i];
        }

    return 0;
}

背包问题的初始化

二维费用背包和一维费用背包是一样的。只需要弄清楚花费与状态表示的关系就可以了。
合法：对于一个状态的描述，我们必须弄清楚它是不是合法的，对于合法的方案，它一定是被赋予初始值或者是会被更新的。对于不合法的方案，我们一定让它不被更新到。举个例子，就比如我们求最大值，如果不合法就给它赋值负无穷，如果不合法求最小值就给它正无穷。比如完全背包中 i 表示决策第 i 件物品， j 表示体积恰好是 j ，f[i][j]表示最大价值，因此f[0][j]表示从前 i 件物品里选，选出体积恰好为 j 的最大价值，但是我们发现如果不选物品，它不可能体积恰好是 j ，因此我们把f[0][i]-i∈1~n都赋值为负无穷，其目的就是在去max中让它永远不被更新掉，而f[0][0]表示选0个物品体积为0的最大价值，这个表示是合法的，所以f[0][0]=0。真*完全背包写法：
在这里插入图片描述
上述例子说明合法性质的同时解释了花费恰好为 j 的时候，合法与不合法的含义,那么就以最大值继续扩展合法与不合法的问题。

如果体积恰好为 j ，j-v[i]需要>=0。因为不存在一个选 i 件物品体积恰好为负数——不合法。
如果体积至少为 j ，j-v[i]可以<=0。因为如果f[i][j]表示决策第 i 件物品，体积至少为 j 的最大值,此时f[0][0]代表选0件物品，体积至少为0的最大值，则f[0][0]=0。f[0][-3]表示选0个物品，体积至少为-3的最大值，这个至少为-3，j可以等于-2，-1，0，1…正无穷。但是因为选择了0个物品，体积只有可能是0，所以f[0][负数]合法且与f[0][0]等价，因此j - v[i]可以<0，依然合法。与之相对的是f[0][正数]，选0个物品，至少体积为 j ，显然不可能，所以此时f[0][i]-i∈1~n皆不合法。
如果体积最多为 j，j-v[i]需要>=0，因为f[0][0]表示选0件物品，体积至少为0的最大值, f[0][负数]表示选0个物品，体积最多是一个负数，j 的取值范围是负无穷到这个负数，然而选0个物品的体积只能是0，上述情况不包括f[0][0]，所以不存在选0个物品体积最多是负数的情况——不合法。与之相对，对于一个f[0][正数]，它表示的是选0个物品，体积最多是 j 的情况，那么 j 的取值范围是负无穷到 j，包括0——合法，同时又因为0个物品体积只能为0，所以f[0][正数]合法且与f[0][0]等价。
结论：

关于初始化问题，举一道例题潜水员
大体上就是二维费用背包，两个至少类型的花费，求01背包最小值，这道题巧妙的运用了上述初始化有关问题。

#include <cstring>
#include <iostream>
const int N = 1010;
using namespace std;
int v1[N], v2[N], w[N];
int n, m;
int f[N][N];
int main() 
{
    int V1, V2;
    cin >> V1 >> V2;
    cin >> n;
    for (int i = 1; i <= n; i++) 
    {
        cin >> v1[i] >> v2[i] >> w[i];
    }
    //进入循环之前i这一维是0，初始化的是i=0这一维
    memset(f, 0x3f, sizeof f);//至少花费类型大于0的部分均不合法
    //展开二维等价于f[0][j][k]，j∈1.....k∈1.....时都不合法
    f[0][0] = 0;//除f[0][0]外负数也合法，循环的时候把下标等价到0即可。
    for (int i = 1; i <= n; i++) 
    {
        for (int j = V1; j >= 0; j--) //循环到0即可，因为不在乎j-v[i]的正负
        {
            for (int k = V2; k >= 0; k--) 
            {
                f[j][k] =min(f[j][k], f[max(0, j-v1[i])][max(0, k-v2[i])] + w[i]);
            }//因为这个两个花费是相对独立的。
             //所以这个等价于0，一定是每一个花费分开等价于0，f[-1][3]等价于f[0][3]不等价于f[0][0]。
        }
    }
    cout << f[V1][V2] << endl;
    return 0;
}