背包问题

最新推荐文章于 2022-06-15 23:11:33 发布
最新推荐文章于 2022-06-15 23:11:33 发布
阅读量177 收藏
点赞数 1
分类专栏： leetcode刷题记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ccnuacmhdu/article/details/103310063
版权

一、01背包

Bone Collector HDU - 2602

Many years ago , in Teddy’s hometown there was a man who was called “Bone Collector”. This man like to collect varies of bones , such as dog’s , cow’s , also he went to the grave …
The bone collector had a big bag with a volume of V ,and along his trip of collecting there are a lot of bones , obviously , different bone has different value and different volume, now given the each bone’s value along his trip , can you calculate out the maximum of the total value the bone collector can get ?

在这里插入图片描述
在这里插入图片描述
【题解】

import java.util.*;

public class Main {
    // 注意坑点。。。每个物品的容量也有可能是0而价值大于0啊。。。
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int T = scanner.nextInt();
        for(int t = 0; t < T; t++){
            int N = scanner.nextInt();
            int V = scanner.nextInt();
            int[] value = new int[N];
            int[] volume = new int[N];
            for(int i = 0; i < N; i++){
                value[i] = scanner.nextInt();
            }
            for(int i = 0; i < N; i++){
                volume[i] = scanner.nextInt();
            }
            int ans = zeroOneBackpack3(V, N, value, volume);
            System.out.println(ans);
        }
    }

    // 1. 记忆化搜索（暴力递归超时，改成记忆化搜索）
    private static int zeroOneBackpack(int V, int N, int[] value, int[] volume){
        int[][] dp = new int[V+1][N];
        for(int i = 0; i <= V; i++){
            Arrays.fill(dp[i], -1);
        }
        return f(V, value, volume, N-1, dp);
    }
    // （关键）容量为V的包放入前i个物品，所获的最大价值
    private static int f(int V, int[] value, int[] volume, int i, int[][] dp){
        if(i < 0 || V < 0){ // 注意这里V=0时，也有可能放物品，因为物品有可能容量是0但价值大于0
            return 0;
        }
        if(dp[V][i] != -1){
            return dp[V][i];
        }
        if(V < volume[i]){
            return dp[V][i] = f(V, value, volume, i-1, dp);
        }
        return dp[V][i] = Math.max(f(V, value, volume, i-1, dp), f(V-volume[i], value, volume, i-1, dp) + value[i]);
    }

    // 2. 动态规划（分析暴力递归或记忆化搜索表，找到递推依赖关系，直接改成此）
    private static int zeroOneBackpack2(int V, int N, int[] value, int[] volume){
        int[][] dp = new int[V+1][N];
        for(int k = 0; k <= V; k++){
            dp[k][0] = volume[0] > k ? 0 : value[0];
        }
        for(int j = 1; j < N; j++){
            for(int v = 0; v <= V; v++){
                if(volume[j] > v){
                    dp[v][j] = dp[v][j-1];
                }else{
                    dp[v][j] = Math.max(dp[v][j-1], dp[v-volume[j]][j-1]+value[j]);
                }
            }
        }
        return dp[V][N-1];
    }

    // 3.动态规划（状态压缩），分析递推表发现，(i,j)位置的值仅取决于(k,j-1)的值，其中k<=i。
    // 参考易误点分析图，压缩为一位数组后，应该采用自下而上递推。
    // 自下而上推导，下面的值确定后，不会影响上面的值。
    // 自上而下推导，上面的值会影响下面的值。
    private static int zeroOneBackpack3(int V, int N, int[] value, int[] volume){
        int[] dp = new int[V+1];
        for(int k = 0; k <= V; k++){
            dp[k] = volume[0] > k ? 0 : value[0];
        }
        for(int j = 1; j < N; j++){
            for(int v = V; v >= volume[j]; v--){
                dp[v] = Math.max(dp[v], dp[v-volume[j]]+value[j]);
            }
        }
        return dp[V];
    }
}

关于递归改动态规划？
递归函数参数有几个是可变值，就对应几维数组即几维表格（状态确定），然后根据递归方程分析状态转移表，确定动态规划转移方程，再根据递归结束条件对状态进行初始化。

关于状态压缩的时候的易错点分析？
在这里插入图片描述

二、完全背包

寒冰王座 HDU - 1248

