动态规划之背包问题（全）

已于 2023-02-10 19:44:55 修改
阅读量1.5k 收藏 2
点赞数 1
分类专栏： 动态规划 文章标签： java 动态规划 算法 Powered by 金山文档
于 2023-02-10 19:43:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63157868/article/details/128944913
版权

01背包问题

1.题目

有 N件物品和一个容量为 V的背包，每件物品有各自的价值且只能被选择一次，要求在有限的背包容量下，装入的物品总价值最大。

「0-1 背包」是较为简单的动态规划问题，也是其余背包问题的基础。

动态规划是不断决策求最优解的过程，「0-1 背包」即是不断对第 i 个物品的做出决策，「0-1」正好代表不选与选两种决定。

2.题解代码

2.1版本1 二维

（1）状态f[i][j]定义：只从前i个物品选，且选取物品总体积不超过j的最大价值

（2）状态计算（如何求f[i][j]）：将f[i][j]看作集合，划分为不包含第i个物品和包含第i个物品两类，不包含第i个物品为从前i-1个物品选，总体积不超过j所构成的集合，取最大值，即f[i-1][j]，包含第i个物品为从前i-1个物品选，总体积不超过j-vi的集合，取最大值然后加上选取物品i的权重，即f[i-1][j-vi]+wi；最后在两者之间选取最大值，即可求得f[i][j]。

（3）考虑背包容量是否大于物品i的体积:

j<v[i]: 无需考虑选取第i个物品的情况，对应代码：f[i][j] = f[i - 1][j]

j>=v[i]：选取和不选取第i个物品都得考虑， 对应代码：Math.max(f[i - 1][j], f[i - 1][j - v[i]] + w[i])

代码如下：

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[][] f = new int[n + 1][m + 1];
        int[] v = new int[n + 1];
        int[] w = new int[n + 1];
        for (int i = 1; i <= n; i ++){
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        for (int i = 1; i <= n; i ++) {
            for (int j = 0; j <= m; j ++) {
                f[i][j] = f[i-1][j];
                if (v[i] <= j){
                    f[i][j] = Math.max(f[i-1][j], f[i-1][j-v[i]] + w[i]);
                }
            }
        }
        System.out.println(f[n][m]);
    }
}

2.2版本2 一维

将状态f[i][j]优化为以为f[j], 实际上只需要做一个等价变形。

由f[i][j] = Math.max(f[i-1][j], f[i-1][j-v[i]] + w[i])我们可知，我们每次求取f[i][j]的时候，都只用到了第i-1层的数据，而且题目只需要求得最总状态f[n][m],中间状态不需要存储。，所以我们每次求第i层的数据时只需要将第i-1层的数据覆盖即可。但是注意小细节，此时在一维情况下枚举背包容量时，需要逆序遍历，因为f[j-v[i]]在f[j]的左边，如果正序遍历的话，我们用到的数据就不是第i-1层的数据了，而是刚更新过的第i层数据。

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[] f = new int[m + 1];
        int[] v = new int[n + 1];
        int[] w = new int[n + 1];
        for (int i = 1; i <= n; i ++){
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        for (int i = 1; i <= n; i ++) {
            for (int j = m; j >= v[i]; j --) {
                f[j] = Math.max(f[j], f[j-v[i]] + w[i]);
            }
        }
        System.out.println(f[m]);
    }
}

完全背包问题

1.题目

有 N种物品和一个容量是 V 的背包，每种物品都有无限件可用。

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

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

输出最大价值。

2.题解代码

2.1简单版

（1）状态f[i][j]定义：只从前i个物品选，且选取物品总体积不超过j的最大价值

（2）状态计算：将集合f[i][j]划分为分别选取0~k个物品i，再对选取物品i的个数进行枚举，限制条件为k * v[i] <= j, 然后求最大值即可。

基本代码如下：

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[] v = new int[n+1];
        int[] w = new int[n+1];
        int[][] f = new int[n+1][m+1];
        for (int i = 1; i <= n; i ++) {
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        for (int i = 1; i <= n; i ++) {
            for (int j = 0; j <= m; j ++) {
                for (int k = 0; k * v[i] <= j; k ++) {
                    f[i][j] = Math.max(f[i][j], f[i-1][j-k*v[i]] + k*w[i]);
                }
            }
        }
        System.out.println(f[n][m]);
    }
}

