LintCode背包问题总结

最新推荐文章于 2024-06-16 23:12:54 发布
最新推荐文章于 2024-06-16 23:12:54 发布
阅读量4k 收藏 15
点赞数 7
分类专栏： Algorithm 文章标签： Backpack 背包 动态规划 DP LintCode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luoshengkim/article/details/76514558
版权

背包问题是动态规划的一种题型，它的特点如下：

特点： 
1. 用值作为dp维度
2. dp过程就是填写矩阵
3. 可以用滚动数组进行优化

有个背包问题九讲的链接推荐：背包问题九讲

92. Backpack

Given n items with size Ai, an integer m denotes the size of a backpack. How full you can fill this backpack? 要求返回背包最多能容纳的大小是多大。

state: 
    f[i][j] 前i个物品，取出一些能否组成和为j
function:
    f[i][j] = 
        1. f[i - 1][j - a[i]] // 能放下第i个物品，那么要看除掉第i 个物品剩下的容量 j - a[i]时候与i － 1个物品的情况
        2. f[i - 1][j] // 若前i-1个物品就能组成大小为j
Intialize:
    f[0][0] = true;
Result:
    检查所有的f[n][j] (j = 0, 1, 2,..., n)

时间复杂度为O(m * n)

    public int backpack(int capacity, int[] A) {
        // state dp[m][n]: if it can fill the capacity n from the first m items
        boolean dp[][] = new boolean[A.length + 1][capacity + 1];
        // initialize
        for (int i = 0; i <= A.length; i++) {
            for (int j = 0; j <= capacity; j++) {
                dp[i][j] = false;
            }
        }
        dp[0][0] = true;
        // dp function
        for (int i = 1; i <= A.length; i++) {
            for (int j = 0; j <= capacity; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j >= A[i - 1] && dp[i - 1][j - A[i - 1]]) {
                    dp[i][j] = true;
                }
            }
        }
        // result
        for (int i = capacity; i >= 0; i--) {
            if (dp[A.length][i]) {
                return i;
            }
        }
        return 0;
    }
仔细观察，这道题可以用滚动数组优化，从而优化了空间复杂度： 

    public int backpackWithRollingArray(int capacity, int[] A) {
        // state dp[m][n]: if it can fill the capacity n from the first m items
        boolean dp[][] = new boolean[2][capacity + 1];
        // initialize
        for (int i = 0; i < dp.length; i++) {
            for (int j = 0; j <= capacity; j++) {
                dp[i][j] = false;
            }
        }
        dp[0][0] = true;
        // dp function
        for (int i = 1; i <= A.length; i++) {
            for (int j = 0; j <= capacity; j++) {
                dp[i%2][j] = dp[(i - 1)%2][j];
                if (j >= A[i - 1] && dp[(i - 1)%2][j - A[i - 1]]) {
                    dp[i%2][j] = true;
                }
            }
        }
        // result
        for (int i = capacity; i >= 0; i--) {
            if (dp[A.length%2][i]) {
                return i;
            }
        }
        return 0;
    }

125. Backpack II

物品不仅有大小size，还有价值value，分别有2个数组表示每个物品的大小和价值，然后给一个大小为target的背包，这个背包里能装下的最大价值是多少。

State:    f[i][j]表示前i个物品当中选出一些物品组成容量为j的最大价值

DP Function:    f[i][j] = Max( f[i-1][j], f[i-1][j-A[i]]+Value[i]);  

Initialize:    f[0][0] = 0;

Result:    f[m][n]

时间复杂度：O(m * n)

    public int backPackII(int n, int[] A, int V[]) {
        int m = A.length;
        // state
        int[][] dp = new int[m + 1][n + 1];
        // initialize
        dp[0][0] = 0;
        // dp function
        for (int i = 1; i <= m; i++) {
            for (int j = 0; j <= n; j++) {
                dp[i][j] = Math.max(dp[i][j], dp[i-1][j]);
                if (A[i - 1] <= j) {
                    dp[i][j] = Math.max(dp[i][j], dp[i-1][j-A[i-1]]+V[i-1]);
                }
            }
        }
        // result
        return dp[m][n];
    }


