探讨背包问题

最新推荐文章于 2024-06-09 05:17:51 发布

菜汪在路上

最新推荐文章于 2024-06-09 05:17:51 发布

阅读量674

点赞数

文章标签：算法 java Powered by 金山文档

本文链接：https://blog.csdn.net/qx020814/article/details/129631921

版权

结果为时两天的折磨，对背包问题小有感悟：

题目 2131: 信息学奥赛一本通T1267-01背包问题
时间限制: 1s 内存限制: 128MB 提交: 1225 解决: 555
题目描述
一个旅行者有一个最多能装 M 公斤的背包，现在有 n 件物品，它们的重量分别是W1，W2，...,Wn,它们的价值分别为C1,C2,...,Cn，求旅行者能获得最大总价值。
输入格式
第一行：两个整数，M(背包容量，M≤200)和N(物品数量，N≤30)；
第2..N+1行：每行二个整数Wi，Ci，表示每个物品的重量和价值。
输出格式
仅一行，一个数，表示最大总价值。
样例输入复制
10 42 13 34 57 9

也许大家和我一样有个疑问，为什么要叫01背包，熟读问题三遍以上，我们便会发现，取物只有两种状态，也即是“取1”或者“不取0”。

如果将背包大小从小到大遍历，就会得到这样一个：

1、第一个条件就是：我要背包大小大于这个物品的大小，我才能拿

2、第二个是：我拿了的价值大，还是我上一个的最大价值大，并且我拿了这个值，还剩下的空间大小它的最大值加上。

定义dp[i][j]的含义，这一点也是动态规划中比较繁琐的，我们知道，一定要把一个物品的0-n所有背包大小都遍历一遍，所以背包大小要在里层循环即为j，那么i就是某个背包：

即：dp[i][j]为物品为i时，背包大小为j时的最大价值。

所以推导算式就是：

dp[i][j]=最大值（（上一个最大值）dp[i-1][j]，（拿当前物品，背包减去当前物品重量剩下的最大值）dp[i-1][j-w[i]]+v[i]（加上当前价值））

不能拿就使用上一个的最大价值dp[i-1][j];

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int big = sc.nextInt();
        int n = sc.nextInt();
        int[] w = new int[n + 1];
        int[] v = new int[n + 1];
        int[][] dp = new int[n + 1][big + 1];
        for (int i = 1; i <= n; i++) {
            w[i] = sc.nextInt();
            v[i] = sc.nextInt();
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= big; j++) {
                if (j >= w[i]) {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i]);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        System.out.println();
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= big; j++) {
                System.out.printf("%4d", dp[i][j]);
            }
            System.out.println();
        }
    }
}

所以我们总结就是：所以这个就是拿不拿，怎么拿的问题，即：背包大于当前物品大小，拿了后加上剩下空间的值（剩下空间的值一定能够在以往的步骤中找到，因为当前背包减去物品大小，是等于另一个背包大小。因为只能拿一次）。

也可以倒着算，先使用最大的背包，越来越小：

当然你输出的时候是一样的，没啥区别：

前面我们使用的是二位数组，我们发现：如果不能取，就得使用上一个物品的最大价值，

也就是dp[i-1][j]，只是i变了，j没有变，所以我们是能使用一维数组来做的：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int big = sc.nextInt();
        int n = sc.nextInt();
        int[] w = new int[n + 1];
        int[] v = new int[n + 1];
//        int[][] dp = new int[n + 1][big + 1];
        int[] dp = new int[big + 1];
        for (int i = 1; i <= n; i++) {
            w[i] = sc.nextInt();
            v[i] = sc.nextInt();
        }
        for (int i = 1; i <= n; i++) {
            for (int j = big; j >= 1; j--) {
                if (j >= w[i]) {
                    dp[j] = Math.max(dp[j], dp[j - w[i]] + v[i]);
                } else {
                    // 因为只有一行的原因，上一行的数据任然保存在当前位置中
                    // 所以很多博主并没有写上这句话，但是我们递推的时候，是有这一个程序的！
                    dp[j] = dp[j];
                }
            }
            System.out.println(Arrays.toString(dp));
        }
    }
}

01背包的问题便是这样，需要大家一步一步推理，想法与问题很简单，主要是动态规划的思想。

接下来提升一下难度，如下：