2.2优化版

优化思路：

f[i , j ] = max( f[i-1,j] , f[i-1,j-v]+w , f[i-1,j-2*v]+2*w , f[i-1,j-3*v]+3*w , .....)

f[i , j-v]= max( f[i-1,j-v] , f[i-1,j-2*v] + w , f[i-1,j-3*v]+2*w , .....)

由上两式，可得出如下递推关系：

f[i][j]=max(f[i,j-v]+w , f[i-1][j])

有了上面的关系，那么其实k循环可以不要了，核心代码优化成这样：

for(int i = 1 ; i <=n ;i++)
    for(int j = 0 ; j <=m ;j++)
    {
        f[i][j] = f[i-1][j];
        if(j-v[i]>=0)
            f[i][j]=max(f[i][j],f[i][j-v[i]]+w[i]);
    }

这个代码和01背包的非优化写法很像啊!!!我们对比一下，下面是01背包的核心代码

for(int i = 1 ; i <= n ; i++)
    for(int j = 0 ; j <= m ; j ++)
    {
        f[i][j] = f[i-1][j];
        if(j-v[i]>=0)
            f[i][j] = max(f[i][j],f[i-1][j-v[i]]+w[i]);
    }

两个代码其实只有一句不同（注意下标）

f[i][j] = max(f[i][j],f[i-1][j-v[i]]+w[i]);//01背包

f[i][j] = max(f[i][j],f[i][j-v[i]]+w[i]);//完全背包问题

综上所述，完全背包的最终写法如下：

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[] v = new int[n+1];
        int[] w = new int[n+1];
        int[] f = new int[m+1];
        for (int i = 1; i <= n; i ++) {
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        for (int i = 1; i <= n; i ++) {
            for (int j = v[i]; j <= m; j ++) {
                f[j] = Math.max(f[j], f[j-v[i]] + w[i]);
            }
        }
        System.out.println(f[m]);
    }
}

多重背包问题（二进制优化）

1.题目

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

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

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

输出最大价值。

2.解题代码

多重背包问题简单版和完全背包问题简单版是相同的解题思路，这里直接上优化版

在完全背包中,通过两个状态转移方程：

f[i,j]=max(f[i−1,j],f[i−1,j−v]+w,f[i−1,j−2v]+2w,f[i−1,j−3v]+3w,.....)

f[i,j−v]=max(f[i−1,j−v],f[i−1,j−2v]+w,f[i−1,j−2v]+2w,.....)

通过上述比较，可以得到f[i][j] = max(f[i-1][j],f[i][j-v]+w)

再来看下多重背包,

f[i,j] = max(f[i−1,j],f[i−1,j−v]+w,f[i−1,j−2v]+2w,.....f[i−1,j−Sv]+Sw,)

f[i,j-v] = max(f[i−1,j−v],f[i−1,j−2v]+w,.....f[i−1,j−Sv]+(S−1)w,f[i−1,j−(S+1)v]+Sw)

这里比完全背包方程多了一项，不能像完全背包一样去优化

二进制优化思路：

将每一组拥有的个数进行二进制计算，使每组进行二进制分割之后变为01背包问题，即假设有1023个；二进制的思维，将1023按照1，2，4，8，16，... ，512分到10个箱子里，根据数学知识，如何一个我们需要拿的数字x∈[0,1023]都可以用这10个箱子里的苹果数量表示出来，这样的话时间复杂度从O(n3)降到O(n2logS)

import java.util.Scanner;

public class Main{
    static int N = 12010;//逐一枚举最大是N*logS
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[] v = new int[N];
        int[] w = new int[N];
        int[] f = new int[m+1];
        int cnt = 0;
        for (int i = 1; i <= n; i ++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            int s = sc.nextInt();
            int k = 1;
            while(k <= s) {
                cnt ++;
                v[cnt] = a * k; //整体体积
                w[cnt] = b * k; // 整体价值
                s -= k; // s要减小
                k *= 2; // 组别里的个数增加
            }
            if (s > 0) {
                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] = Math.max(f[j], f[j-v[i]] + w[i]);
            }
        }
        System.out.println(f[m]);
    }
}

分组背包问题

  1. 题目

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

每组物品有若干个，同一组内的物品最多只能选一个。

每件物品的体积是 vij，价值是 wij，其中 i 是组号，j 是组内编号。

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

