01背包问题

最新推荐文章于 2016-10-11 00:07:32 发布
最新推荐文章于 2016-10-11 00:07:32 发布
阅读量377 收藏
点赞数
分类专栏： 程序 文章标签： 01背包 动态规划 递归 非递归 记忆化搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fan2012huan/article/details/52528393
版权

小偷有一个容量为W的背包，有n件物品，第i个物品价值vi，且重wi
目标: 找到xi使得对于所有的xi = {0, 1}
sum(wi*xi) <= W, 并且 sum(xi*vi)最大

递归代码

package org.fan.learn.dp;

/**
 * Created by fan on 2016/9/13.
 */
public class Bag {


    public static int[][] result;

    public static final int MAX_INT = 1000000;

    public static final int BAG_MAX_WEIGHT = 12;
    public static final int PRODUCT_COUNTS = 5;
//    public static final int[] WEIGHTS = {1,9,3};
//    public static final int[] VALUES = {6,2,3};
//    public static final int[] WEIGHTS = {3,4,5};
//    public static final int[] VALUES = {3,4,6};
    public static final int[] WEIGHTS = {2, 2, 6, 5, 4};
    public static final int[] VALUES = {6, 3, 5, 4, 6};
    //这个返回的是有idx个物品时的最大价值，w表示这时书包还可以容纳的物品的重量
    public static int search(int idx, int w) {
        if (idx < 0) {
            return 0;
        }
        if (WEIGHTS[idx] > w) {
            return search(idx - 1, w);
        }
        //search(idx-1, w)表示没有选idx
        //search(idx-1,w-WEIGHTS[idx])表示选了idx
        int a = search(idx - 1, w);
        int b = search(idx - 1, w - WEIGHTS[idx]) + VALUES[idx];
        return Math.max(a, b);
    }

    //这个返回的是有idx物品时的最大价值，w表示这时书包中的重量
    public static int search2(int idx, int w) {
        if (idx >= PRODUCT_COUNTS) {
            return 0;
        }
        int a = 0, b = 0;
        //search(idx+1, w)表示没有选idx
        //search(idx+1,w+WEIGHTS[idx])表示选了idx
        if (w + WEIGHTS[idx] <= BAG_MAX_WEIGHT) {
            a = search2(idx + 1, w + WEIGHTS[idx]) + VALUES[idx];
        }
        b = search2(idx + 1, w);
        return Math.max(a, b);
    }

    //推荐这个写法
    //这个返回的是有idx个物品时的最大价值，w表示这时书包还可以容纳的物品的重量
    public static int search3(int idx, int w) {
        if (idx < 0) {
            return 0;
        }
        //result[idx][w]表示从前idx（包含idx）个东西，达到重量上限w，可以获得的最大价值
        if (result[idx][w] >= 0) {
            return result[idx][w];
        }

        //冗余的地方，主要是因为有两个search。而n!中是没有冗余的
        //(idx-1, w-W[idx])
        //(idx-1, w-W[idx])

        int a = 0, b = 0;
        //search(idx-1, w)表示没有选idx
        //search(idx-1,w-WEIGHTS[idx])表示选了idx
        if (WEIGHTS[idx] <= w) {
            a = search3(idx - 1, w - WEIGHTS[idx]) + VALUES[idx];;
        }
        b = search3(idx - 1, w);
        /*
        上面的代码不能这么写：
        if (WEIGHTS[idx] > w) {
            a = search3(idx - 1, w);
        }
        b = search3(idx - 1, w - WEIGHTS[idx]) + VALUES[idx];
        这么写只有WEIGHTS[idx] > w时才会调用search3(idx - 1, w)，
        其实当WEIGHTS[idx] < w时，也可以调用search3(idx - 1, w)
         */
        result[idx][w] = Math.max(a, b);
        return result[idx][w];
    }

    public static void main(String[] args) {
        result = new int[PRODUCT_COUNTS][BAG_MAX_WEIGHT+1];
        for (int i = 0; i < PRODUCT_COUNTS; i++) {
            for (int j = 0; j < BAG_MAX_WEIGHT+1; j++) {
                result[i][j] = -1;
            }
        }
        System.out.println(search(PRODUCT_COUNTS-1, BAG_MAX_WEIGHT));
        System.out.println(search2(0, 0));
        System.out.println(search3(PRODUCT_COUNTS - 1, BAG_MAX_WEIGHT));
    }
}

执行结果：
17
17
17