设有n种物品，每种物品有一个重量及一个价值。但每种物品的数量是无限的，同时有一个背包，最大载重量为M，今从n种物品中选取若干件(同一种物品可以多次选取)，使其重量的和小于等于M，而价值的和为最大。
输入格式
第一行：两个整数，M(背包容量，M≤200)和N(物品数量，N≤30)；
第2..N+1行：每行二个整数Wi,Ci，表示每个物品的重量和价值。
输出格式
仅一行，一个数，表示最大总价值。
样例输入
10 42 13 34 57 9
样例输出
max=12

也就是物品无限使用的背包，

首先想取物品取法

当前背包大小，能够取几个当前物品，没装满的话，剩余的寻找以往的最大值（既然装不下，就说明有一个比当前更小的背包大小）。

和01背包的区别就是，能够装多少当前物品。

取了n个物品，重量就是n*当前物品重量，价值也是如此n*当前物品的价值。

循环0-背包大小/当前物品大小，也就是最大装当前物品k。

所以只需要在01背包的基础上，小改一下：（一维数组）

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
//        10 4
//        2 1
//        3 3
//        4 5
//        7 9
        int big = sc.nextInt();
        int n = sc.nextInt();
        int[] w = new int[n + 1];
        int[] v = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            w[i] = sc.nextInt();
            v[i] = sc.nextInt();
        }
        int[] dp = new int[big + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = big; j >= 1; j--) {
                for (int k = 0; k <= j / w[i]; k++) {
                    // 第k个装不下了
                    if (k * w[i] <= j) {
                        dp[j] = Math.max(dp[j], dp[j - k * w[i]] + k * v[i]);
                    } else {
                        // 这一步虽然很鸡肋，但是，有这一步，便于理解
                        dp[j] = dp[j];
                        break;
                    }
                }
            }
            System.out.println(Arrays.toString(dp));
        }
        System.out.println("max="+dp[big]);
    }
}

二维数组版本：

推到一遍，为什么用一二维数组都可以完成。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
//        10 4
//        2 1
//        3 3
//        4 5
//        7 9
        int big = sc.nextInt();
        int n = sc.nextInt();
        int[] w = new int[n + 1];
        int[] v = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            w[i] = sc.nextInt();
            v[i] = sc.nextInt();
        }
        int[][] dp = new int[n + 1][big + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = big; j >= 1; j--) {
                for (int k = 0; k <= j / w[i]; k++) {
                    // 第k个装不下了
                    if (k * w[i] <= j) {
                        dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - k * w[i]] + k * v[i]);
                    } else {
                        // 这一步虽然很鸡肋，但是，有这一步，便于理解
                        dp[i][j] = dp[i - 1][j];
                        break;
                    }
                }
            }
        }
//        for (int i = 0; i <=n; i++) {
//            for (int j = 0; j <=big; j++) {
//                System.out.print(dp[i][j]+" ");
//            }
//            System.out.println();
//        }
        System.out.println("max=" + dp[n][big]);
    }
}

另外一个便是多重背包问题：

为了庆贺班级在校运动会上取得全校第一名成绩，班主任决定开一场庆功会，为此拨款购买奖品犒劳运动员。期望拨款金额能购买最大价值的奖品，可以补充他们的精力和体力。
输入格式
第一行二个数n(n≤500)，m(m≤6000)，其中n代表希望购买的奖品的种数，m表示拨款金额。
接下来n行，每行3个数，v、w、s，分别表示第I种奖品的价格、价值（价格与价值是不同的概念）和能购买的最大数量（买0件到s件均可），其中v≤100，w≤1000，s≤10。
输出格式
一行：一个数，表示此次购买能获得的最大的价值（注意！不是价格）。
样例输入
5 100080 20 440 50 930 50 740 30 620 20 1
样例输出
1040

就是物品取的次数指定，这个就更好理解了：

就是0到n，每次取的时候判断到底取多少更大，

import java.util.*;

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

}

以上代码都是按照简单思想实现的，另一种完全背包不好理解。

期间很折磨，但是收益颇丰啊！

菜汪在路上

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
探讨背包问题

dp[i][j]=最大值（（上一个最大值）dp[i-1][j]，（拿当前物品，背包减去当前物品重量剩下的最大值）dp[i-1][j-w[i]]+v[i]（加上当前价值））的问题，即：背包大于当前物品大小，拿了后加上剩下空间的值（剩下空间的值一定能够在以往的步骤中找到，因为当前背包减去物品大小，是等于另一个背包大小。也许大家和我一样有个疑问，为什么要叫01背包，熟读问题三遍以上，我们便会发现，取物只有两种状态，也即是“取1”或者“不取0”。即：dp[i][j]为物品为i时，背包大小为j时的最大价值。
复制链接

扫一扫