背包问题

已于 2023-10-01 17:54:36 修改
阅读量284 收藏 1
点赞数 1
分类专栏： 洛谷 文章标签： 算法 动态规划 c++
于 2023-10-01 17:32:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62593364/article/details/133434367
版权

目录

开端

01背包问题

AcWing 01背包问题

Luogu P2925干草出售

Luogu P1048采药

完全背包问题

AcWing 完全背包问题

Luogu P1853投资的最大效益

多重背包问题

AcWing 多重背包问题 I

AcWing 多重背包问题 II

Luogu P1776宝物筛选

混合背包问题

AcWing 混合背包问题

Luogu P1833樱花

二维费用背包问题

AcWing 二维费用的背包问题 

Luogu P1507NASA的食物计划

分组背包问题

AcWing 分组背包问题

Luogu P1757 通天之分组背包

开端

关于背包问题，嗯一直学不明白，暑假咸的没事又拾起来学了一下，跟着这位大佬整理的思路（背包九讲——全篇详细理解与代码实现-CSDN博客），对背包的思想有了一定清晰的理解，大佬的文章有些长，所以跟着自己的思路再整理一下。

为了方便统一，先定义一下

c[i]：表示代价

w[i]：表示价值

dp[i][j]：表示前i个物品花费代价为j的可以获得的最大代价

p[i]：表示第i种物品最多有p[i]件

01背包问题

定义：

dp[i][j]：表示前i个物品恰放入一个容量为j的背包下可以获得的最大代价

子问题第i1件物品状态：

①不选：dp[i][j]=dp[i-1][j]

②选：dp[i][j]=dp[i][j-c[i]]+w[i]

状态转移方程：

dp[i][j]=max(dp[i-1][j],dp[i][j-c[i]]+w[i])

优化空间复杂度：

O(V*N)

for(int i=1;i<=n;i++)
    for(int j=c[i];j<=V;j--)
        dp[i][j]=max(dp[i-1][j],dp[i-1][j-c[i]]+w[i]);

O(V)

for(int i=1;i<=n;i++)
    for(int j=V;j>=c[i];j++)
        dp[j]=max(dp[j],dp[j-c[i]]+w[i]);

关于顺序和逆序：

逆序表示：dp[j]=max(dp[j],dp[j-c[i]]+w[i])由dp[i][j]=max(dp[i-1][j],dp[i-1][j-c[i]]+w[i])转移过来的
顺序表示：dp[j]=max(dp[j],dp[j-c[i]]+w[i])由dp[i][j]=max(dp[i][j],dp[i][j-c[i]]+w[i])转移过来的

初始化问题：

①要求恰好装满：dp[i]=-∞,dp[0]=0;

②只要求价值最大：dp[i]=0;

 AcWing 01背包问题

const int N = 1010;
int c[N], w[N], dp[N];
inline void solve()
{
    int N, V;
    cin >> N >> V;
    for (int i = 1; i <= N; i++)
        cin >> c[i] >> w[i];
    for (int i = 1; i <= N; i++)
        for (int j = V; j >= c[i]; j--)
            dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
    cout << dp[V] << endl;
}

Luogu P2925干草出售

const int N = 5e4 + 10;
int w[N], dp[N];
inline void solve()
{
    int C, H;
    cin >> C >> H;
    for (int i = 1; i <= H; i++)
        cin >> w[i];
    for (int i = 1; i <= H; i++)
        for (int j = C; j >= w[i]; j--)
            dp[j] = max(dp[j], dp[j - w[i]] + w[i]);
    cout << dp[C] << endl;
}

Luogu P1048采药

const int N = 1010;
int c[N], w[N], dp[N];
inline void solve()
{
    int T, M;
    cin >> T >> M;
    for (int i = 1; i <= M; i++)
        cin >> c[i] >> w[i];
    for (int i = 1; i <= M; i++)
        for (int j = T; j >= c[i]; j--)
            dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
    cout << dp[T] << endl;
}

完全背包问题

 定义：

dp[i][j]：表示前i种物品恰放入一个容量为j的背包下可以获得的最大代价

子问题第i种物品状态：

①不选该种物品：dp[i][j]=dp[i-1][j];
②选不同件该种物品：选0件、1件、2件……k件：dp[i][j]=dp[i-1][j-c[i]*k]+w[i]*k;

