2024-02-05(背包问题）

已于 2024-02-16 17:08:22 修改
阅读量362 收藏 8
点赞数 12
分类专栏： 日志 文章标签： 算法
于 2024-02-05 18:18:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73165551/article/details/136034663
版权

背包问题

（1)01背包问题

2. 01背包问题 - AcWing题库

二维

import java.util.*;

public class Main{
    public static void main(String[] args){
        int N = 1010;
        int[][] f = new int[N][N];//表示最大价值
        int[] w = new int[N];//每件物品的价值
        int[] v = new int[N];//每件物品的体积
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();//物品总的数量
        int m = sc.nextInt();//背包的容积
        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][j], f[i - 1][j - v[i]] + w[i]);//当第i件物品的体积小于j时，才有左边右边取最大值
            }
        }
        
        System.out.print(f[n][m]);
    }
}

 一维优化

import java.util.*;

public class Main{
    public static void main(String[] args){
        int N = 1010;
        int[] f = new int[N];//表示最大价值
        int[] w = new int[N];//每件物品的价值
        int[] v = new int[N];//每件物品的体积
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();//物品总的数量
        int m = sc.nextInt();//背包的容积
        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 --){//这里原来j是从0开始的，但是由于当v[i] <= j就没有意义了，所以直接从v[i]开始
                f[j] = Math.max(f[j], f[j - v[i]] + w[i]);
            }
        }
        
        System.out.print(f[m]);
    }
}

 （2）完全背包问题

3. 完全背包问题 - AcWing题库

二维（三重循环）

import java.util.*;
import java.io.*;

public class Main{
    public static void main(String[] args)throws IOException{
        int N = 1010;
        int[] v = new int[N];
        int[] w = new int[N];
        int[][] f = new int[N][N];
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        String[] str = br.readLine().split(" ");
        int n = Integer.parseInt(str[0]);
        int m = Integer.parseInt(str[1]);
        for(int i = 1; i <= n; i ++){
            String[] arr = br.readLine().split(" ");
            v[i] = Integer.parseInt(arr[0]);
            w[i] = Integer.parseInt(arr[1]);
        }
        
        for(int i = 1; i <= n; i ++){
            for(int j = 0; j <= m; j ++){
               for(int k = 0; k * v[i] <= j; k ++){
                   //和01背包问题的主要区别在这里
                    f[i][j] = Math.max(f[i][j], f[i - 1][j - v[i] * k] + w[i] * k);
               }
            }
        }
        
        System.out.print(f[n][m]);
    }
}

二维（两重循环） 

import java.util.*;
import java.io.*;

public class Main{
    public static void main(String[] args)throws IOException{
        int N = 1010;
        int[] v = new int[N];
        int[] w = new int[N];
        int[][] f = new int[N][N];
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        String[] str = br.readLine().split(" ");
        int n = Integer.parseInt(str[0]);
        int m = Integer.parseInt(str[1]);
        for(int i = 1; i <= n; i ++){
            String[] arr = br.readLine().split(" ");
            v[i] = Integer.parseInt(arr[0]);
            w[i] = Integer.parseInt(arr[1]);
        }
        
        for(int i = 1; i <= n; i ++){
            for(int j = 0; j <= m; j ++){
               f[i][j] = f[i - 1][j];
                //和01背包问题的主要区别在这里
               if(v[i] <= j) f[i][j] = Math.max(f[i][j], f[i][j - v[i]] + w[i]);
            }
        }
        
        System.out.print(f[n][m]);
    }
}

  一维优化

import java.util.*;
import java.io.*;

public class Main{
    public static void main(String[] args)throws IOException{
        int N = 1010;
        int[] v = new int[N];
        int[] w = new int[N];
        int[] f = new int[N];
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        String[] str = br.readLine().split(" ");
        int n = Integer.parseInt(str[0]);
        int m = Integer.parseInt(str[1]);
        for(int i = 1; i <= n; i ++){
            String[] arr = br.readLine().split(" ");
            v[i] = Integer.parseInt(arr[0]);
            w[i] = Integer.parseInt(arr[1]);
        }
        
        for(int i = 1; i <= n; i ++){
            for(int j = v[i]; j <= m; j ++){
            //这里的j不需要逆序输入
               f[j] = Math.max(f[j], f[j - v[i]] + w[i]);
            }
        }
        
        System.out.print(f[m]);
    }
}

