0-1背包问题

最新推荐文章于 2025-09-02 22:57:29 发布

little-monster

最新推荐文章于 2025-09-02 22:57:29 发布

阅读量379

点赞数 4

CC 4.0 BY-SA版权

文章标签： leetcode

本文链接：https://blog.csdn.net/weixin_45332508/article/details/137643449

本文介绍了如何使用回溯法和动态规划算法解决0-1背包问题，详细解释了两种方法的实现过程，包括递归结构和状态转移方程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

0-1背包问题

暴力–回溯法

回溯就是递归：：

参数：重量数组、价值数组、背包最大承重、每次开始的索引号startindex、当前背包中的物品总价值
递归终止条件：当背包中的物品重量超过背包承重时，返回。当背包中物品的重量不超过背包承重的时候，计算当前背包中物品的总价值。
单层遍历：遍历重量数组中从startindex开始的数。加入path中，进入下一层，回溯。

	static ArrayList<Integer> bags = new ArrayList<>(); //背包中放的物品
    static int maxValue = 0;
    //回溯法
    private static void backtracking(int[] weight, int[] value, int bagsize, int startindex, int curValue) {
        int sum = 0;
        for (int i = 0; i < bags.size(); i++) {
            sum += bags.get(i);
        }
        //超过背包重量 返回
        if (sum > bagsize){
            return;
        }else {
            maxValue=Math.max(maxValue,curValue);
        }
        //单层循环逻辑
        for (int i = startindex; i < weight.length; i++) {
            bags.add(weight[i]);
            curValue += value[i];
            backtracking(weight,value,bagsize,i+1,curValue);
            bags.remove(bags.size()-1);
            curValue -=value[i];
        }
    }

动态规划法–使用二维数组

在这里插入图片描述

需要明确的是：i和j的含义
i:第i个物品
j:背包最大承重j
dp[i][j]:背包最大承重为j的时候，从0-i个物品中任意选取物品能得到的最大价值。
递推公式：dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-weight[i]]+vaule[i])
初始化：for(weight[0]–>bagsize) 赋值为value[0] （也就是先在背包中放一个物品0）
遍历顺序
for(i=1 --> 物品个数)
for(j = 1 --> bagsize)

//动态规划法
    private static int testWeightBagProblem(int[] weight, int[] value, int bagsize) {
        //物品个数
        int goods = weight.length;
        //dp[i][j]数组的含义  i:第i个物品 j:背包的重量
        int[][] dp = new int[goods][bagsize+1];
        //初始化dp数组
        for (int j = weight[0]; j < bagsize+1; j++) {
            dp[0][j] = value[0];
        }

        //填充这个数组
        for (int i = 1; i < goods; i++) {
            for (int j = 1; j < bagsize+1; j++) {
                if (j < weight[i]){
                    dp[i][j] = dp[i-1][j];
                }else {
                    dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]);
                }
            }
        }
        return dp[goods-1][bagsize];
    }

动态规划使用一维数组

在这里插入图片描述

数组含义：j 背包承重 dp[j]：背包承重为j的时候，背包中物品的最大价值
递推公式：dp[j] = Math.max(dp[j], dp[j-weight[i]]+vaule[i])
初始化：初始化都为0 就可以了
遍历顺序
for(i =0–>物品个数)
for(j = bagsize–> weight[i])

 //动态规划法
    private static int testWeightBagProblem(int[] weight, int[] value, int bagsize) {
        //物品个数
        int goods = weight.length;
        //dp[j]数组的含义  j:背包的重量
        int[] dp = new int[bagsize+1];

        //填充这个数组
        for (int i = 0; i < goods; i++) {
            for (int j = bagsize; j >= weight[i]; j--) {
                dp[j] = Math.max(dp[j],dp[j-weight[i]]+value[i]);
            }
        }
        return dp[goods-1][bagsize];
    }