输出最大价值。

2.题解代码

（1）状态f[i][j]定义：只从前i组物品选，且选取物品总体积不超过j的最大价值

（2）状态计算（如何求f[i][j]）：将f[i][j]看作集合，划分为不包含第i组的物品和包含第i组的第k个物品两类，不包含第i组的物品为从前i-1组物品选，总体积不超过j所构成的集合，取最大值，即f[i-1][j]，包含第i组的第k个物品为从前i-1个物品选，总体积不超过j-v[i,k]的集合，取最大值然后加上选取第i组物品的第k个物品的权重，即f[i-1][j-v[i,k]]+w[i,k]；最后在两者之间选取最大值，即可求得f[i][j]。

代码如下：

import java.util.Scanner;

public class Main{
    static int N = 110;
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[][] v = new int[n+1][N];
        int[][] w = new int[n+1][N];
        int[] s = new int[n+1];
        int[][] f = new int[n+1][m+1];
        for (int i = 1; i <= n; i ++) {
            s[i] = sc.nextInt();
            for (int j = 1; j <= s[i]; j ++) {
                v[i][j] = sc.nextInt();
                w[i][j] = sc.nextInt();
            }
        }
        
        for (int i = 1; i <= n; i ++) {
            for (int j = 0; j <= m; j ++) {
                f[i][j] = f[i-1][j];
                for (int k = 0; k <= s[i]; k ++) {
                    if (j >= v[i][k]){
                        f[i][j] = Math.max(f[i][j], f[i-1][j-v[i][k]] + w[i][k]);   
                    }
                }
            }
        }
        System.out.println(f[n][m]);
    }
}

因为只用到了第i-1列，所以可以仿照01背包的套路逆向枚举体积

import java.util.Scanner;

public class Main{
    static int N = 110;
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[][] v = new int[n+1][N];
        int[][] w = new int[n+1][N];
        int[] s = new int[n+1];
        int[] f = new int[m+1];
        for (int i = 1; i <= n; i ++) {
            s[i] = sc.nextInt();
            for (int j = 1; j <= s[i]; j ++) {
                v[i][j] = sc.nextInt();
                w[i][j] = sc.nextInt();
            }
        }
        
        for (int i = 1; i <= n; i ++) {
            for (int j = m; j >= 0; j --) {
                for (int k = 1; k <= s[i]; k ++) {
                    if (j >= v[i][k]){
                        f[j] = Math.max(f[j], f[j-v[i][k]] + w[i][k]);   
                    }
                }
            }
        }
        System.out.println(f[m]);
    }
}