440. Backpack III

这道题是上题Backpack II的变种，区别就每种item可以重复的选择，基本思路跟上题一样，只不过由于可以重复，所以在最内层循环还要再加一层while循环用于遍历枚举重复的组合。时间复杂度是O(m * n * k)。

    public int backPackIII(int[] A, int[] V, int n) {
        int m = A.length;
        // state
        int[][] dp = new int[m + 1][n + 1];
        // initialize
        dp[0][0] = 0;
        // dp function
        for (int i = 1; i <= m; i++) {
            for (int j = 0; j <= n; j++) {
                int k = 0;
                while (A[i - 1] * k <= j) {
                    dp[i][j] = Math.max(dp[i][j], dp[i-1][j-A[i-1]*k]+V[i-1]*k);  
                    k++;
                }
            }
        }
        // result
        int res = 0;
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                res = Math.max(res, dp[i][j]);
            }
        }
        return res;
    }

562. Backpack IV

给定一些物品数组和一个目标值，问有多少种可以组成目标的组合数，比如给定物品数组 [2,3,6,7] 和目标值 7, 那么就有2种可能：[7] 和 [2, 2, 3]。所以返回2。这道题也可以这样描述：给1，2，5，10硬币无数多个，请问凑80元的方案总数。

State:
    dp[m][n] 前m种硬币凑成n元的方案数量
DP Function:
    dp[m][n] = dp[m - 1][n] + dp[m - 1][n - A[m] * 1] + dp[m - 1][n - A[m] * 2] + dp[m - 1][n - A[m] * 3] + ...
Initialize:
    dp[0][0] = 1
result:
    dp[m][n]

时间复杂度是O(m * n * k)

    public int backpack(int [] nums, int target) {
        // state dp[m][n]: the number of combinations that first m kinds of items form the target n
        int m = nums.length, n = target;
        int dp[][] = new int[m + 1][n + 1];
        dp[0][0] = 1;
        // dp function
        for (int i = 1; i <= m; i++) {
            for (int j = 0; j <= n; j++) {
                int k = 0;
                while (k * nums[i - 1] <= j) {
                    dp[i][j] += dp[i - 1][j - k * nums[i - 1]];
                    k++;
                }
            }
        }
        // result
        return dp[m][n];
    }

563. Backpack V

这道题是Backpack IV那道凑硬币题目的变种，唯一的区别就是现在每种类型的硬币是不可以重复的选择。每个硬币只能出现一次。

State:
    dp[m][n] 前m种硬币凑成n元的方案数量
DP Function:
    dp[m][n] = dp[m - 1][n] + dp[m - 1][n - A[m] ];
Initialize:
    dp[0][0] = 1
result:
    dp[m][n]

时间复杂度是O(m * n)

    public int backPackV(int[] nums, int target) {
        // state dp[m][n]: the number of combinations that first m kinds of items form the target n  
        int m = nums.length, n = target;  
        int dp[][] = new int[m + 1][n + 1];  
        dp[0][0] = 1;  
        // dp function  
        for (int i = 1; i <= m; i++) {  
            for (int j = 0; j <= n; j++) {
                dp[i][j] = dp[i - 1][j];
                if (nums[i - 1] <= j) {
                    dp[i][j] += dp[i - 1][j - nums[i - 1]];
                }
            }  
        }  
        // result  
        return dp[m][n]; 
    }


564. Backpack VI

给定一个包含了一些数字的数组，和一个目标值，从数组里面取数做排列，使得排列的数字的和等于target。问有多少种排列方法。数字是阔以重复取出来的。比如给定数组[1, 2, 4]和target值4。那么能得到如下的组合。总共有6种，则返回6.

