[算法]背包问题

最新推荐文章于 2024-10-08 20:49:38 发布
最新推荐文章于 2024-10-08 20:49:38 发布
阅读量376 收藏 7
点赞数 8
分类专栏： 算法 文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64609861/article/details/137795440
版权
本文详细探讨了背包问题的几种版本（101背包、完全背包、分组背包和多重背包），介绍了原始未优化算法和通过滚动数组进行的时间和空间复杂度优化方法。主要关注了如何通过动态规划解决背包问题并优化其效率。
摘要由CSDN通过智能技术生成

文章目录

1 01背包

1.1 题目

有N 件物品和一个容量为V 的背包。放入第i 件物品耗费的费用是Ci，得到的价值是Wi。求解将哪些物品装入背包可使价值总和最大。

1.2 未优化版

1.2.1 代码

public static void main(String[] args) {//原始版
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();//n个物品
    int m = scanner.nextInt();//容量是w
    int[] w = new int[n + 5];//容量是wi
    int[] v = new int[n + 5];//价值是vi
    int[][] dp = new int[n + 2][m + 2];
    for (int i = 1; i <= n; i++) {
        v[i] = scanner.nextInt();
        w[i] = scanner.nextInt();
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            dp[i][j] = dp[i - 1][j];
            if (v[i] <= j) {
                dp[i][j] = Math.max(dp[i - 1][j - v[i]] + w[i], dp[i][j]);
            }
        }
    }
    System.out.println(dp[n][m]);
}

1.2.2 时空复杂度

1.2.2.1 时间: n*m
1.2.2.2 空间: n*m

1.3 滚动数组优化

public static void main(String[] args) {//优化版
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();//n个物品
    int m = scanner.nextInt();//容量是w
    int[] w = new int[n + 5];//容量是wi
    int[] v = new int[n + 5];//价值是vi
    int[] dp = new int[m + 2];
    for (int i = 1; i <= n; i++) {
        v[i] = scanner.nextInt();
        w[i] = scanner.nextInt();
    }
    for (int i = 1; i <= n; i++) {
        for (int j = m; j >= v[i]; j--) {
            dp[j] = Math.max(dp[j - v[i]] + w[i], dp[j]);
        }
    }
    System.out.println(dp[m]);
}

1.3.2 时空复杂度

1.3.2.1 时间: n*m
1.3.2.2 空间: m

2 完全背包

2.1 题目

有N 种物品和一个容量为V 的背包，每种物品都有无限件可用。放入第i 种物品的费用是Ci，价值是Wi。求解：将哪些物品装入背包，可使这些物品的耗费的费用总和不超过背包容量，且价值总和最大。

2.2 未优化版

public static void main(String[] args) {//原始版
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    int m = scanner.nextInt();
    int[] v = new int[n + 1];
    int[] w = new int[n + 1];
    int[][] dp = new int[n + 1][m + 1];
    for (int i = 1; i <= n; i++) {
        v[i] = scanner.nextInt();
        w[i] = scanner.nextInt();
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            for (int k = 0; k <= n; k++) {
                if (j - k * v[i] >= 0) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - k * v[i]] + k * w[i]);
                }
            }
        }
    }
    System.out.println(dp[n][m]);
}

2.2.1 时空复杂度

2.2.2.1 时间: n*m*m
2.2.2.2 空间: m*n

2.3 优化一层循环

public static void main(String[] args) {//优化版
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    int m = scanner.nextInt();
    int[] v = new int[n + 1];
    int[] w = new int[n + 1];
    int[][] dp = new int[n + 1][m + 1];
    for (int i = 1; i <= n; i++) {
        v[i] = scanner.nextInt();
        w[i] = scanner.nextInt();
    }
    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] >= 0) {
                dp[i][j] = Math.max(dp[i][j], dp[i][j - v[i]] + w[i]);
            }
        }
    }
    System.out.println(dp[n][m]);
}

2.3.1 时空复杂度

2.3.2.1 时间: n*m
2.3.2.2 空间: m*n

2.4 滚动数组优化