在这里插入图片描述在这里插入图片描述
【题解】

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] volume = {150, 200, 350};
        int[] value = {150, 200, 350};
        int T = scanner.nextInt();
        while (T-- > 0){
            int n = scanner.nextInt();
            int ans = n - completeBackpack4(n, volume, value);
            System.out.println(ans);
        }
    }
    // 1.普通递归（容易改成记忆化搜索，略）
    private static int completeBackpack(int V, int[] volume, int[] value){
        return f1(V, volume, value, volume.length-1);
    }
    // （关键）类比于01背包，容量为V，放入前i种物品，产生的最大价值，每种物品最多可以用V/volume[i]次
    // （关键）f(V, i) = max(f(V-k*volume[i], i-1) + k*value[i]), k取值:[0,V/volume[i]]
    private static int f1(int V, int[] volume, int[] value, int i){
        if(i < 0 || V < 0){
            return 0;
        }
        int ans = 0;
        for(int k = 0; k*volume[i] <= V; k++){
            ans = Math.max(ans, f1(V-k*volume[i], volume, value, i-1) + k*value[i]);
        }
        return ans;
    }

    // 2.动态规划
    private static int completeBackpack2(int V, int[] volume, int[] value){
        int[][] dp = new int[V+1][volume.length];
        for(int k = 0; k <= V; k++){
            dp[k][0] = k/volume[0]*value[0];
        }
        for(int j = 1; j < volume.length; j++){
            for(int v = 0; v <= V; v++){
                int ans = 0;
                for(int p = 0; p*volume[j] <= v; p++){
                    ans = Math.max(ans, dp[v-p*volume[j]][j-1] + p*value[j]);
                }
                dp[v][j] = ans;
            }
        }
        return dp[V][volume.length-1];
    }

    // 3.动态规划（状态压缩）
    private static int completeBackpack3(int V, int[] volume, int[] value){
        int[] dp = new int[V+1];
        for(int k = 0; k <= V; k++){
            dp[k] = k/volume[0]*value[0];
        }
        for(int j = 1; j < volume.length; j++){
            for(int v = V; v >= 0; v--){
                int ans = 0;
                for(int p = 0; p*volume[j] <= v; p++){
                    ans = Math.max(ans, dp[v-p*volume[j]] + p*value[j]);
                }
                dp[v] = ans;
            }
        }
        return dp[V];
    }
    // 4.转成01背包（同时用二进制优化，采用01背包最终的优化版本）
    // 虽说某种物品数量无限，但总容量空间有限。可以把物品拆分成0，2^0, 2^1, 2^2,……, 这些数字组合可在
    // 总容量允许的范围内取得任意值。如果不二进制优化直接转为01背包，物品的数量大大增加。。。
    // 注意这里和多重背包不同，因为物品数量无限，所以可以一直无穷的二进制下去，人家用不用不管，反正人
    // 家有的是啊。。。所以没错啊。。。但多重背包就必须那么保守的处理了啊。。因为你数量有限啊。。。
    private static int completeBackpack4(int V, int[] volume, int[] value){
        int[] dp = new int[V+1];
        for(int k = 0; k <= V; k++){
            dp[k] = k/volume[0]*value[0];
        }
        for(int j = 1; j < volume.length; j++){
            for(int p = 0; p*volume[j] <= V; p = (p==0) ? 1 : (p <<= 1)) { // 二进制优化
                for (int v = V; v >= p*volume[j]; v--) {
                    dp[v] = Math.max(dp[v], dp[v - p*volume[j]] + p*value[j]);
                }
            }
        }
        return dp[V];
    }
    // 5.公式推导优化。。。
    // (1) f(V, i) = max(f(V-k*volume[i], i-1) + k*value[i]), k取值:[0,V/volume[i]]
    // (2) f(V, i) = max(f(V, i-1), f(V-k*volume[i], i-1) + k*value[i]), k取值:[1, V/volume[i]]
    // (3) f(V, i) = max(f(V, i-1), max(f(V-volume[i] - k*volume[i], i-1) + k*value[i]) + value[i]), k取值:[0, V/volume[i]-1]
    // (1)带入(3)得到(4)
    // (4) f(V, i) = max(f(V, i-1), f(V-volume[i], i) + value[i])
    // 由上述(4)式容易写出递归函数或动态规划，下面只给出动态规划经过状态压缩的最终形式
    private static int completeBackpack5(int V, int[] volume, int[] value){
        int[] dp = new int[V+1];
        for(int k = 0; k <= V; k++){
            dp[k] = k/volume[0]*value[0];
        }
        for(int j = 1; j < volume.length; j++){
            for(int v = volume[j]; v <= V; v++){
                dp[v] = Math.max(dp[v], dp[v-volume[j]] + value[j]);
            }
        }
        return dp[V];
    }
}