（3）多重背包问题

4. 多重背包问题 I - AcWing题库 二维（三重循环） 

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int N = 110;
        int[] v = new int[N];
        int[] w = new int[N];
        int[] s = new int[N];
        int[][] f = new int[N][N];
        for(int i = 1; i <= n; i ++){
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
            s[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 <= s[i]; k ++){//与完全背包问题的主要不同
                    f[i][j] = Math.max(f[i][j], f[i - 1][j - k * v[i]] + k * w[i]);
                }
            }
        }
        System.out.print(f[n][m]);
    }
}

 5. 多重背包问题 II - AcWing题库 （给的数据范围不一样）

二进制优化 

第一种写法 

import java.util.*;
public class Main{
    public static void main(String[] ags){
        Scanner scan = new Scanner(System.in);
        int N = 12000;
        //一个数最多就是2的12次方就会超过题目给的2000，所以1000*12
        int[] v = new int[N];
        int[] w = new int[N];
        int[] f = new int[N];
        int n = scan.nextInt();
        int m = scan.nextInt();
        
        //这个cnt是组合的个数
        int cnt = 0;
        for(int i = 0 ; i < n ; i ++ ){
            int a = scan.nextInt();//体积
            int b = scan.nextInt();//价值
            int s = scan.nextInt();//数量
            
            int k = 1;  //2的0次幂

            //将每一个s都分解成2的多少次幂合
            while(s >= k){
                cnt ++ ;  
                v[cnt] = a * k; 这个组合的体积总数
                w[cnt] = b * k; //这个组合的价值总量
                s -= k;  // s 分解成2的0到k次幂，所以每次s都要减去当前的k
                k *= 2; // k每次都乘以2
            }

            //判断k的很多次幂加起来是不是还差一点才到s
            //假设s为10，那么就是1，2，4，3
            if(s > 0){
                cnt ++;
                v[cnt] = a * s;//这里的s就是上面例子中的3
                w[cnt] = b * s;
            }
        }

        n = cnt; // 将所有组合的值赋值给n

        //用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]);
    }
}

第二种写法

import java.util.*;

//多重背包问题的二进制的第二种写法
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = 2010;
        int[] f = new int[N];
        
        int n = sc.nextInt();
        int m = sc.nextInt();
        
        for(int i = 1; i <= n; i ++){
            int v = sc.nextInt();
            int w = sc.nextInt();
            int s = sc.nextInt();
            for(int k = 1; k <= s; k *= 2){
                for(int j = m; j >= k * v; j --){
                    f[j] = Math.max(f[j], f[j - v * k] + w * k);
                }
                s -= k;
            }
            if(s > 0){
                for(int j = m; j >= s * v; j --){
                    f[j] = Math.max(f[j], f[j - v * s] + w * s);
                }
            }
        }
        System.out.print(f[m]);
    }
}

 

6. 多重背包问题 III - AcWing题库

单调队列优化 

 AcWing 6. 多重背包问题 III (包含自己的一些理解，不懂的可以看看） - AcWing

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = 1010;
        int M = 20010;
        int[][] f = new int[N][M];
        int[] q = new int[M];//单调队列
        int[] v = new int[M];//体积
        int[] w = new int[M];//价值
        int[] s = new int[M];//数量
        
        int n = sc.nextInt();//物品个数
        int m = sc.nextInt();//背包数量
        for(int i = 1; i <= n; i ++){
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
            s[i] = sc.nextInt();
        }
        
        for(int i = 1; i <= n; i ++){
            for(int r = 0; r < v[i]; r ++){//表示余数
                int hh = 0;//队头
                int tt = -1;//队尾
                for(int j = r; j <= m; j += v[i]){
                    f[i][j] = f[i - 1][j];//一开始不放物品
                    while(hh <= tt && q[hh] < j - v[i] * s[i]) ++ hh;//队头超出滑动窗口
                    //让最大的值移到队头
                    while(hh <= tt && f[i - 1][q[tt]] + (j - q[tt]) / v[i] * w[i] <= f[i - 1][j]) tt --;
                    q[++ tt] = j;
                    f[i][j] = f[i - 1][q[hh]] + (j - q[hh]) / v[i] * w[i];
                }
            }
        }
        System.out.print(f[n][m]);
    }
}