[1, 1, 1, 1]
[1, 1, 2]
[1, 2, 1]
[2, 1, 1]
[2, 2]
[4]
用dp[i]表示target为i的排列数有多少种。比如以上面那个例子为例，我们可以画出如下的dp搜索图：


从而就不难写出如下代码了：

    public int backPackVI(int[] nums, int target) {
        // state
        int[] dp = new int[target + 1];
        // initialize
        dp[0] = 1;
        // dp function
        for (int i = 1; i <= target; i++) {
            for (int num: nums) {
                if (i >= num) {
                    dp[i] += dp[i - num];
                }
            }
        }
        // result
        return dp[target];
    }

89. k Sum

从一个数组中取k个数的和为target，求有多少种组合。假如数组是[1,2,3,4], k = 2, target = 5。那么有2种解：[1,4] 和 [2,3]。

state:
    f[i][j][t]前 i 个数中取 j 个数出来组成和为 t 的组合数目
function: 
    f[i][j][t] = f[i - 1][j][t] + f[i - 1][j - 1][t - a[i - 1]] (不包括第i 个数的时候组成t的情况 + 包括第i个数的时候组成t的情况)
initialize:
    f[i][0][0] = 1
result:
    f[n][k][target]

时间复杂度：O(n * k * target)

    public int kSum(int A[], int k, int target) {
        int n = A.length;
        // state
        int[][][] dp = new int[n + 1][k + 1][target + 1];
        // initialize
        for (int i = 0; i <= n; i++) {
            dp[i][0][0] = 1;
        }
        // dp function
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= k; j++) {
                for (int l = 0; l <= target; l++) {
                    dp[i][j][l] = dp[i-1][j][l];
                    if (l >= A[i-1]) {
                       dp[i][j][l] += dp[i-1][j-1][l-A[i-1]];
                    }
                }
            }
        }
        // result
        return dp[n][k][target];
    }

91. Minimum Adjustment Cost

题意有点复杂，给定一个整型数组，调整这个数组使得每两个数之间的差值不超过给定target值。问你调整这个数组所需要的最小开销是多少。注意数组中的每个数不会超过100，这是一个非常关键的条件。因为这样的话，当前可取的值是1-100，并且与上一个值是在target的差值以内。那我们可以转换成背包问题：

State:    f[i][v] 前i个数，第i个数调整为v，满足相邻两数<=target，所需要的最小代价 
Function:    f[i][v] = min(f[i-1][v’] + |A[i]-v|, |v-v’| <= target)
Answer:    f[n][a[n]-target~a[n]+target]
时间复杂度:    O(n * A * T)

其实很简单，就是当前index为v时，我们把上一个index从1-100全部过一次，取其中的最小值（判断一下前一个跟当前的是不是abs <= target）

    public int MinAdjustmentCost(ArrayList<Integer> A, int target) {
        if (A == null || A.size() == 0) {
            return 0;
        }
        // state
        int[][] dp = new int[A.size() + 1][101];
        // dp function
        for (int i = 1; i <= A.size(); i++) {
            for (int j = 1; j <= 100; j++) {
                dp[i][j] = Integer.MAX_VALUE;
                for (int k = 1; k <= 100; k++) {
                    if (Math.abs(k - j) > target) {
                        continue;
                    }
                    int diff = Math.abs(j - A.get(i - 1)) + dp[i-1][k];
                    dp[i][j] = Math.min(dp[i][j], diff);
                }
            }
        }
        // result
        int res = Integer.MAX_VALUE;
        for (int i = 1; i <= 100; i++) {
            res = Math.min(res, dp[A.size()][i]);
        }
        return res;
    }

