背包问题 模版体形汇总

最新推荐文章于 2022-06-17 22:12:18 发布
最新推荐文章于 2022-06-17 22:12:18 发布
阅读量247 收藏 1
点赞数 3
分类专栏： # 背包九讲
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34261446/article/details/108673132
版权

题目总链接

01 背包问题

分析

  • 题意

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 1 件物品的体积是 vi, 价值是 Wi
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行两个整数，N, V, 用空格隔开，分别表示物品数量和背包容积。
接下来有 N 行，每行两个整数 Vi, Wi, 用空格隔开，分别表示第 i 件物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围 0 <N, VS 1000
0 < Vi, Wi S 1000
输入样例
45
12
24
34
45

  • 分析：注意 dp 的方向和 dp 时候 for 循环的范围

代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <bitset>
#include <vector>
#include <stack>
#include <map>
/* #include <unordered_map> */
#include <sstream>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define db double
#define ll long long
#define ull unsigned long long
#define Pir pair<int, int>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
using namespace std;

const int mxn = 1e5;

int dp[mxn];

int main()
{
    /* fre(); */
    int n, m;
    sc("%d %d", &n, &m);

    int v, w;
    for_(i, 1, n)
    {
        sc("%d %d", &v, &w);
        rep_(j, m, v)
            dp[j] = max(dp[j], dp[j - v] + w);
    }

    pr("%d\n", dp[m]);

    return 0;
}

完全背包问题

分析

  • 题意

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 i 件物品的体积是 Vi, 价值是 Wi
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行两个整数，N, V, 用空格隔开，分别表示物品数量和背包容积。
接下来有 N 行，每行两个整数 vi, Wi, 用空格隔开，分别表示第 i 件物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围 0<N.V<10000<Vi, WiS 1000
输入样例
4 5
1 2
24
34
45
输出样例：8

  • 分析
  1. 从后往前往 for 循环 dp，这样可以重复利用 当前正在讨论的物品

代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <bitset>
#include <vector>
#include <stack>
#include <map>
/* #include <unordered_map> */
#include <sstream>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define db double
#define ll long long
#define ull unsigned long long
#define Pir pair<int, int>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
using namespace std;

const int mxn = 1e5;

int dp[mxn];

int main()
{
    /* fre(); */
    int n, m;
    sc("%d %d", &n, &m);

    int v, w;
    for_(i, 1, n)
    {
        sc("%d %d", &v, &w);
        for_(j, v, m)
            dp[j] = max(dp[j], dp[j - v] + w);
    }

    pr("%d\n", dp[m]);

    return 0;
}

多重背包问题 I

分析

  • 题意

有 N 种物品和一个容量是 V 的背包。
第 i 种物品最多有 s; 件，每件体积是 Vi, 价值是 Wi
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。
输入格式
第一行两个整数，N, V, 用空格隔开，分别表示物品种数和背包容积。
接下来有 N 行，每行三个整数 Vi, Wi, Si, 用空格隔开，分别表示第 1 种物品的体积、价值和数量
输出格式
输出一个整数，表示最大价值
数据范围 0<N, VS 100
0<Vi, W; si 100
输入样例
4 5
1 2 3
2 41
3 4 3
452
输出样例:
10

  • 分析

代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <bitset>
#include <vector>
#include <stack>
#include <map>
/* #include <unordered_map> */
#include <sstream>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define db double
#define ll long long
#define ull unsigned long long
#define Pir pair<int, int>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
using namespace std;

const int mxn = 1e5;
int dp[mxn];

int main()
{
    /* fre(); */
    int n, m;
    sc("%d %d", &n, &m);

    int v, w, s;
    for_(i, 1, n)
    {
        sc("%d %d %d", &v, &w, &s);
        for_(j, 1, s)
        {
            rep_(k, m, v)
                dp[k] = max(dp[k], dp[k - v] + w);
        }
    }

    pr("%d\n", dp[m]);

    return 0;
}

多重背包问题 II

分析

  • 题意

有 N 种物品和一个容量是 V 的背包。
第 i 种物品最多有 si 件，每件体积是 vi, 价值是 Wi
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。
输入格式
第一行两个整数，N, V, 用空格隔开，分别表示物品种数和背包容积。
接下来有 N 行，每行三个整数 Vi, Wi, Si, 用空格隔开，分别表示第 i 种物品的体积、价值和数量。
输出格式
输出一个整数，表示最大价值。
数据范围
ONS 10000<VS20000<Vi, Wi, si 2000
提示:
本题考查多重背包的二进制优化方法。
输入样例
45
123
241
343
45 2
输出样例:

  • 分析
  1. 利用二进制拆分的思想，任何一个数都可，拆分一些 2 的次方数的和（最后一个拆分剩下的数 可能不是 2 某个次方数）