public static void main(String[] args) {//最终优化版
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    int m = scanner.nextInt();
    int[] v = new int[n + 1];
    int[] w = new int[n + 1];
    int[] dp = new int[m + 1];
    for (int i = 1; i <= n; i++) {
        v[i] = scanner.nextInt();
        w[i] = scanner.nextInt();
    }

    for (int i = 1; i <= n; i++) {
        for (int j = v[i]; j <= m; j++) {
            dp[j] = Math.max(dp[j], dp[j - v[i]] + w[i]);
        }
    }
    System.out.println(dp[m]);
}

2.4.1 时空复杂度

2.4.2.1 时间: n*m
2.4.2.2 空间: m

3 分组背包

3.1 题目

给你N组物品，然后每一组你至多选择一个物品(也可以不选),每个物品都有自己的体积和价值，现在给你一个容里为M的背包，让你用这个背包装物品，使得物品价值总和最大.

3.1 未优化版

    public static void main(String[] args) {//未优化版
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int[] s = new int[n + 1];
        int[][] v = new int[n + 1][m + 1];
        int[][] w = new int[n + 1][m + 1];
        int[][] dp = new int[n + 1][m + 1];

        for (int i = 1; i <= n; i++) {
            s[i] = scanner.nextInt();
            for (int j = 0; j < s[i]; j++) {
                v[i][j] = scanner.nextInt();
                w[i][j] = scanner.nextInt();
            }
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= m; j++) {
                for (int k = 0; k < s[i]; k++) {
                    dp[i][j] = dp[i - 1][j];
                    if (j - v[i][k] >= 0) {
                        dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - v[i][k]] + w[i][k]);
                    }
                }
            }
        }
        System.out.println(dp[n][m]);
    }

2.3.1 时空复杂度

2.3.2.1 时间: n*m*s[i]
2.3.2.2 空间: m*n

3.2 优化版

public static void main(String[] args) {//优化版
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    int m = scanner.nextInt();
    int[] s = new int[n + 1];
    int[][] v = new int[n + 1][m + 1];
    int[][] w = new int[n + 1][m + 1];
    int[] dp = new int[m + 1];

    for (int i = 1; i <= n; i++) {
        s[i] = scanner.nextInt();
        for (int j = 0; j < s[i]; j++) {
            v[i][j] = scanner.nextInt();
            w[i][j] = scanner.nextInt();
        }
    }
    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] >= 0) {
                    dp[j] = Math.max(dp[j], dp[j - v[i][k]] + w[i][k]);
                }
            }
        }
    }
    System.out.println(dp[m]);
}

2.4.1 时空复杂度

2.4.2.1 时间: n*m*s[i]
2.4.2.2 空间: m

4 多重背包

4.1题目

有N 种物品和一个容量为V 的背包。第i 种物品最多有Mi 件可用，每件耗费的空间是vi，价值是Wi。求解将哪些物品装入背包可使这些物品的耗费的空间总和不超过背包容量，且价值总和最大。

4.1 未优化版

public static void main0(String[] args) {//原始版
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    int m = scanner.nextInt();
    int[][] dp = new int[n + 1][m + 1];
    int[] v = new int[n + 1];
    int[] w = new int[n + 1];
    int[] s = new int[n + 1];
    for (int i = 1; i <= n; i++) {
        v[i] = scanner.nextInt();
        w[i] = scanner.nextInt();
        s[i] = scanner.nextInt();
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            for (int k = 0; k <= s[i]; k++) {
                dp[i][j] = dp[i - 1][j];
                if (j >= v[i] * k) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - k * v[i]] + k * w[i]);
                }
            }
        }
    }
    System.out.println(dp[n][m]);
}

4.2 优化版

public static void main(String[] args) {//小优化
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    int m = scanner.nextInt();
    int[][] dp = new int[n + 1][m + 1];
    int[] v = new int[n + 1];
    int[] w = new int[n + 1];
    int[] s = new int[n + 1];
    for (int i = 1; i <= n; i++) {
        v[i] = scanner.nextInt();
        w[i] = scanner.nextInt();
        s[i] = scanner.nextInt();
    }
    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++) {//减少循环
                dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - k * v[i]] + k * w[i]);
            }
        }
    }
    System.out.println(dp[n][m]);
}