状态转移方程：

dp[i][j]=max(dp[i-1][j-c[i]*k]+w[i]*k)  0<=c[i]*k<=j

优化空间复杂度：

O(N*∑(V/c[i]))

for(int i=1;i<=n;i++)
    for(int j=c[i];j<=V;j++)
        for(int k=0;c[i]*k<=j;k++)
            dp[i][j]=max(dp[i][j],dp[i-1][j-c[i]*k]+w[i]*k);
# 第一个参数，因为k=0时就相当于dp[i-1][j];

O(V*N)转化为01背包问题

for(int i=1;i<=n;i++)
    for(int j=c[i];j<=j;j++)
        dp[j]=max(dp[j],dp[j-c[i]]+w[i]);
//等价于dp[i][j]=max(dp[i-1][j],dp[i][j-c[i]]+w[i]);(不取该物品，取不同件)；

关于顺序和逆序：

逆序表示：dp[j]=max(dp[j],dp[j-c[i]]+w[i])由dp[i][j]=max(dp[i-1][j],dp[i-1][j-c[i]]+w[i])转移过来的
顺序表示：dp[j]=max(dp[j],dp[j-c[i]]+w[i])由dp[i][j]=max(dp[i-1][j],dp[i][j-c[i]]+w[i])转移过来的

初始化问题：

①要求恰好装满：dp[i]=-∞,dp[0]=0;

②只要求价值最大：dp[i]=0;

AcWing 完全背包问题

const int N = 1010;
int c[N], w[N], dp[N];
inline void solve()
{
    int N, V;
    cin >> N >> V;
    for (int i = 1; i <= N; i++)
        cin >> c[i] >> w[i];
    for (int i = 1; i <= N; i++)
        for (int j = c[i]; j <= V; j++)
            dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
    cout << dp[V] << endl;
}

Luogu P1853投资的最大效益

