背包问题

背包问题是线性dp的一种特殊模型 其主要问题分为以下几种

1.01背包问题

对于每种物品的状态只有拿或者不拿两种状态

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 i 件物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

#include <bits/stdc++.h>

using namespace std;

const int N = 1010;
/*
其中i表示选择物品个数 j表示容量 dp[i][j]表示当前i个物品容量为j的最大价值
*/
int dp[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];

    dp[0][0] = 0;

    ///i表示选择物品个数 j表示容量
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            dp[i][j] = dp[i-1][j];///不拿这件物品

            if(j >= v[i])///如果体积允许
                dp[i][j] = max(dp[i][j],dp[i-1][j-v[i]]+w[i]);///从i-1的状态转移 进行相应更新
        }
    }

    int res = 0;

    for(int i=0;i<=m;i++)///取最大值
        res = max(res,dp[n][i]);

    cout << res  << '\n';
    return 0;
}

而我们可以发现 当前状态总是从上一个状态转移过来 可以省去i的维度

#include <bits/stdc++.h>

using namespace std;

const int N = 1005;

int v[N],w[N];
int dp[N];

int main()
{
    int n,m;

    cin >> m >> n;

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

    ///i是物品数 j是体积容量
    for(int i = 1; i <= n; i ++)
    {
        for(int j = m; j >= v[i] ; j --)///注意这边是逆序遍历
        {
///           dp[i][j] = dp[i-1][j];
///            if(j >= v[i])
///                dp[i][j] = max(dp[i-1][j],dp[i-1][j-v[i]]+w[i]);
            ///  逆序遍历保证后者是 i-1 的状态由于v[i]>0 j-v[i]一定>0 一定没有被算过 
            ///  所以当前状态一定不包括i的状态
            dp[j] = max(dp[j],dp[j-v[i]]+w[i]);
        }
    }

    /// 求恰好体积为m的价值时 将dp[0] = 0 其余赋值成-INF
    cout << dp[m] << '\n';

    return 0;
}

2.完全背包

相对于01背包 每个物品可以拿无限次 即 0~无穷大

在01背包中 逆序遍历是保证更新这轮的状态时用的上一轮状态的基础 然而完全背包可以取任意次 不用强求上一轮的状态 也就是这一轮用过的东西 后面可以继续用

#include <bits/stdc++.h>

using namespace std;

const int N = 1005;

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

int dp[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 ++)
        {
            dp[j] = max(dp[j],dp[j-v[i]]+w[i]);
        }
    }

    cout << dp[m] << '\n';

    return 0;
}

3.多重背包

相对于01背包 每件物品有了物品数s 所以选取的范围在 【0,s】中 所以你选择的方法就有了 s+1种 在01背包的基础上 遍历每种情况即可

#include <bits/stdc++.h>

using namespace std;

const int N = 1005;

int n,m;

int dp[N];

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

    int v,w,s;

    for(int i=1;i<=n;i++)
    {
        cin >> v >> w >> s;

        for(int j = m;j >= 0;j --)
        {
            for(int k = 0;k <= s && v*k <= j ; k ++)///遍历s+1种情况 v*k <= j 判断体积是否超过
            {
                dp[j] = max(dp[j],dp[j-k*v]+k*w);
            }
        }
    }

    cout << dp[m] << '\n';

    return 0;
}

但是 这样的复杂度来到了 O(nms) 面对数据范围大时是不能接受的

这边有个基础知识 任意一个数n以内的数字都可以用 0~log2n的数来表示 举个例子
log7 = 2 所以7以内的数字都可以用 2的 0~2次方表示
1 = 2^0
2 = 2^1
5 = 2^0+2 2

所以这样可以使用二进制优化 将复杂度降至 O(nmlogs)

#include <bits/stdc++.h>

using namespace std;

int n,m;

struct node
{
    int v,w;
};

vector <node> vec;

int dp[2005];

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

    int v,w,s;

    for(int i=1;i<=n;i++)
    {
        cin >>  v >> w >> s;

        for(int k = 1;k <= s;k *= 2)///二进制拆分
        {
            s -= k;
            vec.push_back({v*k,w*k});///存入种类数中
        }

        if(s > 0)///如果有剩余
            vec.push_back({s*v,w*s});
    }


    for(auto i:vec)///遍历种类数组 跑01背包
        for(int j=m;j>=i.v;j--)
          dp[j] = max(dp[j],dp[j-i.v]+i.w);

    cout << dp[m] << '\n';
    
    return 0;
}

还有一种单调队列优化 不好意思 我不会

4.混合背包

第一类物品只能用1次（01背包）；
第二类物品可以用无限次（完全背包）；
第三类物品最多只能用 si次（多重背包）；
顾名思义 然后用将多重背包转换成01背包 就只有01背包和完全背包两种情况 分别处理即可