递推代码

    //这是result[i][j]的含义：前i个东西，获得w重量时的最大价值
    public static int searchDitui(int idx, int w) {
        result[0][0] = 0;
        for (int i = 1; i <= BAG_MAX_WEIGHT; i++) {
            if (WEIGHTS[0] > i) {
                //当前0号东西的重量已经超过目标重量j，因此不能取0号东西，获得的价值为0
                result[0][i] = 0;
            } else {
                //WEIGHTS[0] <= i此时可以拿0号东西，获得0号东西的价值
                result[0][i] = VALUES[0];
            }
        }

        for (int i = 1; i < PRODUCT_COUNTS; i++) {
            result[i][0] = 0;
            for (int j = 1; j <= BAG_MAX_WEIGHT; j++) {
                //不取i号东西，因此跟前一个东西的价值相同
                result[i][j] = result[i-1][j];
                //只有当i号东西的重量小于等于目标重量j时才取i号东西
                if (WEIGHTS[i] <= j) {
                    result[i][j] = Math.max(result[i-1][j-WEIGHTS[i]]+VALUES[i], result[i][j]);
                }
            }
        }
        return result[idx][w];
    }

递推优化

使用滚动数组。

//这是result[i][j]的含义：前i个东西，获得w重量时的最大价值
    public static int searchDituiYouhua(int idx, int w) {
        result[0][0] = 0;
        for (int i = 1; i <= BAG_MAX_WEIGHT; i++) {
            if (WEIGHTS[0] > i) {
                //当前0号东西的重量已经超过目标重量j，因此不能取0号东西，获得的价值为0
                result[0][i] = 0;
            } else {
                //WEIGHTS[0] <= i此时可以拿0号东西，获得0号东西的价值
                result[0][i] = VALUES[0];
            }
        }

        for (int i = 1; i < PRODUCT_COUNTS; i++) {
            result[i%2][0] = 0;
            for (int j = 1; j <= BAG_MAX_WEIGHT; j++) {
                //不取i号东西，因此跟前一个东西的价值相同
                result[i%2][j] = result[(i-1)%2][j];
                //只有当i号东西的重量小于等于目标重量j时才取i号东西
                if (WEIGHTS[i] <= j) {
                    result[i%2][j] = Math.max(result[(i-1)%2][j-WEIGHTS[i]]+VALUES[i], result[i%2][j]);
                }
            }
        }
        return result[idx%2][w];
    }

完整代码

package org.fan.learn.dp;

/**
 * Created by fan on 2016/9/13.
 */
public class Bag {


    public static int[][] result;

    public static final int MAX_INT = 1000000;

    public static final int BAG_MAX_WEIGHT = 10;
    public static final int PRODUCT_COUNTS = 3;
//    public static final int[] WEIGHTS = {1,9,3};
//    public static final int[] VALUES = {6,2,3};
    public static final int[] WEIGHTS = {3,4,5};
    public static final int[] VALUES = {3,4,6};
//    public static final int[] WEIGHTS = {2, 2, 6, 5, 4};
//    public static final int[] VALUES = {6, 3, 5, 4, 6};
    //这个返回的是有idx个物品时的最大价值，w表示这时书包还可以容纳的物品的重量
    public static int search(int idx, int w) {
        if (idx < 0) {
            return 0;
        }
        if (WEIGHTS[idx] > w) {
            return search(idx - 1, w);
        }
        //search(idx-1, w)表示没有选idx
        //search(idx-1,w-WEIGHTS[idx])表示选了idx
        int a = search(idx - 1, w);
        int b = search(idx - 1, w - WEIGHTS[idx]) + VALUES[idx];
        return Math.max(a, b);
    }

    //这个返回的是有idx物品时的最大价值，w表示这时书包中的重量
    public static int search2(int idx, int w) {
        if (idx >= PRODUCT_COUNTS) {
            return 0;
        }
        int a = 0, b = 0;
        //search(idx+1, w)表示没有选idx
        //search(idx+1,w+WEIGHTS[idx])表示选了idx
        if (w + WEIGHTS[idx] <= BAG_MAX_WEIGHT) {
            a = search2(idx + 1, w + WEIGHTS[idx]) + VALUES[idx];
        }
        b = search2(idx + 1, w);
        return Math.max(a, b);
    }