代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <bitset>
#include <vector>
#include <stack>
#include <map>
/* #include <unordered_map> */
#include <sstream>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define db double
#define ll long long
#define ull unsigned long long
#define Pir pair<int, int>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
using namespace std;

const int mxn = 1e5;
int dp[mxn];

int n, m;
int v, w, s;
void sov(int t)
{
    rep_(j, m, v * t)
        dp[j] = max(dp[j], dp[j - v * t] + t * w);
}

int main()
{
    /* fre(); */
    sc("%d %d", &n, &m);

    for_(i, 1, n)
    {
        sc("%d %d %d", &v, &w, &s);

        int t = 1;
        while(s >= t)
        {
            s -= t;
            sov(t);
            t <<= 1;
        }

        if(s) sov(s);
    }

    pr("%d\n", dp[m]);

    return 0;
}

多重背包问题 III

分析

  • 题意

有 N 种物品和一个容量是 V 的背包。
第 i 种物品最多有 si 件，每件体积是 Vi, 价值是 Wis
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。
输入格式
第一行两个整数，N, V (0 <N< 1000,0 <V< 20000), 用空格隔开，分别表示物品种数和背包容积。
接下来有 N 行，每行三个整数 Vi, Wi, Si, 用空格隔开，分别表示第 i 种物品的体积、价值和数量。
输出格式
输出一个整数，表示最大价值。
数据范围 0<N<1000
0<V<200000<Vi, Wi, Si S 20000
提示
本题考查多重背包的单调队列优化方法。
输入样例
45
123
241
343
4 5 2
输出样例:

  • 分析
  1. 利用单调队列来维护一个极大值队列

代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <bitset>
#include <vector>
#include <stack>
#include <map>
/* #include <unordered_map> */
#include <sstream>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define db double
#define ll long long
#define ull unsigned long long
#define Pir pair<int, int>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
using namespace std;

const int mxn = 1e5;
int dp[2][mxn];
int q[mxn];             //注意这里 我们维护的是一个 极大值的单调队列, 
#define cal(x, i) dp[x ^ 1][q[i]] + (k - q[i]) / v * w

int main()
{
    /* fre(); */
    int n, m;
    sc("%d %d", &n, &m);

    int v, w, s;
    
    int x = 0;          //滚动数组,用的标号
    for_(i, 1, n)
    {
        sc("%d %d %d", &v, &w, &s);

        x ^= 1;
        for_(j, 0, v - 1)           //枚举余数j，j + x * v（就能表示出所有的以j为余数的数）, 这样当我们依次枚举了 v的所有余数j之后，就能表示出所有的可能的数（指的是：在（1～s）*v之间的数）了
        {
            int hh = 0, tt = -1;
            for(int k = j; k <= m; k += v)          //枚举出来 可能的数
            {
                while(tt >= hh && (k - q[hh]) / v > s) hh ++;       //排除太远，越界的

                if(tt >= hh) dp[x][k] = max(dp[x ^ 1][k], cal(x, hh));

                while(tt >= hh && dp[x ^ 1][q[hh]] - (q[hh] - j) / v * w <= dp[x ^ 1][k] - (k - j) / v * w) tt --;      //消除距离产生的影响

                q[++ tt] = k;
            }
        }
    }

    pr("%d\n", dp[x][m]);

    return 0;
}

混合背包问题

分析

  • 题意
    有 N 种物品和一个容量是 V 的背包。
    物品一共有三类:
    ・第一类物品只能用 1 次 (01 背包) ;
    , 第二类物品可以用无限次 (完全背包) ;
    , 第三类物品最多只能用 si 次 (多重背包) ;
    每种体积是 Vi, 价值是 Wi
    求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
    输出最大价值。
    输入格式
    第一行两个整数，N,V, 用空格隔开，分别表示物品种数和背包容积。
    接下来有 N 行，每行三个整数 vi, Wi, Si, 用空格隔开，分别表示第 i 种物品的体积、价值和数量。
    .Si=-1 表示第 i 种物品只能用 1 次；
    .Si=0 表示第 i 种物品可以用无限次.Si>0 表示第 i 种物品可以使用 si 次；
    输出格式
    输出一个整数，表示最大价值。
    数据范围 0<N, VS 1000
    0<Vi, Wi S 1000
    -1 SSi S 1000
    输入样例
    输入样例
    4 5
    1 2 -1
    2 4 1
    340
    4 5 2
    输出样例:в
  • 分析