（4）分组背包问题

9. 分组背包问题 - AcWing题库

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = 110;
        int[][] v = new int[N][N];
        int[][] w = new int[N][N];
        int[] f = new int[N];
        int[] s = new int[N];
        
        int n = sc.nextInt();
        int m = sc.nextInt();
        for(int i = 1; i <= n; i ++){
            //分成n组，每一组的数量
            s[i] = sc.nextInt();
            //每一组中的物品的体积和价值
            for(int j = 1; j <= s[i]; j ++){
                v[i][j] = sc.nextInt();
                w[i][j] = sc.nextInt();
            }
        }
        
        //和01背包问题很像
        for(int i = 1; i <= n; i ++){
            for(int j = m; j >= 0; j --){
                for(int k = 0; k <= s[i]; k ++){
                    if(v[i][k] <= j) f[j] = Math.max(f[j], f[j - v[i][k]] + w[i][k]);
                }
            }
        }
        System.out.print(f[m]);
    }
}

m0_73165551
关注
  • 12
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【华为笔试题汇总】2024-05-22-华为春招笔试题-三语言题解(Python/Java/Cpp)
春秋招笔试突围
05-23 1399
给定两个链表，找出它们中相同节点值的最大连续片段。如果没有公共片段，返回 -1。第一行表示链表 1，第二行表示链表 2。每条链表长度不超过 20 个元素，链表不会为空。输出两个链表中相同节点值的最大连续片段。如果没有公共片段，返回 -1。 样例输出 数据范围 链表长度不超过 20 个元素。本题数据范围比较小，怎么做都可以，使用双重循环遍历两个链表，并在找到相同节点时，继续向后比较，直到不相同为止。记录最长的公共片段并输出。 Java Cpp 🔗 02.矿车运输成本 问题描述 露天矿
0-1背包问题-算法简洁易懂
05-23
0-1背包问题算法简洁易懂 0-1背包问题简介 0-1背包问题是算法设计中的一种经典问题。它是一个组合优化问题，属于NP-hard问题。问题的描述是：给定一组物品，每个物品都有一个价值和一个重量，要求在不超过背包容量...
2024-02-12（背包模型）
m0_73165551的博客
02-16 1456
1、当空间优化成一维之后，只有完全背包问题的体积是从小到大循环的。2、循环形式：for 物品for 体积for 决策。
力扣刷题记录-动态规划问题总结
qq_41857397的博客
09-07 560
汇总leetcode中关于动态规划的各类题目与解析，诸如背包问题、股票问题等
JSP基于JavaEE的在线学习平台3x7zl程序+源码+数据库+调试部署+开发环境
Kittyxia001的博客
08-17 691
随着互联网技术的飞速发展，在线教育已成为教育领域的重要趋势。传统教育模式受限于地域、时间等因素，难以满足广大学习者个性化、灵活化的学习需求。因此，开发一个基于JavaEE的在线学习平台，旨在打破时空限制，提供丰富多样的学习资源，促进教育资源的均衡分配，提升学习效率与效果，具有重要的现实意义和应用价值。
《信息学奥赛一本通 编程启蒙 C++版》 3471-3482（12题）
青少年趣味编程
12-06 711
《信息学奥赛一本通 编程启蒙 C++版》 3471-382（12题）
JSP基于JavaEE的自习室订座管理系统ignpx程序+源码+数据库+调试部署+开发环境
CK3041的博客
08-17 680
随着高等教育的普及，自习室成为学生自主学习的重要场所。然而，传统的人工管理方式在座位分配、预约查询等方面效率低下，难以满足学生日益增长的需求。因此，开发一套基于JavaEE的自习室订座管理系统显得尤为重要。该系统旨在通过信息化手段，实现自习室的在线预约、座位状态实时更新、历史记录查询等功能，提高管理效率，优化资源配置，为学生提供更加便捷、高效的自习环境。
算法笔记|动态规划2024/05/02（背包模型1）
正在努力的网安小菜鸟！
05-02 281
问题描述：1.每个小精灵可以看做一个物品，每个小精灵可以收服一次，对应01背包问题2.：花费1：精灵球数量，花费2：体力值，价值：小精灵的数量3.状态表示和状态计算4.输出5.体积不能小于等于0，从V2-1开始算。
spring-mvc搭建时，控制台有警告servlet配置文件
u012799877的博客
12-14 2060
警告 [http-nio-8080-exec-4] org.springframework.web.servlet.DispatcherServlet.noHandlerFound No mapping found for HTTP request with URI [/favicon.ico] in DispatcherServlet with name ‘DefaultServlet’ 搭建s...
【moeCTF题解-0x03】Algorithm
框架科工：Framecraft
11-03 840
title: 【moeCTF题解-0x03】Algorithm categories: CTF moeCTF tags: CTF 【moeCTF题解-0x03】Algorithm 计算是宇宙的本质 （并不） 这部分主要是一些数据处理题和算法题。 数据处理题用Python做较为容易。 算法题要求用C++，我不太擅长；又因都是一些经典的题目，万维网上其他大佬的题解很多，故没有去做，这个题解中会放一些其他人题解的链接。 【moeCTF题解】总目录如下： 【moeCTF题解-0x00】序 .
0-1背包_0-1背包问题_背包算法_背包_
10-04
0-1背包问题是一种经典的组合优化问题，在计算机科学和运筹学中有着广泛的应用。它源于实际生活中的装箱问题，比如如何在限定的重量限制下，选择物品以获得最大价值。在这里，我们主要探讨0-1背包问题的定义、算法...
2024-2030年背包行业市场调研及前景趋势预测报告.pdf
06-12
根据给定的文件信息，以下是对“2024-2030年背包行业市场调研及前景趋势预测报告”的详细解析与相关知识点总结： ### 一、产业核心驱动力 1. **消费升级：** - 随着消费者收入水平的提高，对背包的需求从基本的...
0-1ga_01背包问题_0-1背包问题_遗传算法_源码
10-02
0-1背包问题是一种经典的组合优化问题，在计算机科学和运筹学中有着广泛的应用。它描述的是这样的场景：有一组物品，每个物品都有一个重量和一个价值，目标是在不超过背包最大承重的情况下，选择物品以使总价值最大...
源代码_背包问题--01背包_
10-02
01背包问题是一种经典的计算机科学中的动态规划问题，主要出现在算法设计和优化的领域，尤其在求解资源分配和组合优化问题时非常常见。在这个问题中，我们有一个背包，其容量有限，同时有一系列物品，每种物品都有...
代码随想录算法训练营day30
qq_56445436的博客
09-05 437
【代码】代码随想录算法训练营day30。
树状数组记录
最新发布
volcan的博客
09-06 672
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 392
力扣刷题--1534. 统计好三元组【简单】
【算法】单词出现次数和位置统计
Hanbuhuic的博客
09-04 417
编写一个程序，用于统计一个给定单词在一段文本中出现的次数以及第一次出现的位置。如果单词在文本中出现，则输出出现次数和第一次出现的位置（位置从0开始计算）。如果单词没有出现，则输出-1。
动态规划解0-1背包问题
"这篇资源主要讨论了0-1背包问题的动态规划解决方案，以及动态规划在图问题、组合问题和查找问题中的应用。" 在计算机科学中，动态规划是一种强大的算法设计方法，常用于解决最优化问题。0-1背包问题是一个经典的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值