三、多重背包

和完全背包解法基本相同。要么直接转成01背包，要么模仿01背包的递归思路写出类似代码，然后改成记忆化搜索或动态规划再状态压缩。

悼念512汶川大地震遇难同胞——珍惜现在，感恩生活 HDU - 2191

在这里插入图片描述
在这里插入图片描述
【题解】

package test;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int T = scanner.nextInt();
        while (T-- > 0){
            int n = scanner.nextInt();
            int m = scanner.nextInt();
            int[] volume = new int[m];
            int[] value = new int[m];
            int[] count = new int[m];
            for(int i = 0; i < m; i++){
                volume[i] = scanner.nextInt();
                value[i] = scanner.nextInt();
                count[i] = scanner.nextInt();
            }
            int ans = multipleBackpack4(n, m, volume, value, count);
            System.out.println(ans);
        }
    }
    // 1.记忆化搜索
    private static int multipleBackpack(int V, int N,  int[] volume, int[] value, int[] count){
        int[][] dp = new int[V+1][N];
        for(int i = 0; i <= V; i++){
            Arrays.fill(dp[i], -1);
        }
        return f(V, volume, value, count, N-1, dp);
    }
    // （关键）类比于01背包，容量为V，放入前i种物品，产生的最大价值，每种物品最多可以用count[i]次
    // （关键）f(V, i) = max(f(V-k*volume[i], i-1) + k*value[i]), k取值:[0,Math.min(count[i], V/volume[i])]
    private static int f(int V, int[] volume, int[] value, int[] count, int i, int[][] dp){
        if(i < 0 || V < 0){
            return 0;
        }
        if(dp[V][i] != -1){
            return  dp[V][i];
        }
        int ans = 0;
        for(int k = 0; k <= Math.min(count[i], V/volume[i]); k++){
            ans = Math.max(ans, f(V-k*volume[i], volume, value, count, i-1, dp) + k*value[i]);
        }
        return dp[V][i] = ans;
    }

    // 2.动态规划
    private static int multipleBackpack2(int V, int N,  int[] volume, int[] value, int[] count){
        int[][] dp = new int[V+1][N];
        for(int k = 0; k <= V; k++){
            dp[k][0] = Math.min(k/volume[0], count[0])*value[0];
        }
        for(int j = 1; j < N; j++){
            for(int v = 0; v <= V; v++){
                int ans = 0;
                for(int p = 0; p <= Math.min(v/volume[j], count[j]); p++){
                    ans = Math.max(ans, dp[v-p*volume[j]][j-1] + p*value[j]);
                }
                dp[v][j] = ans;
            }
        }
        return dp[V][N-1];
    }

    // 3.动态规划（状态压缩）
    private static int multipleBackpack3(int V, int N,  int[] volume, int[] value, int[] count){
        int[] dp = new int[V+1];
        for(int k = 0; k <= V; k++){
            dp[k] = Math.min(k/volume[0], count[0])*value[0];
        }
        for(int j = 1; j < N; j++){
            for(int v = V; v >= 0; v--){
                int ans = 0;
                for(int p = 0; p <= Math.min(v/volume[j], count[j]); p++){
                    ans = Math.max(ans, dp[v-p*volume[j]] + p*value[j]);
                }
                dp[v] = ans;
            }
        }
        return dp[V];
    }
    // 4.转成01背包问题（同时使用二进制优化，并使用01背包的最终优化版本）
    // 举例，V=10，某种物品可拆成1，2，4，(10-7)=3，为啥这么拆之后确能凑出[1, 10]所有数，待证明
    private static int multipleBackpack4(int V, int N, int[] volume, int[] value, int[] count){
        List<Integer> volumeList = new ArrayList<>();
        List<Integer> valueList = new ArrayList<>();
        int total = 0;
        for(int i = 0; i < N; i++){
            int j = 0;
            for(; (1<<(j+1)) - 1 < count[i]; j++){
                total++;
                volumeList.add(volume[i]*(1<<j));
                valueList.add(value[i]*(1<<j));
            }
            int remain = count[i] - (1<<j) + 1;
            if(remain <= 0){
                continue;
            }
            total++;
            volumeList.add(volume[i]*remain);
            valueList.add(value[i]*remain);
        }
        int[] valueNew = new int[valueList.size()];
        int[] volumeNew = new int[volumeList.size()];
        for(int i = 0; i < valueList.size(); i++){
            valueNew[i] = valueList.get(i);
            volumeNew[i] = volumeList.get(i);
        }
        return zeroOneBackpack3(V, total, valueNew, volumeNew);
    }
    private static int zeroOneBackpack3(int V, int N, int[] value, int[] volume){
        int[] dp = new int[V+1];
        for(int k = 0; k <= V; k++){
            dp[k] = volume[0] > k ? 0 : value[0];
        }
        for(int j = 1; j < N; j++){
            for(int v = V; v >= volume[j]; v--){
                dp[v] = Math.max(dp[v], dp[v-volume[j]]+value[j]);
            }
        }
        return dp[V];
    }
}