const int N = 1e6 + 10;
int c[N], w[N], dp[N];
inline void solve()
{
    int s, n, d;
    cin >> s >> n >> d;
    for (int i = 1; i <= d; i++)
        cin >> c[i] >> w[i];
    while (n--)
    {
        for (int i = 1; i <= d; i++)
            for (int j = c[i]; j <= s; j++)
                dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
        s += dp[s];
    }
    cout << s << endl;
}
int main(

这个题目有个小坑

所以要做一下处理：除以1000防止爆空间

const int N = 1e6 + 10;
int c[N], w[N], dp[N];
inline void solve()
{
    int s, n, d;
    cin >> s >> n >> d;
    for (int i = 1; i <= d; i++)
        cin >> c[i] >> w[i];
    while (n--)
    {
        for (int i = 1; i <= d; i++)
            for (int j = c[i] / 1000; j <= s / 1000; j++)
                dp[j] = max(dp[j], dp[j - c[i] / 1000] + w[i]);
        s += dp[s / 1000];
    }
    cout << s << endl;
}

多重背包问题

  定义：

dp[i][j]：表示前i种物品恰放入一个容量为j的背包下可以获得的最大代价

子问题第i种物品状态：

①不选该种物品：dp[i][j]=dp[i-1][j];
②选不同件该种物品：选1件、2件……p[i]件：dp[i][j]=dp[i-1][j-c[i]*k]+w[i]*k;

状态转移方程：

dp[i][j]=max(dp[i-1][j-c[i]*k]+w[i]*k)  0<=k<=p[i]

转化为01背包问题：

方法一：O(V*∑p[i])

for(int i=1;i<=n;i++)
    for(int j=V;j>=c[i];j--)
        for(int k=1;c[i]*k<=j&&k<=p[i];k++)
            dp[j]=max(dp[j],dp[j-c[i]*k]+w[i]*k);
# 第一个参数，因为k=0时就相当于dp[i-1][j];

方法二：二进制优化O(N*log(p)*V)

for (int i = 1; i <= N; i++)
    {
        int a, b, s;
        cin >> a >> b >> s;
        int k = 1;
        while (k <= s)  //0……2^k-1部分的系数1，2，4，8……
        {
            cnt++;
            c[cnt] = k * a;
            w[cnt] = k * b;
            s -= k;
            k *= 2;
        }
        if (s > 0)  //2^k……s部分的系数 s-2^k
        {
            cnt++;
            c[cnt] = s * a;
            w[cnt] = s * b;
        }
    }
    N = cnt;  //更新总数量
    for (int i = 1; i <= N; i++)  //01背包问题
        for (int j = V; j >= c[i]; j--)
            dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
 for (int i = 1; i <= n; i++)
    {
        cin >> c[i] >> w[i] >> p[i];
        int s = min(p[i], W / w[i]);
        for (int k = 1; s > 0; k <<= 1)
        {
            k = min(k, s);
            s -= k;
            for (int j = W; j >= k * w[i]; j--)
            {
                dp[j] = max(dp[j], dp[j - k * w[i]] + k * c[i]);
            }
        }
    }

初始化问题：

①要求恰好装满：dp[i]=-∞,dp[0]=0;

②只要求价值最大：dp[i]=0;

方法一：

AcWing 多重背包问题 I

const int N = 110;
int c[N], w[N], p[N], dp[N];
inline void solve()
{
    int N, V;
    cin >> N >> V;
    int cnt = 0;
    for (int i = 1; i <= N; i++)
        cin >> c[i] >> w[i] >> p[i];
    for (int i = 1; i <= N; i++)
        for (int j = V; j >= c[i]; j--)
            for (int k = 1; c[i] * k <= j && k <= p[i]; k++)
                dp[j] = max(dp[j], dp[j - c[i] * k] + w[i] * k);
    cout << dp[V] << endl;
}

方法二：

AcWing 多重背包问题 II

const int N = 20010;  //注意初始化，否则会越界
int c[N], w[N], dp[N];
inline void solve()
{
    int N, V;
    cin >> N >> V;
    int cnt = 0;
    for (int i = 1; i <= N; i++)
    {
        int a, b, s;
        cin >> a >> b >> s;
        int k = 1;
        while (k <= s)  //0……2^k-1部分的系数1，2，4，8……
        {
            cnt++;
            c[cnt] = k * a;
            w[cnt] = k * b;
            s -= k;
            k *= 2;
        }
        if (s > 0)  //2^k……s部分的系数 s-2^k
        {
            cnt++;
            c[cnt] = s * a;
            w[cnt] = s * b;
        }
    }
    N = cnt;  //更新总数量
    for (int i = 1; i <= N; i++)  //01背包问题
        for (int j = V; j >= c[i]; j--)
            dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
    cout << dp[V] << endl;
}

Luogu P1776宝物筛选

const int N = 1e6 + 10; // 注意初始化，否则会越界
int c[N], w[N], dp[N];
inline void solve()
{
    int n, W;
    cin >> n >> W;
    int cnt = 0;
    for (int i = 1; i <= n; i++)
    {
        int a, b, s;
        cin >> a >> b >> s;
        int k = 1;
        while (k <= s)
        {
            cnt++;
            w[cnt] = k * a;
            c[cnt] = k * b;
            s -= k;
            k *= 2;
        }
        if (s > 0)
        {
            cnt++;
            w[cnt] = s * a;
            c[cnt] = s * b;
        }
    }
    n = cnt;
    for (int i = 1; i <= n; i++)
        for (int j = W; j >= c[i]; j--)
            dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
    cout << dp[W] << endl;
}

简化

const int N = 1e6 + 10; // 注意初始化，否则会越界
int c[N], w[N], p[N], dp[N];
inline void solve()
{
    int n, W;
    cin >> n >> W;
    for (int i = 1; i <= n; i++)
    {
        cin >> c[i] >> w[i] >> p[i];
        int s = min(p[i], W / w[i]);
        for (int k = 1; s > 0; k <<= 1)
        {
            k = min(k, s);
            s -= k;
            for (int j = W; j >= k * w[i]; j--)
            {
                dp[j] = max(dp[j], dp[j - k * w[i]] + k * c[i]);
            }
        }
    }
    cout << dp[W] << endl;
}

混合背包问题

 01背包、完全背包、多重背包的混合状态转移：

for (int i = 1; i <= N; i++)
    {
        cin >> c[i] >> w[i] >> p[i];
        // 01背包
        if (p[i] == -1)
            for (int j = V; j >= c[i]; j--)
                dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
        // 完全背包
        else if (p[i] == 0)
            for (int j = c[i]; j <= V; j++)
                dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
        // 多重背包二进制优化
        else
        {
            int s = min(p[i], V / c[i]);
            for (int k = 1; s > 0; k <<= 1)
            {
                k = max(k, s);
                s -= k;
                for (int j = V; j >= k * c[i]; j--)
                    dp[j] = max(dp[j], dp[j - k * c[i]] + k * w[i]);
            }
        }
    }

AcWing 混合背包问题

const int N = 1e6 + 10; // 注意初始化，否则会越界
int c[N], w[N], p[N], dp[N];
inline void solve()
{
    int N, V;
    cin >> N >> V;
    for (int i = 1; i <= N; i++)
    {
        cin >> c[i] >> w[i] >> p[i];
        // 01背包
        if (p[i] == -1)
            for (int j = V; j >= c[i]; j--)
                dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
        // 完全背包
        else if (p[i] == 0)
            for (int j = c[i]; j <= V; j++)
                dp[j] = max(dp[j], dp[j - c[i]] + w[i]);//或将完全背包转化为多重01背包s=V/c[i]
        // 多重背包二进制优化
        else
        {
            int s = min(p[i], V / c[i]);
            for (int k = 1; s > 0; k <<= 1)
            {
                k = min(k, s);
                s -= k;
                for (int j = V; j >= k * c[i]; j--)
                    dp[j] = max(dp[j], dp[j - k * c[i]] + k * w[i]);
            }
        }
    }
    cout << dp[V] << endl;
}

Luogu P1833樱花

const int N = 1e6 + 10; // 注意初始化，否则会越界
int c[N], w[N], p[N], dp[N];
inline void solve()
{
    int m1, m2, s1, s2, N;
    scanf("%d:%d %d:%d %d", &m1, &s1, &m2, &s2, &N);
    int V = m2 * 60 + s2 - m1 * 60 - s1;
    for (int i = 1; i <= N; i++)
    {
        cin >> c[i] >> w[i] >> p[i];
        int s;
        if (p[i] == 0) // 完全转化为多重
            s = V / c[i];
        else
            s = min(p[i], V / c[i]);
        for (int k = 1; s > 0; k <<= 1)
        {
            k = min(k, s);
            s -= k;
            for (int j = V; j >= k * c[i]; j--)
                dp[j] = max(dp[j], dp[j - k * c[i]] + k * w[i]);
        }
    }
    cout << dp[V] << endl;
}

二维费用背包问题

 定义：每件物品需要同时花费两种不同的代价

dp[i][j][k]：表示前i种物品付出两种代价分别最大为j和k时可获得的最大价值

状态转移方程：

dp[i][j][k]=max(dp[i-1][j][k],dp[i-1][j-c[i]][k-m[i]]+w[i])

01背包代码（完全背包、多重背包可以类比）

for(int i=1;i<=n;i++)
    for(int j=V;j>=c[i];j--)
        for(int k=M;k>=m[i];k--)
            dp[j][k]=max(dp[j][k],dp[j-c[i]][k-m[i]]+w[i]);

AcWing 二维费用的背包问题 

const int N = 1010; // 注意初始化，否则会越界
int c[N], w[N], m[N], dp[N][N];
inline void solve()
{
    int N, V, M;
    cin >> N >> V >> M;

    for (int i = 1; i <= N; i++)
    {
        cin >> c[i] >> m[i] >> w[i];
        for (int j = V; j >= c[i]; j--)
            for (int k = M; k >= m[i]; k--)
                dp[j][k] = max(dp[j][k], dp[j - c[i]][k - m[i]] + w[i]);
    }
    cout << dp[V][M] << endl;
}

Luogu P1507NASA的食物计划

const int N = 1010; // 注意初始化，否则会越界
int c[N], w[N], m[N], dp[N][N];
inline void solve()
{
    int V, M, N;
    cin >> V >> M >> N;

    for (int i = 1; i <= N; i++)
    {
        cin >> c[i] >> m[i] >> w[i];
        for (int j = V; j >= c[i]; j--)
            for (int k = M; k >= m[i]; k--)
                dp[j][k] = max(dp[j][k], dp[j - c[i]][k - m[i]] + w[i]);
    }
    cout << dp[V][M] << endl;
}

分组背包问题

  定义：

dp[k][j]：表示前k组物品花费代价j能取得的最大价值

子问题第k组物品状态：

①不选该组物品：dp[k][j]=dp[k-1][j];
②选该组物品：dp[k][j]=dp[k-1][j-c[i]+w[i]] 物品i属于k组

状态转移方程：

dp[k][j]=max(dp[k-1][j],dp[k-1][j-c[i]]+w[i])

模板：

 for (int k = 1; k <= N; k++)
    {
        int s;
        cin >> s; // 第k组的物品数量
        for (int i = 1; i <= s; i++)
            cin >> c[i] >> w[i]; // 组中每个物品i的属性
        for (int j = V; j >= 0; j--)
            for (int i = 1; i <= s; i++) // 保证每组物品只能选一个，可以覆盖之前组内物品最优解的来取最大值
                if (j >= c[i])
                    dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
    }

AcWing 分组背包问题

const int N = 110; // 注意初始化，否则会越界
int c[N], w[N], m[N], dp[N];
inline void solve()
{
    int N, V;
    cin >> N >> V;
    for (int k = 1; k <= N; k++)
    {
        int s;
        cin >> s; // 第k组的物品数量
        for (int i = 1; i <= s; i++)
            cin >> c[i] >> w[i]; // 组中每个物品i的属性
        for (int j = V; j >= 0; j--)
            for (int i = 1; i <= s; i++) // 保证每组物品只能选一个，可以覆盖之前组内物品最优解的来取最大值
                if (j >= c[i])
                    dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
    }
    cout << dp[V] << endl;
}

Luogu P1757 通天之分组背包

const int N = 110;  // 注意初始化，否则会越界
const int M = 1010; // 注意初始化，否则会越界
int c[M], w[M], dp[M];
int g[N][N], b[M]; // g[k][i]表示小组k种第i个物品的编号,b[k]表示小组k的物品+1；
inline void solve()
{
    int N, V;
    cin >> V >> N;
    int t = 0, k = 0;
    for (int i = 1; i <= N; i++)
    {
        cin >> c[i] >> w[i] >> k;
        t = max(t, k);  // 求小组的组数
        b[k]++;         // 小组k的物品+1；
        g[k][b[k]] = i; // 小组k中第b[k]个物品的编号为i;
    }
    for (int k = 1; k <= t; k++)
        for (int j = V; j >= 0; j--)
            for (int i = 1; i <= b[k]; i++)
                if (j >= c[g[k][i]])
                    dp[j] = max(dp[j], dp[j - c[g[k][i]]] + w[g[k][i]]);

    cout << dp[V] << endl;
}
会笑的小熊
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划专题——背包问题
⚡
02-13 3万+
详解四种背包：01背包、完全背包、多重背包、分组背包。
【动态规划】01背包问题（通俗易懂，超基础讲解）
热门推荐
Yngz_Miao的博客
08-24 43万+
问题描述 有n个物品，它们有各自的体积和价值，现有给定容量的背包，如何让背包里装入的物品具有最大的价值总和？ 为方便讲解和理解，下面讲述的例子均先用具体的数字代入，即：eg：number＝4，capacity＝8 i（物品编号） 1 2 3 4 w（体积） 2 3 4 5 v（价值） 3 4 5 6 总...
01背包问题
ccc369639963的博客
01-19 1万+
01背包问题 商店的货架上摆放着不同重量和价值的商品，一个小偷在商店行窃，他携带的背包只能装固定重量的商品。装哪些商品才能获得最大的收益呢？在限定条件内找到最佳的物品组合，这样的问题统称为背包问题。 根据限定的条件不同，背包问题还可以细分： 部分背包问题：所有物品是可再分的，即允许将某件物品的一部分（例如 1/3）放入背包； 0-1 背包问题：所有物品不可再分，要么整个装入背包，要么放弃，不允许出现“仅选择物品的 1/3 装入背包”的情况； 完全背包问题：不对每一件物品的数量做限制，同一件物品可以选择多个装
背包问题leetcode
Hello World程序员的博客
08-02 1306
问题一：分割等和子集（LeetCode 416） 416. 分割等和子集 //给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。 // // 注意: // // // 每个数组中的元素不会超过 100 // 数组的大小不会超过 200 // // // 示例 1: // // 输入: [1, 5, 11, 5] // //输出: true // //解释: 数组可以分割成 [1, 5, 5] 和 [11]. // // // // // 示.
动态规划之背包问题（01背包问题、完全背包问题、多重背包问题 I、多重背包问题 II 、分组背包问题）
小羊的博客
03-30 5万+
动态规划之背包问题（01背包问题、完全背包问题、多重背包问题 I、多重背包问题 II 、分组背包问题）
完全背包问题
weixin_57023347的博客
08-02 1万+
概念： 完全背包问题一般是指：有N件物品和一个能背重量为W的背包，第i件物品的重量为weight[i],价值为value[i]。每件物品有无限个(也就是可以放入背包多次），求怎样可以使背包物品价值总量最大。 完全背包与01背包问题的区别在于01背包物品只有一个，完全背包有无数个。 ...
Python 背包问题
小嗷犬的博客
07-07 2265
背包问题（Knapsack Problem）是一类常见的组合优化问题。其问题描述为：给定一个固定大小、能够携重 WW 的背包，以及一组有价值和重量的物品，找出一个最佳解决方案，使得装入背包的物品总重量不超过 WW，且总价值最大。
leetcode——背包问题汇总
Michael_Jay的博客
12-24 1742
本篇文章汇总了leetcode常见的0-1背包问题和完全背包问题。
背包问题Matlab求解
05-28
初始化背包容量、价值等必要因素，Matlab求解最优解。代码模块清晰，简单明了。
背包问题详解
04-09
这里有9种背包问题的详解，包括01背包问题，完全背包问题，多重背包问题，混合三种背包问题，二维费用的背包问题，分组的背包问题，有依赖的背包问题，泛华物品，背包问题问法的变化。每种背包问题不仅有详细的讲解...
01背包问题_01背包问题_
10-04
课程作业，实现算法实践书后的例题，实现01背包问题
3-增量背包问题四类实例
09-03
3-增量背包问题四类实例
链接表存储图(C++注释详解): 构建表 & 深度优先遍历 (DFS)
H13420972436的博客
05-15 444
代码实现: 构建表 & 深度优先遍历 (DFS)
【算法】二分算法——x的平方根
2302_79031646的博客
05-17 812
用二分边界算法来求解——x的平方根，从暴力求解到二分的优化细说
day09
2202_76101487的博客
05-17 747
正值少年的日常打卡！！！
BERT系列算法解读
qq_52053775的博客
05-19 80
从而提高模型在SQuAD、MNLI和SST-2数据集上的性能。总的来看，这些优化措施显著增强了模型的表现。
基于地理坐标的高阶几何编辑工具算法（8）——整形面
最新发布
HouGISer的博客
05-19 616
整形面算法常用于快速修改一个几何面的局部形状。
python背包问题
08-26
背包问题是一个经典的优化问题，在计算机科学和运筹学中经常被讨论和研究。在Python中，可以使用动态规划来解决背包问题。 背包问题可以分为0-1背包问题和无限背包问题两种类型。 0-1背包问题要求在有限的物品集合中选择一些物品放入背包，使得在限定的背包容量下，所选物品的总价值最大化。每种物品只能选择取或不取一次。 无限背包问题则允许每种物品选择无限次放入背包，其他条件与0-1背包问题类似。 下面是一个简单的例子，展示如何使用动态规划解决0-1背包问题： ```python def knapsack_01(values, weights, total_weight): n = len(values) dp = [[0] * (total_weight + 1) for _ in range(n + 1)] for i in range(1, n + 1): for j in range(1, total_weight + 1): if weights[i - 1] <= j: dp[i][j] = max(dp[i - 1][j], values[i - 1] + dp[i - 1][j - weights[i - 1]]) else: dp[i][j] = dp[i - 1][j] return dp[n][total_weight] ``` 在这个例子中，`values`是物品的价值列表，`weights`是物品的重量列表，`total_weight`是背包的总容量。函数返回最大化的总价值。 你可以根据实际需求进行修改和扩展，这只是一个基本的示例。希望对你有所帮助！如果有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值