代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <bitset>
#include <vector>
#include <stack>
#include <map>
/* #include <unordered_map> */
#include <sstream>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define db double
#define ll long long
#define ull unsigned long long
#define Pir pair<int, int>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
using namespace std;

const int mxn = 1e5;
int dp[mxn];
int n, m;
int v, w, s;
void sov(int t)
{
    rep_(j, m, t * v) dp[j] = max(dp[j], dp[j - t * v] + t * w);
}

int main()
{
    /* fre(); */

    sc("%d %d", &n, &m);
    for_(i, 1, n)
    {
        sc("%d %d %d", &v, &w, &s);
        if(s == 0)
        {
            for_(j, v, m) dp[j] = max(dp[j], dp[j - v] + w);
        }
        else
        {
            if(s == -1) s = 1;

            int t = 1;
            while(s >= t)           //对01背包进行、对多重背包 进行二进制拆分
            {
                s -= t;
                sov(t);
                t <<= 1;
            }

            if(s) sov(s);
        }
    }

    pr("%d\n", dp[m]);

    return 0;
}

二维费用的背包问题

分析

  • 题意

有 N 件物品和一个容量是 V 的背包，背包能承受的最大量量是 M。
每件物品只能用一次。体积是 Vi, 重量是 mi, 价值是 Wi
求解将哪些物品装入背包，可使物品总体积不超过背包容量，总重量不超过背包可承受的最大重量，且价值总和最大。
输出最大价值。
输入格式
第一行两个整数，N , V,M, 用空格隔开，分别表示物品件数、背包容积和背包可承受的最大重量。
接下来有 N 行，每行三个整数 Vi, mi;, Wi, 用空格隔开，分别表示第 i 件物品的体积、重量和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N S 1000 0<V,M S100 0<Vimi< 100 0<WiS1000
输入样例
456
123
244
345
15 6
输出样例:

  • 分析

代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <bitset>
#include <vector>
#include <stack>
#include <map>
/* #include <unordered_map> */
#include <sstream>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define db double
#define ll long long
#define ull unsigned long long
#define Pir pair<int, int>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
using namespace std;

const int mxn = 1e3 + 5;
int dp[mxn][mxn];
int N, M, V;
int v, m, w;


int main()
{
    /* fre(); */
    sc("%d %d %d", &N, &V, &M);
    for_(i, 1, N)
    {
        sc("%d %d %d", &v, &m, &w);
        rep_(j, V, v)
        {
            rep_(k, M, m)
                dp[j][k] = max(dp[j][k], dp[j - v][k - m] + w);
        }
    }

    pr("%d\n", dp[V][M]);

    return 0;
}

分组背包问题

分析

  • 题意
    有 N 组物品和一个容量是 V 的背包。
    每组物品有若干个，同一组内的物品最多只能选一个。
    每件物品的体积是 Vj, 价值是 Wi, 其中 i 是组号，j 是组内编号。
    求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。
    输出最大价值。
    输入格式
    第一行有两个整数 N, V, 用空格隔开，分别表示物品组数和背包容量。
    接下来有 N 组数据
    ・每组数据第一行有一个整数 Si, 表示第 i 个物品组的物品数量；
    ・每组数据接下来有 Si 行，每行有两个整数 vj, wj, 用空格隔开，分别表示第 i 个物品组的第 j 个物品的体积和价值；
    输出格式
    输出一个整数，表示最大价值。
    数据范围
    <N, Vs 1000<Si<100<Vij, Wij S 100
    输入样例
    35
    2
    12
    :
  • 分析

代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <bitset>
#include <vector>
#include <stack>
#include <map>
/* #include <unordered_map> */
#include <sstream>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define db double
#define ll long long
#define ull unsigned long long
#define Pir pair<int, int>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
using namespace std;

const int mxn = 105;
int n, m;
int dp[mxn];
int v[mxn][mxn], w[mxn][mxn], s[mxn];