    //推荐这个写法
    //这个返回的是有idx个物品时的最大价值，w表示这时书包还可以容纳的物品的重量
    public static int search3(int idx, int w) {
        if (idx < 0) {
            return 0;
        }
        //result[idx][w]表示从前idx（包含idx）个东西，达到重量上限w，可以获得的最大价值
        if (result[idx][w] >= 0) {
            return result[idx][w];
        }

        //冗余的地方，主要是因为有两个search。而n!中是没有冗余的
        //(idx-1, w-W[idx])
        //(idx-1, w-W[idx])

        int a = 0, b = 0;
        //search(idx-1, w)表示没有选idx
        //search(idx-1,w-WEIGHTS[idx])表示选了idx
        if (WEIGHTS[idx] <= w) {
            a = search3(idx - 1, w - WEIGHTS[idx]) + VALUES[idx];;
        }
        b = search3(idx - 1, w);
        /*
        上面的代码不能这么写：
        if (WEIGHTS[idx] > w) {
            a = search3(idx - 1, w);
        }
        b = search3(idx - 1, w - WEIGHTS[idx]) + VALUES[idx];
        这么写只有WEIGHTS[idx] > w时才会调用search3(idx - 1, w)，
        其实当WEIGHTS[idx] < w时，也可以调用search3(idx - 1, w)
         */
        result[idx][w] = Math.max(a, b);
        return result[idx][w];
    }

    //这是result[i][j]的含义：前i个东西，获得w重量时的最大价值
    public static int searchDitui(int idx, int w) {
        result[0][0] = 0;
        for (int i = 1; i <= BAG_MAX_WEIGHT; i++) {
            if (WEIGHTS[0] > i) {
                //当前0号东西的重量已经超过目标重量j，因此不能取0号东西，获得的价值为0
                result[0][i] = 0;
            } else {
                //WEIGHTS[0] <= i此时可以拿0号东西，获得0号东西的价值
                result[0][i] = VALUES[0];
            }
        }

        for (int i = 1; i < PRODUCT_COUNTS; i++) {
            result[i][0] = 0;
            for (int j = 1; j <= BAG_MAX_WEIGHT; j++) {
                //不取i号东西，因此跟前一个东西的价值相同
                result[i][j] = result[i-1][j];
                //只有当i号东西的重量小于等于目标重量j时才取i号东西
                if (WEIGHTS[i] <= j) {
                    result[i][j] = Math.max(result[i-1][j-WEIGHTS[i]]+VALUES[i], result[i][j]);
                }
            }
        }
        return result[idx][w];
    }

    public static void main(String[] args) {
        result = new int[PRODUCT_COUNTS][BAG_MAX_WEIGHT+1];
        for (int i = 0; i < PRODUCT_COUNTS; i++) {
            for (int j = 0; j < BAG_MAX_WEIGHT+1; j++) {
                result[i][j] = -1;
            }
        }
        System.out.println(search(PRODUCT_COUNTS-1, BAG_MAX_WEIGHT));
        System.out.println(search2(0, 0));
        System.out.println(search3(PRODUCT_COUNTS - 1, BAG_MAX_WEIGHT));
        System.out.println(searchDitui(PRODUCT_COUNTS - 1, BAG_MAX_WEIGHT));
    }
}

运行结果
10
10
10
10