4.3 二进制优化

public static void main(String[] args) {//二进制优化
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    int m = scanner.nextInt();
    int[] dp = new int[N];//由于需要扩大数组,所以开得比较大
    int[] v = new int[N];
    int[] w = new int[N];
    int index = 1;
    for (int i = 1; i <= n; i++) {
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int s = scanner.nextInt();
        int k = 1;
        while (k <= s) {
            v[index] = a * k;
            w[index++] = b * k;
            s -= k;
            k <<= 2;
        }
        if (s > 0) {
            v[index] = a * s;
            w[index++] = b * s;
            s = 0;
        }
    }
    n=index;
    for (int i = 1; i <= n; i++) {//01背包
        for (int j = m; j >= v[i]; j--) {
            dp[j] = Math.max(dp[j], dp[j - v[i]] + w[i]);
        }
    }
    System.out.println(dp[m]);
}

5 总结

背包是一种动态规划问题。动态规划的核心就是状态转移方程

无-常
关注
专栏目录
贪心算法背包问题c
12-08 2330
这个状态转移方程表示，对于前i个物品在容量为j的背包中能够获得的最大价值f[i][j]，要么是前i个物品在容量为j的背包中能够获得的最大价值f[i][j]，要么是前i - 1个物品在容量为j - w[i]的背包中能够获得的最大价值f[i - 1][j - w[i]] + v[i]。初始状态是f[0][j] = 0，表示不取任何物品时的价值为0。f[i][j] = max(f[i][j], f[i - 1][j - w[i]] + v[i])其中w[i]表示第i个物品的重量，v[i]表示第i个物品的价值。
算法——背包问题
m0_49039508的博客
06-21 2596
算法——背包问题 本篇博文通过学习尚硅谷韩老师《数据结构与算法》课程所做，在此非常感谢！ 文章目录算法——背包问题概念分析代码实现测试 概念 问题 有一个背包，容量为4磅 ， 现有如下物品： 物品 重量 价值 吉他(G) 1 1500 音响(S) 4 3000 电脑© 3 2000 要求达到的目标为装入的背包的总价值最大，并且重量不超出; 要求装入的物品不能重复; 思路分析 背包问题主要是指一个给定容量的背包、若干具有一定价值和重量的物品，如何选择物品放入背包使物品的价值最
Python 贪心算法背包问题
m0_73992567的博客
04-20 536
python 贪心算法求解背包问题
贪心算法背包问题java
java后端攻城狮
11-19 1219
package pack; import java.util.Arrays; import java.util.Scanner; /* * 代码潜在bug * 1. * 第46行，Need数组是float数组没有对进入的数组进行保留2位小数进行处理（虽然题中没说，但感觉是不安全的） * */ public class Pack { public static void main(String[] args) { //读取控制台数据 Scanner scanner .
贪心算法 背包问题代码 c语言,用贪心算法求解普通背包问题的C++代码
weixin_32512187的博客
05-23 1963
用贪心算法求解普通背包问题的C++代码2019年3月6日 125次阅读 来源: 贪心算法#include#define M 100void display(int &n,double &C,double s[M],double p[M]){int i;cout<cin>>n;cout<cout<cin>>C;cout<cout...
【算法】贪心算法 背包问题 python
还有很长很长的路
05-03 6534
博主自己手撸代码，若有错误，感谢指出 0 贪心算法 贪心算法是一个只关注眼前利益的算法，看起来比较短视，没有长远眼光，但在某些时候会取得比较好的收益。 1 直接上代码 因为python中list自带排序算法，因此博主并没有写排序算法，看起来比较短 m = eval(input('可承载的最大重量：')) h = eval(input('宝物重量：')) v = eval(in...
用贪心算法解决背包问题
2301_76572283的博客
05-22 2134
设有背包问题时实例n=7，m=15，（w0，w1，...，w6）=（2，3，5，7，1，4，1），物品装入背包的收益为：（p0，p1，...，p6）=（10，5，15，7，6，18，13）。先选入1号物品，再选入2号物品，但由于背包的容量剩余20-15=5，因此2号物品装入1/2，0号物品不装入，这样得到的解为（x0，x1，x2）=（0，1，1/2），它的总收益为31.5，总收益最大。贪心算法只是一种算法，它是基于贪心策略来编写的算法，贪心算法可以看作是贪心策略的具象化，算法是具体的，策略是模糊的。
【算法】经典背包问题
指针不指南吗的博客
05-16 2651
acwing 背包问题——学习笔记：01背包、完全背包、多重背包、分组背包
背包问题贪心算法求解
热门推荐
practical_sharp的博客
10-06 6万+
题目 有一个背包，背包容量是M=150。有7个物品，物品可以分割成任意大小。 要求尽可能让装入背包中的物品总价值最大，但不能超过总容量。 思路 具有最优子结构性质和贪心选择性质。只要是所有物品的总重量大于背包容纳量，那么背包一定能装满。注意背包问题与0-1背包问题的区别。 这2类问题都具有最优子结构性质，极为相似，但背包问题可以用贪心算法求解，而0-1背包问题却不能用贪心算法求解。 求解步骤 用...
java编程贪心算法背包问题,贪心算法----部分背包问题（java实现）
weixin_32791013的博客
03-22 1735
部分背包问题给定 n 种物品和一个背包.物品 i 的重量是 Wi,其价值为 Vi,背包的容量为 C.在选择物品 i 装入背包时,可以选择物品 i 的一部分,1<= i <=n.问应如何选择装入背包中的物品,使得装入背包中物品的总价值最大.代码：import java.util.Scanner;public class BackPack {/*Sort 将物品按价值比从大到小排放在数组*...
基于C语言实现贪心算法背包问题动态规划源码.zip
01-21
基于C语言实现贪心算法背包问题动态规划源码.zip基于C语言实现贪心算法背包问题动态规划源码.zip基于C语言实现贪心算法背包问题动态规划源码.zip基于C语言实现贪心算法背包问题动态规划源码.zip基于C语言实现贪心...
贪心算法背包问题 zip
10-28
标题中的“贪心算法背包问题 zip”指的是将贪心算法应用于解决背包问题的一种具体实现，可能是一个代码项目或者教程，以ZIP文件形式提供。这个项目可能包含了解决背包问题的源代码、解释文档或者测试案例，通过这些...
基于C语言实现贪心算法背包问题源码.zip
10-28
在这个"基于C语言实现贪心算法背包问题源码.zip"的压缩包中，我们可以看到几个关键的文件，它们是用来解决经典的背包问题的。 首先，`MergeSort.c`可能包含一个归并排序的实现。归并排序是一种分治算法，它将大问题...
遗传算法背包问题
05-04
根据给定的信息，本文将详细解释“遗传算法背包问题”的核心概念、原理及其实现细节。 ### 遗传算法背包问题概述 遗传算法（Genetic Algorithm, GA）是一种模拟自然界生物进化过程的搜索算法，它通过模拟自然选择...
【C++算法】9.双指针_四数之和
hlyd520的博客
10-04 540
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
Java 插入排序
最新发布
在那一刻，我们或许会发现自己站在了时间的另一岸，以更加成熟和宽广的胸怀，去拥抱那份隔代相传的深情。
10-08 107
插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 817
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 723
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
生成哈夫曼树
TTz012的博客
10-08 64
例如：由叶子节点：5 15 40 30 10，生成的最优二叉树如下图所示，该树的最短带权路径长度为：40 * 1 + 30 * 2 + 5 * 4 + 10 * 4 = 205。所谓树的带权路径长度，就是树中所有的叶节点的权值乘上其到根节点的路径长度（若根节点为 0 层，叶节点到根节点的路径长度为叶节点的层数）二叉树节点中，左节点权值小于右节点权值，根节点权值为左右节点权值之和。给定长度为 n 的无序的数字数组，每个数字代表二叉树的叶子节点的权值，数字数组的值均大于等于1。
python贪婪算法背包问题
09-14
贪婪算法背包问题是指在给定一组商品的价值和重量以及一个背包的最大容量的情况下，选择一些商品放入背包中，使得背包中商品的总价值最大化。贪婪算法的思想是每次选择当前价值与重量比值最高的商品放入背包中，直到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值