int main()
{
    /* fre(); */
    sc("%d %d", &n, &m);
    for_(i, 1, n)
    {
        sd(s[i]);
        for_(j, 1, s[i])
            sc("%d %d", &v[i][j], &w[i][j]);
    }

    for_(i, 1, n)
        rep_(j, m, 0)
        {
            for_(k, 1, s[i])
                if(j >= v[i][k]) dp[j] = max(dp[j], dp[j - v[i][k]] + w[i][k]);
        }

    pr("%d\n", dp[m]);


    return 0;
}

有依赖的背包问题

分析

  • 题意
    有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
    第 i 件物品的体积是 vi, 价值是 Wi
    求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
    输出最优选法的方案数。注意答案可能很大，请输出答案模 109+7 的结果。
    输入格式
    第一行两个整数，N, V, 用空格隔开，分别表示物品数量和背包容积
    接下来有 N 行，每行两个整数 Vi, Wi, 用空格隔开，分别表示第 i 件物品的体积和价值。
    输出格式
    输出一个整数，表示方案数模 109+7 的结果
    数据范围 0<N, VS 1000
    0<Vi, Wi s 1000
    输入样例
    45
    12
    2 4
    34
    4 6
    输出样例：2
  • 分析

代码

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 110;
int n,m;
int h[N],e[N],ne[N],idx;
/*h数组是邻接表的头它的下表是当前节点的标号，值是当前结点第一条边的编号（其实是最后加入的那一条边），e数组是边的集合，它的下标是当前边的编号，数值是当前边的终点；
  ne是nextedge，如果ne是-1表示当前结点没有下一条边，ne的下标是当前边的编号，数值是当前结点的下一条边的编号，idx用于保存每一条边的上一条边的编号。
  这样我们就知道了当前结点的第一条边是几，这个边的终点是那个结点，该节点的下一条边编号是几，那么邻接表就完成了
  */ 
int v[N],w[N],f[N][N]; 

void add(int a,int b){
    e[idx] = b,ne[idx] = h[a],h[a] = idx++;//该方法同于向有向图中加入一条边，这条边的起点是a，终点是b，加入的这条边编号为idx 
}

void dfs(int u){
    for(int i = h[u];i!=-1;i = ne[i]){//对当前结点的边进行遍历 
        int son = e[i];//e数组的值是当前边的终点，即儿子结点 
        dfs(son); 
        for(int j = m-v[u];j>=0;j--){
            //在做这一题之前，我们首先应该明白，我们正在讨论的 树中的某个节点x为根的整个子树，就相当于一个 分组背包问题，所以树中有多少个节点就是多少个分组背包问题
            //遍历背包的容积，因为我们是要遍历其子节点，所以当前节点我们是默认选择的。
            //这个时候当前结点我们看成是分组背包中的一个组，"当前正在讨论的子节点son" 的每一种选择我们都看作是组内一种物品(这里的”每一种son的每一种选择“指的是 ”每种选择造成的dp[son][1~m]最优值“);
            //从大到小遍历：（举个例子来说为什么这样？，在01背包中的第二从for循环 “从大到小遍历”， 是为了 把dp[][]的二维空间优化成一位空间dp[]; 而在这一题中表面上看：f[][] 是一个二维数组，但是我们要注意到它的第一纬度的“下标”只是起到表示这个子树是第几个分组背包问题）
            //我们每一次都默认选择当前结点，因为到最后根节点是必选的。 
            for(int k = 0;k<=j;k++){//去遍历子节点的组合 
                f[u][j] = max(f[u][j],f[u][j-k]+f[son][k]);
            }
        }
    }
    //加上刚刚默认选择的父节点价值
    for(int i = m;i>=v[u];i--){
        f[u][i] = f[u][i-v[u]]+w[u];
    }
    //因为我们是从叶子结点开始往上做，所以如果背包容积不如当前物品的体积大，那就不能选择当前结点及其子节点，因此赋值为零 
    for(int i = 0;i<v[u];i++){
        f[u][i] = 0;
    }
}

int main(){
    memset(h,-1,sizeof h);
    cin>>n>>m;
    int root;
    for(int i = 1;i<=n;i++){
        int p;
        cin>>v[i]>>w[i]>>p;
        if(p==-1){
            root = i;
        }else{
            add(p,i);//如果不是根节点就加入邻接表,其中p是该节点的父节点，i是当前是第几个节点
        }
    }
    dfs(root);
    cout<<f[root][m]<<endl;
    return 0;
}