月光下的夜曲
关注
  • 7
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【LintCode】Backpack 背包问题
wutingyehe的专栏
07-16 4521
在n个物品中挑选若干物品装入背包，最多能装多满？假设背包的大小为m，每个物品的大小为A[i]。样例 如果有4个物品[2, 3, 5, 7] 如果背包的大小为11，可以选择[2, 3, 5]装入背包，最多可以装满10的空间。 如果背包的大小为12，可以选择[2, 3, 7]装入背包，最多可以装满12的空间。 函数需要返回最多能装满的空间大小。注意 你不可以将物品进行切割。举例： 如果有4个
Backpack 解题报告 背包问题深入浅出
总结沉淀
04-26 1818
BackpackDescriptionGiven n items with size Ai, an integer m denotes the size of a backpack. How full you can fill this backpack? ExampleIf we have 4 items with size [2, 3, 5, 7], the backpack size is 1
LintCode 562: Backpack IV (完全背包问题变种，DP经典)
roufoo的博客
10-26 765
这题就是完全背包的变种。 dp[x]表示能装满size 为x的背包的最多方法总数。 注意： dp[j] += dp[j - nums[i]]; 旧的dp[j]: 上次的# of ways to fill size=j knapsack with item i 旧的dp[j-nums[i]]: 上次的# of ways to fill size=j-nums[i] knapsack without...
背包问题详解
最新发布
m0_72674633的博客
06-16 1040
背包问题详解
LintCode-背包问题（01背包问题）
03-10 1946
背包问题 II 给出n个物品的体积A[i]和其价值V[i]，将他们装入一个大小为m的背包，最多能装入的总价值有多大？ A[i], V[i], n, m均为整数。你不能将物品进行切分。你所挑选的物品总体积需要小于等于给定的m。样例对于物品体积[2, 3, 5, 7]和对应的价值[1, 5, 2, 4], 假设背包大小为10的话，最大能够装入的价值为9。//AC代码 public class So
【leetcode】背包问题汇总
Candy_GL的博客
03-08 2101
转自：https://blog.csdn.net/u013166817/article/details/85449218 版权声明：转载请注明 https://blog.csdn.net/u013166817/article/details/85449218 详细解析参考“背包九讲”：https://github.com/tianyicui/pack 目录 1. 背包问题 I ——0...
背包问题Matlab求解
05-28
标题中的“背包问题Matlab求解”指的是使用Matlab编程解决经典的组合优化问题——背包问题。背包问题是一个在有限的背包容量下，选择物品以最大化总价值的问题。它广泛应用于资源分配、项目选择等领域。 首先，我们...
背包问题总结
09-28
背包问题总结 背包问题是计算机科学和Operations Research中的一类经典问题，旨在解决如何在有限的资源（如背包容量）下，选择物品使得总价值最大。常见的背包问题有两种：完全背包问题和0-1背包问题。 完全背包...
背包问题介绍背包问题.zip
03-21
【背包问题】是一种经典的组合优化问题，在计算机科学和运筹学中有着广泛的应用。它源自于实际生活中的物品装箱问题，例如在有限的行李箱空间内如何选择物品以达到最大价值或最小重量。在数学建模中，背包问题通常...
背包问题介绍1.zip
03-21
背包问题是一种经典的优化问题，在计算机科学，特别是运筹学和算法设计中占有重要地位。它源于实际生活中的物品装箱问题，例如如何在有限的背包容量内装入最有价值的物品。这个问题通常被用来模拟资源分配、项目选择...
背包问题九讲html版本
03-25
**背包问题概述** 背包问题是一种经典的优化问题，广泛应用于计算机科学和运筹学领域，特别是在算法设计和组合优化中占有重要地位。它通常涉及到在给定容量限制的情况下，选择物品以最大化价值或满足某些目标。这个...
背包问题概述（Lintcode- 562.Backpack IV问题解决）
weixin_33795806的博客
05-08 279
什么是背包问题 背包问题（Knapsack problem）是一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。问题的名称来源于如何选择最合适的物品放置于给定背包中。 背包问题是动态规划算法的一个典型实例。动态规划是对解最优化问题的一种途径。它往往是针对一种最优化问题，根据问题的不同性质，确定不同的设计...
背包问题全解
ruzhuxiaogu的专栏
05-05 1752
类型一：可分割性的物品 此类型为贪心问题 背包问题 时间限制：3000 ms  |  内存限制：65535 KB 难度：3 描述现在有很多物品（它们是可以分割的），我们知道它们每个物品的单位重量的价值v和重量w（1<=v,w<=10）；如果给你一个背包它能容纳的重量为m（10<=m<=20）,你所要做的就是把物品装到背包里，使背包里的物品的价值总和最大。
lintcode 562. 背包问题 IV完全背包
sinb妃的博客
04-14 234
给出 n 个物品, 以及一个数组, nums[i]代表第i个物品的大小, 保证大小均为正数并且没有重复, 正整数 target 表示背包的大小, 找到能填满背包的方案数。 每一个物品可以使用无数次 样例 样例1 输入: nums = [2,3,6,7] 和 target = 7 输出: 2 解释: 方案有: [7] [2, 2, 3] 样例2 输入: nums = [2,3,4,5] 和 t...
01背包问题,多重背包问题-分组背包问题-完全背包问题-总结-内含4种经典背包问题
weixin_45981887的博客
03-16 1730
01背包问题： 01背包问题的特点：背包容量有限，物品只有一个，具有确定的体积和价值，我们的目标就是在不超过背包最大体积的情况下装入价值尽可能大的物品，让我们输出最大总价值 对于背包问题我们可以采用类似的思考方式： 以此为： 状态表示 考虑所有不同情况的结果存储方式 用集合表示背包问题的所有不同选法 f [ i ][ j ] 表示从0 ~ i 这些物品中选，最大背包容量为 j 的最大价值 然后考虑集合选法的条件， 数量 i 小于等于 物品总数 ， 体积 j 小于等于 背包最大体积 V 至于背包问题的属
LintCode : 背包问题 II
yaphone的博客
10-11 610
LintCode : 背包问题 II给出n个物品的体积A[i]和其价值V[i]，将他们装入一个大小为m的背包，最多能装入的总价值有多大？您在真实的面试中是否遇到过这个题？典型的01背包问题，动态规划解决。状态转移方程： ans[i][j] = max ( ans[i-1][j-A[i-1]] + V[i-1], ans[i-1][j-1] ) 当(j >= V[i])时。 ans[i][j] =
lintcode：125 背包问题 II
OceanStar的博客
05-06 202
题目来源 lintcode 题目描述 题目解析 背包问题 需要同时考虑两个维度：重量 + 价值。 所有的背包问题，先从重量入手，已经知道一个背包最大承重是M，不管怎么做装，每个装物品的方案的总重量都是0-M 如果对于每个总重量，我们能知道对应的最大价值是多少 （1）确定状态 需要知道N个物品 是否能拼出重量W(W = 0…M) 对于每个重量W，最大总价值是多少？ 最后一步：最后一个物品（重量AN−1A_{N-1}AN−1​，价值VN−1V_{N-1}VN−1​）是否能装入背包 情况一：
01背包问题 （好难理解）
两水先木示的博客
08-11 1259
真的这背包问题想到头都炸。。。我一点一点地想，看了许多别人的大神解释，太详细又看的懵逼，始终还是很难瞬间理解噢，这道题就是背包问题的感觉。 最终我还是选择了 用人性化地去考虑这个问题，解释在代码里有，我这样解释 感觉比较牵强但是却是最佳考虑方案。类背包问题也看了几个，几乎都差不多这个写法，只是有些决策会有点多，总是围绕着 代价 和收益 ， 结果要你求出最大或最小收益什么的，它就是背包。。
【LintCode 简单】44. 最小子数组
不想写代码的程序猿
01-19 252
LintCode编程练习
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值