四、二维费用背包

474. 一和零

在这里插入图片描述

【代码1】超时—递归

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        return f(strs, m, n, strs.length-1);
    }
    private int f(String[] strs, int m, int n, int i){
        if(i < 0){
            return 0;
        }
        int c0 = 0;
        for(int k = 0; k < strs[i].length(); k++){
            if(strs[i].charAt(k) == '0'){
                c0++;
            }
        }
        int c1 = strs[i].length() - c0;
        if(m < c0 || n < c1){
            return f(strs, m, n, i-1);
        }
        return Math.max(f(strs, m, n, i-1), f(strs, m-c0, n - c1, i-1) + 1);
    }
}

【代码2】通过—记忆化搜索

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][][] dp = new int[m+1][n+1][strs.length];
        for(int i = 0; i <= m; i++){
            for(int j = 0; j <= n; j++){
                for(int k = 0; k < strs.length; k++){
                    dp[i][j][k] = -1;
                }
            }
        }
        int[] cnt0 = new int[strs.length];
        int[] cnt1 = new int[strs.length];
        for(int i = 0; i < strs.length; i++){
            int c0 = 0;
            for(int k = 0; k < strs[i].length(); k++){
                if(strs[i].charAt(k) == '0'){
                    c0++;
                }
            }
            int c1 = strs[i].length() - c0;
            cnt0[i] = c0;
            cnt1[i] = c1;
        }
        return f(cnt0, cnt1, m, n, strs.length-1, dp);
    }
    // 二维费用背包问题。m个0，n个1，前i个字符串，最多能消耗掉多少个字符串
    private int f(int[] cnt0, int[] cnt1, int m, int n, int i, int[][][] dp){
        if(i < 0){
            return 0;
        }
        if(m >= 0 && n >= 0 && dp[m][n][i] != -1){
            return dp[m][n][i];
        }
        if(m < cnt0[i] || n < cnt1[i]){
            return dp[m][n][i] = f(cnt0, cnt1, m, n, i-1, dp);
        }
        return dp[m][n][i] = Math.max(f(cnt0, cnt1, m, n, i-1, dp), f(cnt0, cnt1, m-cnt0[i], n - cnt1[i], i-1, dp) + 1);
    }
}

【代码3】通过—动态规划

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[] cnt0 = new int[strs.length];
        int[] cnt1 = new int[strs.length];
        for(int i = 0; i < strs.length; i++){
            int c0 = 0;
            for(int k = 0; k < strs[i].length(); k++){
                if(strs[i].charAt(k) == '0'){
                    c0++;
                }
            }
            int c1 = strs[i].length() - c0;
            cnt0[i] = c0;
            cnt1[i] = c1;
        }
        int[][][] dp = new int[m+1][n+1][strs.length];
        for(int i = 0; i <= m; i++){
            for(int j = 0; j <= n; j++){
                dp[i][j][0] = (i >= cnt0[0] && j >= cnt1[0]) ? 1 : 0;
            }
        }
        for(int k = 1; k < cnt0.length; k++){
            for(int i = 0; i <= m; i++){
                for(int j = 0; j <= n; j++){
                    if(i >= cnt0[k] && j >= cnt1[k]){
                        dp[i][j][k] = Math.max(dp[i][j][k-1], dp[i-cnt0[k]][j-cnt1[k]][k-1] + 1);
                    }else{
                        dp[i][j][k] = dp[i][j][k-1];
                    }
                }
            }
        }
        return dp[m][n][cnt0.length-1];
    }
}