si=−1 表示第 i 种物品只能用1次；
si=0 表示第 i 种物品可以用无限次；
si>0 表示第 i 种物品可以使用 si 次；

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

const int N = 1005;

struct node
{
    int kind;
    int v,w;
};

vector <node> vec;

int dp[N];

int main()
{
    int n,m;

    cin >> n >> m;

    for(int i=0; i<n; i++)
    {
        int v,w,s;
        cin >> v >> w >> s;

        if(s < 0)
            vec.push_back({-1,v,w});
        else if(s == 0)
            vec.push_back({0,v,w});
        else
        {
            for(int k=1; k<=s; k*=2)
            {
                s -= k;
                vec.push_back({-1,v*k,w*k});
            }

            if(s > 0)
                vec.push_back({-1,v*s,w*s});
        }
    }

    for(auto it : vec)
    {
        if(it.kind == 0)
        {
            for(int j=it.v;j<=m;j++)
                dp[j] = max(dp[j],dp[j-it.v]+it.w);
        }
        else
        {
            for(int j=m;j>=it.v;j--)
            {
                dp[j] = max(dp[j],dp[j-it.v]+it.w);
            }
        }
    }

    cout << dp[m] << '\n';

    return 0;
}

5.二维费用的背包问题

多了一个限制条件那么也多了一个维度

有 N 件物品和一个容量是 V 的背包，背包能承受的最大重量是 M。

每件物品只能用一次。体积是 vi，重量是 mi，价值是 wi。

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

#include <iostream>

using namespace std;

const int N = 105;

int n,m,v;

int dp[N][N];

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

    for(int i=1;i<=n;i++)
    {
        int a,b,c;
        cin >> a >> b >> c;

        for(int j=v;j>=a;j--)///体积
        {
            for(int k=m;k>=b;k--)///重量
            {
                dp[j][k] = max(dp[j][k],dp[j-a][k-b]+c);
            }
        }
    }

    cout << dp[v][m] << '\n';

    return 0;
}

6.有依赖的背包问题

这种题目由于物品之间的依赖关系可构成一个二叉树 所以可以采用树状dp 但对于某些特殊情况 我们也可以采用将其转化成01背包解决

金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间金明自己专用的很宽敞的房间。更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过N元钱就行”。今天一早，金明就开始做预算了，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：

主件

附件

电脑

打印机，扫描仪

书柜

图书

书桌

台灯，文具

工作椅

无

如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有0个、1个或2个附件。附件不再有从属于自己的附件。金明想买的东西很多，肯定会超过妈妈限定的N元。于是，他把每件物品规定了一个重要度，分为5等：用整数1~5表示，第5等最重要。他还从因特网上查到了每件物品的价格（都是10元的整数倍）。他希望在不超过N元（可以等于N元）的前提下，使每件物品的价格与重要度的乘积的总和最大。

设第j件物品的价格为v[j]，重要度为w[j]，共选中了k件物品，编号依次为j1，j2，……，jk，则所求的总和为：

v[j1]*w[j1]+v[j2]*w[j2]+ …+v[jk]w[jk]。（其中为乘号）

请你帮助金明设计一个满足要求的购物单。

这题主件是固定的 附件的数量也是比较少 可以采用结构体来封装信息 跑01背包即可
之后大力讨论 只选主件 选主件+附件1 选主件+附件2 选主件+附件1+附件2 这四种情况

#include <bits/stdc++.h>

using namespace std;

int dp[32005];
int n,m;

struct node
{
    int v1,w1,v2,w2,v3,w3;
}a[1005];

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

    for(int i = 1;i <= n;i ++)
    {
        int v,p,q;

        cin >> v >> p >> q;

        if(!q)
            a[i].v1 = v,a[i].w1 = p*v;
        else if(!a[q].v2)
            a[q].v2 = v,a[q].w2 = p*v;
        else
            a[q].v3 = v,a[q].w3 = p*v;
    }


    for(int i = 1;i <= n;i ++)
    {
        for(int j = m;j >= 0;j --)
        {
            if(j >= a[i].v1)
                dp[j] = max(dp[j], dp[j - a[i].v1] + a[i].w1);
            if(j >= a[i].v1+a[i].v2)
                dp[j] = max(dp[j], dp[j - a[i].v1 - a[i].v2] + a[i].w1 + a[i].w2);
            if(j >= a[i].v1+a[i].v3)
                dp[j] = max(dp[j], dp[j - a[i].v1 - a[i].v3] + a[i].w1 + a[i].w3);
            if(j >= a[i].v1 + a[i].v2 + a[i].v3)
                dp[j] = max(dp[j], dp[j - a[i].v1 - a[i].v2 - a[i].v3] + a[i].w1 + a[i].w2 + a[i].w3);
        }
    }

    cout << dp[m] << '\n';

    return 0;
}