force bo
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划 完全背包问题.cpp
10-13
动态规划之完全背包问题。 完全背包是在N种物品中选取若干件（同一种物品可多次选取）放在空间为V的背包里，每种物品的体积为C1，C2，…，Cn，与之相对应的价值为W1,W2，…，Wn.求解怎么装物品可使背包里物品总价值最大。
【动态规划】背包问题（详细总结，很全）
m0_51370744的博客
10-07 2万+
暴力的解法是指数级别的时间复杂度。进而才需要动态规划的解法来进行优化！背包问题是动态规划（Dynamic Planning） 里的非常重要的一部分,关于几种常见的背包，其关系如下：在解决背包问题的时候，我们通常都是按照如下五部来逐步分析，把这五部都搞透了，算是对动规来理解深入了。二维dp数组01背包，先遍历物品还是先遍历背包都是可以的，且第二层for循环是从小到大遍历一维dp数组01背包，只能先遍历物品再遍历背包容量，且第二层for循环是从大到小遍历。求组合数：外层遍历物品，内层遍历背包。
算法学习17-动态规划01：背包问题
lenard-lhz的博客
04-02 1457
💕💕💕。
背包问题大全（动态规划）
热门推荐
weixin_45746505的博客
05-02 5万+
背包问题是动态规划非常重要的一类问题，它有很多变种，但题目万变不离其宗。我们需要抓住关键的解题思路。
01背包问题
ccc369639963的博客
01-19 1万+
01背包问题 商店的货架上摆放着不同重量和价值的商品，一个小偷在商店行窃，他携带的背包只能装固定重量的商品。装哪些商品才能获得最大的收益呢？在限定条件内找到最佳的物品组合，这样的问题统称为背包问题。 根据限定的条件不同，背包问题还可以细分： 部分背包问题：所有物品是可再分的，即允许将某件物品的一部分（例如 1/3）放入背包； 0-1 背包问题：所有物品不可再分，要么整个装入背包，要么放弃，不允许出现“仅选择物品的 1/3 装入背包”的情况； 完全背包问题：不对每一件物品的数量做限制，同一件物品可以选择多个装
背包问题（四种）
m0_53565874的博客
03-02 1万+
背包问题 文章目录背包问题一、背包模型（定义）二、01背包题目输入格式输出格式数据范围输入样例输出样例：题意思路二维AC代码一维AC代码三、完全背包题目输入格式输出格式数据范围输入样例输出样例：思路1朴素TLE代码思路2二维AC代码一维AC代码四、多重背包多重背包问题I题目输入格式输出格式数据范围输入样例输出样例：思路暴力AC代码多重背包问题II题目输入格式输出格式数据范围提示：输入样例输出样例：AC代码五、分组背包题目输入格式输出格式数据范围输入样例输出样例：思路AC代码 一、背包模型（定义） 01背包：
动态规划之背包问题
m0_64226820的博客
07-26 8649
动态规划的背包问题总结
C++动态规划之背包问题解决方法
09-03
在计算机科学中，背包问题是一种经典的优化问题，经常被用来作为动态规划的示例。这里我们将深入探讨如何使用C++来解决背包问题。 背包问题的基本设定是：有一个固定容量的背包（最大容量为W），以及N件物品，每件...
背包问题动态规划.zip
01-21
背包问题动态规划.zip
动态规划专题之多重背包问题1
08-08
在本文中，我们将深入探讨一个具体的动态规划问题，即多重背包问题。多重背包问题与经典的0-1背包问题有所不同，它允许每种物品可以被选择多次，直至达到其最大数量限制。 题目描述了一个动态规划专题，其中涉及一...
动态规划解决01背包问题
01-17
01背包是在M件物品取出若干件放在空间为W的背包里，每件物品的体积为W1...动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。
动态规划专题——背包问题
⚡
02-13 3万+
详解四种背包：01背包、完全背包、多重背包、分组背包。
背包问题看这一篇就够了（详细版）
qq_54779611的博客
07-28 1万+
我们常说的背包问题其实分为好多种主要分为以下几种：01背包，完全背包，多重背包，分布背包。 所有的背包问题都是在有限V体积的背包中挑选物品，物品的属性分为w[i],v[i]表示第i个物品的价值和体积。从中找出那个能得到最大价值的选物品的方案。 通俗的来讲就是给你一个背包让你去装钻石每个钻石的价值和体积都是不一样的，最后你要装到最大价值的钻石。然后输出最大价值。 想要搞清楚这几种背包首先应该明白这几种背包的区别： 01背包 （每个物品只有一个，要么只选一个要么不选） 完全背包（每个物品有无数多个）
【算法与数据结构】—— 动态规划之背包问题
酱懵静的博客
03-15 2万+
背包问题分为多种，其中最常见的主要是三类：01背包、完全背包、多重背包。这里面最经典的是01背包问题，它基本上已经成为了事实上的动态规划入门级必学算法。下面，我们将对上述的三类背包问题逐个分析。
动态规划-背包问题
qq_52147470的博客
06-06 2366
算法、背包问题、动态规划
【动态规划】背包问题题型及方法归纳
STAR GAME
02-16 5388
背包问题是在规定背包容量为j的前提下，每个物品对应的体积为v[i]，价值为w[i]，从物品0到物品i中选择物品放入背包中，。
【动态规划算法】背包问题——0/1背包问题，多目标优化背包问题详解与示例
qq_35831906的博客
11-13 8949
背包问题是动态规划中的一个经典问题，通常有两种主要变种：0/1 背包问题和背包问题（Fractional Knapsack Problem）。这里我们先详细解释0/1背包问题再介绍背包问题的变种。
动态规划-- 背包问题
qq_48094059的博客
07-18 2954
动态规划--背包问题
动态规划完全背包问题
最新发布
06-05
完全背包问题就是一个经典的动态规划问题，它是指在有限的物品中选取若干件放入一个容量为V的背包中，每种物品都有无限件可用，求背包能够装下的最大价值。 完全背包问题可以使用动态规划来解决，具体地，我们可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值