背包问题求最优解方案数

分析

  • 题意

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 1 件物品的体积是 Vi, 价值是 Wi.
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最优选法的方案数。注意答案可能很大，请输出答案模 109+7 的结果。
输入格式
第一行两个整数，N, V, 用空格隔开，分别表示物品数量和背包容积。
接下来有 N 行，每行两个整数 Vi, Wi, 用空格隔开，分别表示第 i 件物品的体积和价值。
输出格式
输出一个整数，表示方案数模 109+7 的结果。
数据范围
0<N, Vs 1000
0<Vi, Wi S 1000
输入样例
4 5
1 2
24
34
46
输出样例：

  • 分析

代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <bitset>
#include <vector>
#include <stack>
#include <map>
/* #include <unordered_map> */
#include <sstream>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define db double
#define ll long long
#define ull unsigned long long
#define Pir pair<int, int>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
using namespace std;

const int mxn = 1005;
int dp[mxn];
int cnt[mxn];

int main()
{
    /* fre(); */
    int n, m;
    int v, w;
    sc("%d %d", &n, &m);

    for_(i, 0, m) cnt[i] = 1;           //注意这里为什么要 cnt 中的元素全部初始化为1，因为最终方案结果不必填满背包

    for_(i, 1, n)
    {
        sc("%d %d", &v, &w);
        rep_(j, m, v)
        {
            int val = dp[j - v] + w;
            if(val > dp[j])
            {
                dp[j] = val;
                cnt[j] = cnt[j - v];
            }
            else if(val == dp[j])
            {
                cnt[j] += cnt[j - v];
                cnt[j] %= mod;
            }
        }
    }
    pr("%d\n", cnt[m]);


    return 0;
}

背包问题求具体方案 / 记录最优解物品选择的路径

分析

  • 题意

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 1 件物品的体积是 vi, 价值是 Wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出字典序最小的方案。这里的字典序是指：所选物品的编号所构成的序列。物品的编号范围是 1… N.
输入格式
第一行两个整数，N, V, 用空格隔开，分别表示物品数量和背包容积。
接下来有 N 行，每行两个整数 Vi, Wi, 用空格隔开，分别表示第 i 件物品的体积和价值。
输出格式
输出一行，包含若干个用空格隔开的整数，表示最优解中所选物品的编号序列，且该编号序列的字典序最小。
物品编号范围是 1… N。
数据范围
0<N, V< 1000
0<Vi, Wi S1000
输入样例 4
输出样例:

  • 分析

代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <bitset>
#include <vector>
#include <stack>
#include <map>
/* #include <unordered_map> */
#include <sstream>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define db double
#define ll long long
#define ull unsigned long long
#define Pir pair<int, int>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
using namespace std;

const int mxn = 1005;
int dp[mxn][mxn];
int n, m;
int v[mxn], w[mxn];