【代码4】通过—动态规划（状态压缩）

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[] cnt0 = new int[strs.length];
        int[] cnt1 = new int[strs.length];
        for(int i = 0; i < strs.length; i++){
            int c0 = 0;
            for(int k = 0; k < strs[i].length(); k++){
                if(strs[i].charAt(k) == '0'){
                    c0++;
                }
            }
            int c1 = strs[i].length() - c0;
            cnt0[i] = c0;
            cnt1[i] = c1;
        }
        int[][] dp = new int[m+1][n+1];
        for(int i = 0; i <= m; i++){
            for(int j = 0; j <= n; j++){
                dp[i][j] = (i >= cnt0[0] && j >= cnt1[0]) ? 1 : 0;
            }
        }
        for(int k = 1; k < cnt0.length; k++){
            for(int i = m; i >= cnt0[k]; i--){
                for(int j = n; j >= cnt1[k]; j--){
                    dp[i][j] = Math.max(dp[i][j], dp[i-cnt0[k]][j-cnt1[k]] + 1);
                }
            }
        }
        return dp[m][n];
    }
}
Only you, only you!
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
背包问题模板 hdu2191
06-24
背包问题的模板，可以解决各类背包问题，根据问题需要修改参数即可。试用于ACM初学者。
背包问题Matlab求解
05-28
标题中的“背包问题Matlab求解”指的是使用Matlab编程解决经典的组合优化问题——背包问题。背包问题是一个在有限的背包容量下，选择物品以最大化总价值的问题。它广泛应用于资源分配、项目选择等领域。 首先，我们...
hdu 背包问题
Wenxin_Shen的博客
06-30 271
背包问题： 知识点回顾：传送门：https://blog.csdn.net/yandaoqiusheng/article/details/84782655/ 0 1 背包问题（带排序） hdu 3466 传送门：http://acm.hdu.edu.cn/showproblem.php?pid=3466 题目：最近，iSea去了一个古老的国家。这么长时间以来，它是世界上最富有和最强大的王国。结果，即使这个国家不再富裕，这个国家的人民仍然感到非常自豪。 商家是最典型的商家，每个商家仅售出一件商品
背包 习题HDU
qq_41681845的博客
08-19 182
01背包 HDU 2602 #include<iostream> #include<cstring> using namespace std; const int N=1010; int f[N]; int val[N],vol[N]; int main() { int T; cin>>T; while(T--) { int n,V; ...
背包问题（hdu 2602）
chu_jian86a的博客
12-20 351
Bone Collector Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 42848    Accepted Submission(s): 17852 Problem Description Many years ag
简单的背包问题（入门）HDU2602 HDU2546 HDU1864
u011044759的专栏
03-08 977
动态规划，我一直都不熟悉，因为体量不够，所以今天开始努力地学习学习。 当然背包从01开始，特意选了一道HDU的简单背包问题。HDU的2546。 题目很简单：  电子科大本部食堂的饭卡有一种很诡异的设计，即在购买之前判断余额。如果购买一个商品之前，卡上的剩余金额大于或等于5元，就一定可以购买成功（即使购买后卡上余额为负），否则无法购买（即使金额足够）。所以大家都希望尽量使卡上的余额最少。 某
3-增量背包问题四类实例
09-03
增量背包问题（Incremental Knapsack Problem，IKP）是组合优化领域中的一个经典问题，源于实际生活中的资源分配和决策制定。在这个问题中，我们有一组物品，每种物品都有一个价值和一个重量，以及一个固定数量的...
01背包问题_01背包问题_
10-04
01背包问题是一种经典的组合优化问题，广泛应用于资源分配、任务调度等领域。在这个问题中，我们有一个容量为W的背包，以及n件物品，每件物品都有一个重量w[i]和一个价值v[i]。目标是选取不超过背包容量的物品，使得...
完全背包问题
01-08
完全背包问题就是指已知一个体积为m的背包，共有n种物品，其中每种物品有其特定的体积v[i], 和权重w[i]，每种物品有无限个，要求从中选取物品装进背包，使总权值最大。 首先是总体需要弄清楚的模板发： 状态计算...
背包问题介绍背包问题.zip
最新发布
03-21
【背包问题】是一种经典的组合优化问题，在计算机科学和运筹学中有着广泛的应用。它源自于实际生活中的物品装箱问题，例如在有限的行李箱空间内如何选择物品以达到最大价值或最小重量。在数学建模中，背包问题通常...
HDU 1203 01背包问题
ACM,再见！
03-02 874
http://acm.hdu.edu.cn/showproblem.php?pid=1203 Problem Description Speakless很早就想出国，现在他已经考完了所有需要的考试，准备了所有要准备的材料，于是，便需要去申请学校了。要申请国外的任何大学，你都要交纳一定的申请费用，这可是很惊人的。Speakless没有多少钱，总共只攒了n万美元。他将在m个学校中选择若
HDU2602_01背包问题
Cambridge_blue9的博客
04-24 306
01背包（ZeroOnePack）:         有N件物品和一个容量为V的背包。（每种物品均只有一件，可以选择放或不放）第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。用子问题定义状态：即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是：f[i][v]=max{f[i-1][v],f[i-1][v-c[i]
背包问题（01 hdu——2602&&多重hdu——1114Piggy-Bank）
ZMST的博客
08-21 255
断断续续动态规划学了五天了都要，今天一定要吧背包问题解决完去学STL 1、01背包问题： 有n件物品，每件物品的重量为W[i],价值为c[i]. 现有一个容量为V的背包，问如何选取物品放入背包，使得背包内物品的总价值最大 其中每种物品都只有1件 【分析】 令dp[i][v]表示前i件物品恰好装入容量为v的背包中所能获得的最大价值 考虑对第i件物品的选择策略，有两种策略： ①不放第i...
hdu 1114完全背包问题
liwei的专栏
09-20 623
题意：给定t，t个用例；给定E，F，分别表示空的存钱罐的重量和装了钱之后的重量。给定价值和重量，求最少的价值。 思路：这个和01背包相似，只不过内循环相反而已，可以转化为01背包，所以01背包的代码加以修改即可AC，但是注意，这里求的是最少的，所以改的还是挺多的；除了第一个为0外，其他的都设为比较大的值，以便确定最后比它小的值方可求出最小值…… #include using namespa
【更新】01背包问题 HDU 2602 新生赛B题题解
超逸の学习技术博客
02-21 787
HDU - 2602 （01背包问题+详解+最强） Many years ago , in Teddy’s hometown there was a man who was called “Bone Collector”. This man like to collect varies of bones , such as dog’s , cow’s , also he went to the g...
HDU2602/HDU1114/HDU2191(重新整理一下01背包，完全背包，多重背包)
riba2534的博客
01-11 3585
好长时间不做背包的问题，有一点遗忘，现在把这些问题整理一下~ 一.01背包(HDU2602) 题目：http://acm.hdu.edu.cn/showproblem.php?pid=2602 题意就是普通的01背包，给出n种物品和背包容量，给出每种物品的重量和价值，求当前背包最多能达到的价值.(c[i]表示价值，w[i]表示重量) 在二维中，dp[i][j]表示把前i件物品放入容量为v的
JZOJ1517.2017.05.27【提高组】模拟赛C组 T1背包问题
路人黑的纸巾
05-28 439
Description从T组物品中选出一些物品，放入背包中，求剩余空间的最小值。 限制条件：从每组物品中挑选物品必须要选取连续的一段。就是说，如果这组物品共有n个： 物品1、物品2、物品3、…、物品n，那么只能选取物品i、物品i+1、…、物品j，其中1<=i<=j<=n,或者不选。Input第一行为两个用空格隔开的正整数v和T。表示背包的空间和物品的组数。接下来有T行，每行先是一个正整数ni，表示
背包问题精讲2018-08-09
qq_42875611的博客
08-09 120
第一道题：https://www.luogu.org/problemnew/show/P1060 这道题就是一道非常的01背包模板，不过需要注意到题目的条件还需要乘上重要性，也就是价值=原价值*重要度，其他的就按照01背包模板照打即可。 附上代码吧: #include &amp;amp;amp;amp;amp;amp;amp;lt;bits/stdc++.h&amp;amp;amp;amp;amp;amp;amp;gt; using namespace std; const
左神算法中级班第五课[C++代码]
qhu1600417010的博客
06-15 318
左神算法中级班第五课
背包九讲超级版
11-18
第二讲完全背包问题则是介绍了背包问题的另一种基本模型，即每种物品可以放无限多次。在这种情况下，状态转移方程也有所不同，需要对每种物品的放入次数进行考虑，从而得出最大的总价值。详细介绍了完全背包问题的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值