fan2012huan
关注
专栏目录
01背包问题_01背包问题_
10-04
01背包问题是一种经典的组合优化问题，广泛应用于资源分配、任务调度等领域。在这个问题中，我们有一个容量为W的背包，以及n件物品，每件物品都有一个重量w[i]和一个价值v[i]。目标是选取不超过背包容量的物品，使得...
【01背包问题】
01-20
问题描述： 给定n个物品和一个容量为capacity的背包，物品i的大小为w[i]，物品i的价值为v[i]。如何选择物品装入背包，使背包中物品价值最大？ 思路分析：动态规划 动态规划数组：dp[i][j]表示从前i个物品中挑选物品...
Python基于回溯法解决01背包问题实例
09-21
在计算机科学中，优化问题经常需要求解一个有限的解空间，01背包问题就是这类问题的一个典型例子。01背包问题涉及到在一个有限的容量限制下，如何选择物品以最大化价值。这个问题可以通过多种方法解决，其中回溯法是...
什么是01背包问题动态规划以及学习01背包问题动态规划的意义
最新发布
05-09
### 01背包问题动态规划详解及其学习意义 #### 一、01背包问题概述 01背包问题作为计算机科学领域中的一个经典问题，属于组合优化问题的一种。该问题的基本形式如下：假设我们有一个背包，这个背包的最大承重为W...
算法分析 | 分支限界法 | 01背包问题
01-07
1.问题的性质 回溯法是对树的深度遍历,需要用到递归. 分支限界法是对树的广度遍历,需要用到数据结构.而且每个状态都是一个数据结构实体 状态应该表示如下几个属性: int cp //已放入物品总价值 int rp //剩余物品的总...
动态规划解决01背包问题
03-21
动态规划解决01背包问题 动态规划是解决01背包问题的有效方法，该方法的核心是填表，通过填表来找到问题的最优解。下面对动态规划解决01背包问题的知识点进行详细的解释。 一、问题描述 01背包问题是指有n个物品...
C++分支限界法(BFS求解01背包问题)
12-14
本主题将深入探讨如何使用C++编程语言，结合分支限界法（通常与广度优先搜索BFS相结合）来解决01背包问题。 01背包问题是一个经典的组合优化问题，其核心是给定一组物品，每件物品有重量和价值，目标是在不超过背包...
非01背包问题
03-28
非01背包问题，也称为部分背包问题或有界背包问题，是背包问题的一个变种。在经典的01背包问题中，我们面对的是一个有限的背包，每种物品都有一个重量和价值，目标是在不超过背包容量的前提下，选择物品以最大化总...
01背包问题Python实现
07-18
假设背包容量为C，有以下4类物品，每类物品对应的货物数量分别为j1,j2,j3,j4，每个货物的体积分别为：vk1(k1∈j1)，vk2(k2∈j2)，vk3(k3∈j3)，vk4(k4∈j4)，它们所对应的价值为uk1(k1∈j1)，uk2(k2∈j2)，uk3(k3∈j...
基于python使用粒子群优化算法来解决01背包问题的可视化代码
03-30
01背包问题是一种经典的组合优化问题，它在计算机科学、运筹学以及人工智能等领域有着广泛的应用。在这个问题中，我们有n个物品，每个物品都有一个价值v_i和一个重量w_i，目标是在不超过背包容量W的情况下，选择物品...
C++编写的01背包问题
07-07
01背包问题是一种经典的计算机科学优化问题，常用于学习和研究动态规划算法。在这个问题中，我们有一个容量有限的背包，以及一系列物品，每个物品都有一个重量和一个价值。目标是选择一部分物品装入背包，使得背包总...
01背包问题测试数据
12-04
0-1背包问题测试数据，内含多组测试数据，物品的价值量及其重量，复制粘贴即可使用
01 背包问题
05-01
"01 背包问题" 01 背包问题是指在给定物品的重量和价值的情况下，在满足背包容量的限制下，选择哪些物品装入背包，使得总价值达到最大化。该问题可以转化为一个约束条件和目标函数的优化问题。 在具体实现中，01 ...
程序4---分解质因数
程序员
10-15 3366
分解质因数就是将一个合数分解成几个质数（也叫素数）的乘积的形式。 如：6＝2＊3第一种实现基本思路： 从i=2到sqrt(n)，遍历，如果n%i==0，则表示i是n的一个因子，然后再看这个i是不是素数（即质数），如果是，则打印，并使n = n/i。然后i再从2开始。bool isPrime(int m) { int sqr = sqrt(m); for(int i=2; i <= sqr
程序10——逐层打印二叉树
程序员
12-22 2079
逐层打印二叉树与从上往下打印二叉树不同。 逐层打印二叉树的结果为： 1 2,3 4,5,6 7void levelPrintTree(tree *T) { if (T == null) { return; } queue q; tree *t = T; q.push(q); q.push(null); while(!q
程序11-先升序后降序返回最大值
程序员
10-11 1900
一个数列，先升序后降序，返回最大值的下标。package org.fan.learn;/** * Created by fan on 2016/10/10. */ public class BinarySearchMeituan { public static int search(int[] arr) { //特殊处理 if (a
小兵向前冲
程序员
09-12 1581
小兵向前冲N*M的棋盘上，小兵要从左下角走到右上角，只能向上或者向右走，问有多少种走法？ 注意：这里说的N*M是指线段，而不是指几根竖线，几根横线。线段总是比线少1个的。下面的讨论都是基于线段的。 见下图(这个图是4*4的)： 上图标注解释如下： 左下角黄色方框：起始位置 右上角黄色方框：目标位置 下边框和右边框黑色的数字0 1 2 3 4表示的是坐标 红色的方框：表示递归时的重复
程序9——层序遍历二叉树（从上往下打印二叉树）
程序员
12-22 1166
从上往下打印二叉树就是层序遍历二叉树。还有一种变形，是逐层打印二叉树，这个的实现，请详见逐层打印二叉树。 如上图所示，则打印结果是：1,2,3,4,5,6,7在这个实现过程中需要用到队列。代码如下：void levelBinaryTree(tree *T) { if(T == null) { return; } queue q; tree *t
01背包问题解析与优化
"01背包问题是一种经典的优化问题，主要探讨如何在有限的容量下选择物品以最大化总体价值。该问题的核心在于确定是否以及如何放入每一件物品，每件物品只能放一次。01背包问题通常通过动态规划来解决，通过定义状态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值