int main()
{
    /* fre(); */
    sc("%d %d", &n, &m);
    for_(i, 1, n)
        sc("%d %d", &v[i], &w[i]);

    rep_(i, n, 1)
    {
        for_(j, 0, m)
        {

            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 sum_v = m;
    for_(i, 1, n)
    {
        //对最后一个物品进行特判
        if(i == n && sum_v >= v[i])
        {
            pr("%d ", i);
            break;
        }

        if(sum_v <= 0) break;

        if(sum_v >= v[i] && dp[i][sum_v] == dp[i + 1][sum_v - v[i]] + w[i])
        {
            sum_v -= v[i];
            pr("%d ", i);
        }
    }

    return 0;
}

背包问题第k优解

题目链接

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <bitset>
#include <vector>
#include <stack>
#include <map>
/* #include <unordered_map> */
#include <sstream>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define db double
#define ll long long
#define ull unsigned long long
#define Pir pair<int, int>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
using namespace std;

const int mxn = 1010;
int f[mxn][mxn];
int n, m, k;
int v[mxn], w[mxn];
int a[mxn], b[mxn];

int main()
{
    /* fre(); */
    int T; sd(T);   
    while(T --)
    {
        sc("%d %d %d", &n, &m, &k);

        for_(i, 1, n) sd(w[i]);
        for_(i, 1, n) sd(v[i]);

        memset(f, 0, sizeof f);

        for_(i, 1, n)
        {
            rep_(j, m, v[i])
            {
                for_(l, 1, k)           //处理两种情况的状态转移方程分别存储到a、b数组中
                {
                    a[l] = f[j][l];
                    b[l] = f[j - v[i]][l] + w[i];
                }

                a[k + 1] = b[k + 1] = -1;       //结束标志
                int x = 1, y = 1, z = 1;
                while((x <= k || y <= k) && z <= k)         //注意让求的第k大是不是严格第k大
                {
                    if(a[x] > b[y])
                    {
                        f[j][z] = a[x ++];
                    }
                    else
                    {
                        f[j][z] = b[y ++];
                    }
                    if(f[j][z] != f[j][z - 1]) z ++;        //非严格第k大 只有不想等 z 才++
                }
            }
        }

        pr("%d\n", f[m][k]);

    }




    return 0;
}
做一只大熊猫
关注
专栏目录
动态规划专题——背包问题
⚡
02-13 4万+
详解四种背包：01背包、完全背包、多重背包、分组背包。
背包九讲
缇欧的咪西
03-14 153
超级无敌蒟蒻和y总学习第二弹.jpg 01背包问题 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 ii 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 ...
动态规划 C++数据结构 01 背包问题
qq_44787993的博客
05-17 188
#include <iostream> using namespace std; struct Item{ int weight; int value; }; void KnapSack(Item items[],int N,int capacity){//N个物品，背包容量为capacity int ans[N][capacity+1]; for(int i=0;i<N;i++){ for(int j=0;j<capacity+1;j++) .
数据结构--01背包问题
huangyong000的专栏
06-01 475
0-1背包问题递归求解，主要在理解递归思想，从假设装满背包看起，判断把数组中最后一个物品装进去的价值和不装进去进行比较。 #include #define N 100 #define W 100 using namespace std; int w[N]; int v[N]; int x[N]; int package(int n,int m) { if(n==0||m==0)
贪心法 部分背包问题 结构体数组 FatMouse' Trade
?
10-21 405
FatMouse’ Trade题目：FatMouse prepared M pounds of cat food, ready to trade with the cats guarding the warehouse containing his favorite food, JavaBean. The warehouse has N rooms. The i-th room contains
算法学习：贪心求部分背包（使用结构体来求解）
zkyrjsxdm的博客
12-17 725
贪心求部分背包（结构体使用）前几天写的背包在按照单位质量价值进行排序的时候，得把质量和价值也一起排了，觉得那个方法笨笨哒，今天睡醒了午觉突然想起结构体应该能解决这个问题，正好也学学结构体~~然后新的代码就出炉啦~ 当当当~ /* 贪心解部分背包问题 用到结构体 */ #include<iostream> #define N 3 using namespace std; struct K
算法-动态规划- 背包问题- 背包问题模版（包含源程序）.rar
09-16
动态规划是一种强大的算法工具，常用于解决复杂的问题，如背包问题。背包问题是一个经典的优化问题，它涉及到在容量有限的背包中选择物品以最大化价值。在这个压缩包中，你将找到一个关于背包问题的模板，包括源程序...
背包问题.rar_matlab算法实现背包问题_价值背包算法_背包最大价值_背包问题_遗传算法 背包
07-15
《基于MATLAB的遗传算法在背包问题中的应用》 背包问题是一种典型的组合优化问题，广泛存在于资源分配、项目选择等领域。在本项目中，我们利用MATLAB强大的计算能力，结合遗传算法，对背包问题进行了有效的求解，以...
matlab程序（解决0-1背包问题）.zip_背包_背包算法 matlab_背包问题_遗传算法 背包_遗传算法背包
09-21
0-1背包问题是一种经典的组合优化问题，在计算机科学和运筹学中有着广泛的应用。它描述的是这样的场景：你有一组物品，每件物品都有一个重量和价值，你需要选择一部分物品放入容量有限的背包中，使得背包中的物品总...
9大背包问题详解9大背包问题详解
08-23
背包问题详解 背包问题是算法领域中经典的问题之一，属于动态规划的范畴。本资源摘要信息将对背包问题的九大变种进行详细解释，并对每种问题的解决思路、优化方法和算法进行阐述。 问题1：01背包问题 01背包问题...
背包问题
jschen10的专栏
06-03 731
[问题]:己知一个容量为weight的背包。现在要从n种物品中选取若干装入背包中，每种物品的重量为w(i) 、价值为p(i) 。定义一种可行的背包装载为：背包中物品的总重量不能超过背包的容量，并且一个物品要么全部选取，要么不选取。采取怎样的装包方案才会使装入背包的物品总效益值最大? 【输入】 weight n w（i） p（i） 【输出】 可行装载方案 （0代表不取，1代表取） 总
动态规划----0/1背包问题
weixin_34259159的博客
01-08 127
　　 　　 　　问题描述: 　　我们有n种物品，物品j的重量为wj，价格为vj。我们假定所有物品的重量和价格都是非负的。背包所能承受的最大重量为W。如果限定每种物品只能选择0个或1个，则问题称为0-1背包问题。[1] 　　解题思路： 　　　　最终的目标是在总重量不超过W的前提下，总价值最高。在总重量不操作Y的前提下，我们可以将前j种物品的总价值所能达到的最高值定义为value[j][Y]...
动态规划初步之背包问题（参考背包九讲+例题+详细分析+补充）
qq_37136305的博客
07-22 3714
1 01背包问题 1.1 题目 有N件物品和一个容量为V 的背包。放入第i件物品耗费的空间是Ci，得到 的价值是Wi。求解将哪些物品装入背包可使价值总和最大。 1.2 基本思路 这是最基础的背包问题，特点是：每种物品仅有一件，可以选择放或不 放。 用子问题定义状态：即F[i,v]表示前i件物品恰放入一个容量为v的背包可以 获得的最大价值。则其状态转移方程便是： F[i,v] = max{F[i...
背包问题全解析
jyc1020的博客
03-30 528
背包问题 阅读崔添翼老师《背包九讲》后，个人所作总结 目录 01背包 完全背包 多重背包 混合背包 二维费用背包 分组背包 有依赖的背包问题 泛化物品 背包问题目标的变化 01背包 题目描述：有N件物品和一个容量为V的背包。放入第i件物品耗费的费用是Ci，得到的价值是Wi。求解将哪些物品装入背包可使价值总和最大。 特点：每种物品只有一件，选择放或不放。 状态：F[i,v]表示前...
背包问题以及动态规划复习
chc960609的博客
07-23 421
背包问题(Knapsack problem)是一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。 我们有n种物品，物品j的重量为wj，价格为pj。 我们假定所有物品的重量和价格都是非负的。背包所能承受的最大重量为W。 如果限定每种物品只能选择0个或1个，则问题称为0-1背包问题[9]。 可以用公式表示为： 如果限定物品j最多只能选择bj个，则问题称为有界背包问题。 可以用公式表示为： ...
每组输入第一行是两个正整数N和M（0 ＜ N ＜= 30000,0 ＜ M ＜ 5000），分别代表学生的数目和操作的数目。
Jiangshang_jiu
06-17 5061
每组输入第一行是两个正整数N和M（0 < N
【动态规划】背包问题（01背包，完全背包，多重度背包）
Anterior_condyle的博客
07-15 2257
对于背包问题用文字很难描述清楚也很难理解，所以本篇仅描述基本框架，仅供学习参考！！！ 背包问题：给定一组物品，每种物品有自己的重量和价格，在限定的重量内，我们如何选择，才能使物品的总价格最高。 三种背包： 01背包：每个物品只能选择一次 完全背包：每个物品选择次数不限制 多重度背包：每个物品只能选择限定次数 一、01背包 问题描述：有 N 件物品和一个容量是 V的背包。每件物品只能使用一次。第 i件物品的体积是 vi，价值是 wi。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大
群体智能优化算法之萤火虫算法(Firefly Algorithm，FA)
热门推荐
松间沙路的博客
11-15 1万+
获取更多资讯，赶快关注上面的公众号吧！ 文章目录第八章 萤火虫算法8.1 介绍8.2 天然萤火虫的行为8.3 萤火虫算法8.4 萤火虫算法改进参考文献 第八章 萤火虫算法 8.1 介绍 萤火虫（firefly）种类繁多，主要分布在热带地区。大多数萤火虫在短时间内产生有节奏的闪光。这种闪光是由于生物发光的一种化学反应，萤火虫的闪光模式因种类而异。萤火虫算法(FA)是基于萤火虫的闪光行为，它是一种用...
01背包问题深度解析与解法汇总
"该资源是一份关于01背包问题的详细解析资料，包含了多个博客和文章链接，涵盖了01背包问题的不同解法，包括动态规划的运用，以及对背包问题的深入讲解，如四种解题方法、一次搞定三种背包问题的策略，还有针对多重...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值