7.分组背包问题

大力讨论每组全部情况即可

有 NN 组物品和一个容量是 VV 的背包。

每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 vijvij，价值是 wijwij，其中 ii 是组号，jj 是组内编号。

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

输出最大价值。

输入格式

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

接下来有 NN 组数据：

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

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

数据范围

0<N,V≤1000<N,V≤100
0<Si≤1000<Si≤100
0<vij,wij≤100

#include <iostream>

using namespace std;

const int N = 105;

int n,m;

int dp[N];
int v[N],w[N];

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

    int s;

    for(int i=0;i<n;i++)
    {
        cin >> s;

        for(int j=0;j<s;j++)
            cin >> v[j] >> w[j];

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


    cout << dp[m]<< '\n';

    return 0;
}

8.背包问题求方案数

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

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

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

输出 最优选法的方案数。注意答案可能很大，请输出答案模 109+7109+7 的结果。

输入格式

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

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

输出格式

输出一个整数，表示 方案数 模 1e9+7 的结果。

数据范围

0<N,V≤10000<N,V≤1000
0<vi,wi≤1000

在跑01背包的过程中 同时维护一个 ans数组 来保存方案数

#include <iostream>

using namespace std;

const int N = 1005;
const int mod = 1e9+7,INF = 0x3f3f3f3f;

int n,m;
int dp[N],ans[N];
int v[N],w[N];

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

/// 初始化方式
    ans[0] = 1;
/// dp[0] = 0
    for(int i = 1;i <= m ; i ++)
        dp[i] = -INF;

    for(int i = 0;i < n ; i ++)
    {
        int v,w;

        cin >> v >> w;

        for(int j = m; j >= v; j --)
        {
            int temp = max(dp[j],dp[j-v]+w);
            int s = 0;

            if(temp == dp[j]) /// 如果和之前状态相同的话 就加上对应状态的方案数
                s += ans[j];
            if(temp == dp[j-v]+w)
                s += ans[j-v];

            s %= mod;

            dp[j] = temp; ///更新
            ans[j] = s;
        }
    }

    int maxx = 0;

    for(int i = 0 ;i <= m ; i ++) ///找到最大价值
        maxx = max(maxx,dp[i]);


    int res = 0;
    for(int i = 0; i <= m ; i++)///累计能实现最大价值的方案数
    {
        if(maxx == dp[i])
        {
            res += ans[i];

            res %= mod;
        }
    }

    cout << res << '\n';
    return 0;
}

上面的初始化方式为使用 dp[0] = 0 其余均赋值成-INF 这也是求体积恰好为m的最大价值 ans[0] = 1 其余均是0
还有一种将ans全部赋值为1 则 ans[m] 就是答案

#include <iostream>

using namespace std;

const int N = 1005;
const int mod = 1e9+7,INF = 0x3f3f3f3f;

int n,m;
int dp[N],ans[N];
int v[N],w[N];

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

    fill(ans,ans+N,1);

    for(int i = 0;i < n ; i ++)
    {
        int v,w;

        cin >> v >> w;

        for(int j = m; j >= v; j --)
        {
            int temp = max(dp[j],dp[j-v]+w);
            int s = 0;

            if(temp == dp[j])
                s += ans[j];
            if(temp == dp[j-v]+w)
                s += ans[j-v];

            s %= mod;

            dp[j] = temp;
            ans[j] = s;
        }
    }

    cout << ans[m]%mod << '\n';
    
    return 0;
}

9.背包问题求方案

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

第 ii 件物品的体积是 vivi，价值是 wiwi。

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

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

输入格式

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

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

输出格式

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

物品编号范围是 1…N1…N。

数据范围

0<N,V≤10000<N,V≤1000
0<vi,wi≤1000

菜鸡表示这我不太会

#include <iostream>

using namespace std;

const int N = 1005;

int n,m;
int v[N],w[N];
int dp[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 --)///从n开始选择
    {
        for(int j = 0;j <= m;j ++)
        {
            dp[i][j] = dp[i+1][j];

            if(j >= v[i])
                dp[i][j] = max(dp[i][j],dp[i+1][j-v[i]]+w[i]);
        }
    }

    int x = m;

    for(int i = 1; i <= n; i ++)
    {
        if(x >= v[i] && dp[i][x] == dp[i+1][x-v[i]]+w[i])
        {
            cout << i << ' ';
            x -= v[i];
        }
    }

    return 0;
}

感谢各位大佬看菜鸡我的博客 有疑惑或者问题还望指出 ~