【lintcode】背包问题

已于 2023-08-28 17:26:34 修改
阅读量571 收藏 2
点赞数
分类专栏： leetcode python 文章标签： leetcode 动态规划 背包问题
于 2020-08-13 01:12:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_health/article/details/107964544
版权

目录

92. 0/1背包问题(无价值)

125. 0/1背包问题 II（有价值）

总结1

0/1背包问题V-方案个数

完全背包问题IV-方案个数

92. 0/1背包问题(无价值)

在n个物品（每一个物品只能被装一次）中挑选若干物品装入背包，最多能装多满？假设背包的大小为m，每个物品的大小为A[i]
样例 1:
    输入:  [3,4,8,5], backpack size=10
    输出:  9
样例 2:
    输入:  [2,3,5,7], backpack size=12
    输出:  12

  • 二维的dp数组

dp[i][j]表示对于大小为j的背包，前i个物品能装多满。所谓0/1背包问题，就是对于某一个物品，它有两种状态，要么放入背包，状态为1，要么不放入背包，状态为0，因此可分两种情况:

（1）第i个物品没有放入背包中，那么此时背包装的大小为dp[i][j] = dp[i-1][j]。

（2）第i个物品放入背包中，那么此时背包装的大小为dp[i][j] = dp[i-1][j-A[i]]+A[i]。

由于我们求得是最多能装多满，因此是最大值，即dp[i][j] =max(dp[i-1][j-A[i]]+A[i],dp[i-1][j])

因此代码如下：

        for j in range(m+1):#首先初始化dp的第一行，即对于大小为j的背包，用第一个物品能装多满
            if A[0] <= j:
                dp[0][j] = A[0]

        for i in range(1,n):  #循环从第二个物品开始
            for j in range(m+1):
                dp[i][j] = max(dp[i-1][j-A[i]] + A[i],dp[i-1][j])
        return dp[-1][-1]

动态方程由两个循环构成。外循环是物品的index，从1开始，内循环是背包大小，从0开始。这也是背包问题最基本的模板

之所以是物品是外循环是因为每一个物品只能被装一次

但是上面的代码是错误的。原因在于外循环是物品的index，是从1开始的，也就是第2个物品。在计算dp[i-1][j-A[i]]的时候，j-A[i]很可能为负数，导致定位到i-1的最后几列。因此正确的代码为：

    def backPack2(self, m, A):
        #二维度dp
        n = len(A)  #物品的个数
        dp = [[0 for i in range(m+1)] for j in range(n)]  #对于大小为j的背包，前i个物品能装多满
       
        for i in range(m+1):
            if A[0] <= i:
                dp[0][i] = A[0]

        for i in range(1,n):
            for j in range(m+1):
                if A[i] > j:
                    dp[i][j]  = dp[i-1][j]
                else:
                    dp[i][j] = max(dp[i-1][j-A[i]] + A[i],dp[i-1][j])
        return dp[-1][-1]
  • 一维的dp数组

dp[j]表示大小为j的背包最多能装多满。动态方程为：dp[j] = max(dp[j-A[i]] + A[i], dp[j])。

需要注意的点在于：

（1）由于是0/1背包，物品是不能重复算的，因此内循环背包的容量采用倒序。

（2）内循环背包容量j不能小于A[j]，如果小于A[j]，会出现表格中右侧的情况（左边是正确代码的情况，以[4,3,2,1]，7为例）

    def backPack1(self, m, A):
        #一维度dp
        n = len(A)
        dp = [0] * (m+1)
        for i in range(n):
            for j in range(m, A[i]-1, -1):
                dp[j] = max(dp[j-A[i]] + A[i], dp[j])
        return dp[-1]
     0  1  2  3  4  5  6  7  8  9
4  [0, 0, 0, 0, 4, 4, 4, 4, 4, 4]
3  [0, 0, 0, 3, 4, 4, 4, 7, 7, 7]
2  [0, 0, 2, 3, 4, 5, 6, 7, 7, 9]
1  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

   0    1     2    3   4   5    6    7    8    9

4 [0,  8,    8,   8,  4,  4,   4,   4,   4,   4]
3 [0, 10, 10,   8,  11, 11, 11,  7,   7,   7]
2 [0, 11,  10, 12, 12, 11, 13, 13, 13,  9]
1 [0, 11,  12, 12, 13, 13, 13, 14, 14, 14]

125. 0/1背包问题 II（有价值）

有 n 个物品和一个大小为 m 的背包. 给定数组 A 表示每个物品的大小和数组 V 表示每个物品的价值。问最多能装入背包的总价值是多大?

样例 1:
输入: m = 10, A = [2, 3, 5, 7], V = [1, 5, 2, 4]
输出: 9
解释: 装入 A[1] 和 A[3] 可以得到最大价值, V[1] + V[3] = 9 

样例 2:
输入: m = 10, A = [2, 3, 8], V = [2, 5, 8]
输出: 10
解释: 装入 A[0] 和 A[2] 可以得到最大价值, V[0] + V[2] = 10

本题与上一题非常相似，一样可以分为二维dp和一维dp的方法，形式基本一样。 

  • 二维的dp数组

dp[i][j]表示对于大小为j的背包，前i个能装入背包的物体所构成的最大价值。

 def backPackII_1(self, m, A, V):
        #二维度dp
        n = len(A)  #物品的个数
        dp = [[0 for i in range(m+1)] for j in range(n)]  #对于大小为j的背包，前i个物品能构成的最大价值
        
        for j in range(m+1):
            if j >= A[0]:
                dp[0][j] = V[0]

        for i in range(1,n):
            for j in range(m+1):
                print(j,A[i])
                if A[i] > j:   #当前物品的重量大于背包重量
                    dp[i][j]  = dp[i-1][j]
                else:
                    dp[i][j] = max(dp[i-1][j-A[i]] + V[i],dp[i-1][j])
        return dp[-1][-1]
  • 一维的dp数组

dp[j]表示大小为j的背包所构成的最大价值。动态方程为：dp[j] = max(dp[j-A[i]] + V[i], dp[j])。

    def backPackII_2(self, m, A,V):
        n = len(A)
        dp = [0] * (m+1)
        for i in range(n):
            for j in range(m, A[i]-1, -1):
                dp[j] = max(dp[j-A[i]] + V[i], dp[j])
        return dp[-1]

总结1-1维写法简单总结

1.如果是0-1背包，即数组中的元素不可重复使用，nums放在外循环，target在内循环，且内循环倒序；

for i,num in enumerate(nums):
    for j in range(target, num-1, -1):
        dp[j] = max(dp[j-num] + V[i]/num,dp[j])

2.如果是完全背包，即数组中的元素可重复使用，nums放在外循环，target在内循环。且内循环正序。

for i,num in enumerate(nums):
    for j in range(num, target+1):
        dp[j] = max(dp[j-num] + V[i]/num,dp[j])

0/1背包问题V-方案个数

给出 n 个物品, 以及一个数组, nums[i] 代表第i个物品的大小, 保证大小均为正数（但是有重复）, 正整数 target 表示背包大小, 找到能填满背包的方案数。每一个物品只能使用一次。
样例：
给出候选物品集合 [1,2,3,3,7] 以及 target 7
结果的集合为:
[7]
[1,3,3]
返回 2

  • 二维的dp数组

dp[i][j]表示对于大小为j的背包，前i个物品能将背包装满的方案数。

对于第i个物品，有：

  1. 其大小nums[i]>j，说明这个物品一定无法被放入背包，那么其方案数等于前i-1个物品装满背包的方案数:dp[i][j] = dp[i-1][j]
  2. 其大小nums[i]=j，说明这个物品单独就可以放入这个背包并且装满，那么相当于在前i-1个物品装满背包的方案数的基础上又加了1：dp[i-1][j]+1
  3. 其大小nums[i]<j，那么此物品可以放入背包或者不放入背包，放入背包的话其方案数就是dp[i-1][j-nums[i]]。不放入的话其方案数与第一个条件相同dp[i-1][j]，故dp[i][j] = dp[i-1][j-nums[i]] + dp[i-1][j]。

因此代码如下：

    def backPackV(self, nums, target):
        # write your code here
        nums.sort()
        n = len(nums)
        dp = [[0] * (target+1) for j in range(n)]   #截止到第i个数字，填满大小为j的背包有多少种方案
        for j in range(target+1):
            if j == nums[0]:
                dp[0][j] = 1
        for i in range(1,n):
            for j in range(target+1):
                if nums[i] > j:
                    dp[i][j] = dp[i-1][j]
                elif nums[i] == j:
                    dp[i][j] = dp[i-1][j] + 1
                else:
                    dp[i][j] = dp[i-1][j-nums[i]] + dp[i-1][j]
        return dp[-1][-1]

可以看到上面代码的三个条件都是需要先添加dp[i-1][j]，也就是说无论放不放第i个物品，总有dp[i-1][j]个方案，如果进一步放第i个物品，再添加dp[i-1][j-nums[i]]。因此 dp[i][j] = dp[i-1][j-nums[i]] + dp[i-1][j]。

但是必须初始化dp[0][0]=1。这里隐含的意思是，假设我们有重量为0的物品，那么对于大小为0的背包，就存在一个方案。

def backPackV(self, nums, target):
        nums.sort()
        n = len(nums)
        dp = [[0] * (target+1) for j in range(n)]   #截止到第i个数字，填满大小为j的背包有多少种方案f 
        for j in range(target+1):
            if j == nums[0]:
                dp[0][j] = 1
        dp[0][0] = 1    #必须要有
        for i in range(1,n):
            for j in range(target+1):
                dp[i][j] = dp[i-1][j]
                if nums[i] <= j:
                    dp[i][j] = dp[i][j] + dp[i-1][j-nums[i]]
        return dp[-1][-1]
  • 一维的dp数组

dp[j]表示填满大小为j的背包的方案数。因为物品不能重复使用，因此内循环采用倒序。

对于第i个物品，有：

  1. 其大小nums[i]>j，说明这个物品一定无法被放入背包，那么其方案数不变，直接continue（相当于dp[j] = dp[j]）
  2. 其大小nums[i]=j，说明这个物品单独就可以放入这个背包并且装满，因此直接在当前的方案数上+1，dp[j] = dp[j] + 1
  3. 其大小nums[i]<j，那么此物品可以放入背包或者不放入背包，放入背包的话其方案数等于背包大小为j-nums[i]的方案数，即dp[j-nums[i]]。不放入的话其方案数与第一个条件相同dp[j]，故dp[j] = dp[j-nums[i]] + dp[j]
    def backPackV(self, nums, target):
        # write your code here
        nums.sort()
        n = len(nums)
        dp = [0] * (target+1)  #dp[j]填满大小为j的背包有多少种方案
        for i in range(n):
            for j in range(target,nums[i]-1,-1):
                if nums[i] > j:
                    continue
                elif nums[i] == j:
                    dp[j] = dp[j] + 1
                else:
                    dp[j] = dp[j] + dp[j-nums[i]]
            #print(dp)
        return dp[-1]

同样，上述代码可以进一步简化。这里需要初始化dp[0]=1，其功能就是弥补上述dp[j] = dp[j] + 1。如果j=nums[i]，则j-nums[i] = 0，dp[0]如果不初始化为1，就会错误。也可以理解为，存在一个大小为0的物品可以装入大小为0的背包，因此方案数为1。

    def backPackV(self, nums, target):
        # write your code here
        nums.sort()
        n = len(nums)
        dp = [0] * (target+1)  #dp[j]填满大小为j的背包有多少种方案
        dp[0] = 1
        for i in range(n):
            for j in range(target,nums[i]-1,-1):
                dp[j] = dp[j] + dp[j-nums[i]]
        return dp[-1]

完全背包问题IV-方案个数

给出 n 个物品, 以及一个数组, nums[i]代表第i个物品的大小, 保证大小均为正数并且没有重复, 正整数 target 表示背包的大小, 
找到能填满背包的方案数。每一个物品可以使用无数次。
样例1：输入: nums = [2,3,6,7] 和 target = 7
输出: 2
方案有: 
[7]
[2, 2, 3]

样例2：输入: nums = [2,3,4,5] 和 target = 7
输出: 3
方案有: 
[2, 5]
[3, 4]
[2, 2, 3]

  • 二维的dp数组

dp[i][j]表示对于大小为j的背包，前i个物品能将背包装满的方案数。因为物品使用的次数没有限制，因此设置第三层循环k，表示当前的数字用了几次。

对于第i个物品，有：

  1. 其大小nums[i]>j，说明这个物品一定无法被放入背包，那么其方案数等于前i-1个物品装满背包的方案数:dp[i][j] = dp[i-1][j]
  2. 其大小nums[i]=j，说明这个物品单独就可以放入这个背包并且装满，那么相当于在前i-1个物品装满背包的方案数的基础上又加了1：dp[i-1][j]+1
  3. 其大小nums[i]<j，那么此物品可以放入背包或者不放入背包。放入背包的话，根据放入的个数不同，需要添加相应的方案数，dp[i-1][j-k*nums[i]]。不放入的话其方案数为dp[i-1][j]，相当于k=0。因此动态方程为dp[i][j] = dp[i][j] + dp[i-1][j-k*nums[i]]
    def backPackIV(self, nums, target):
        nums.sort()
        n = len(nums)
        dp = [[0] * (target+1) for j in range(n)]   #截止到第i个数字，填满大小为j的背包有多少种方案
        for j in range(1,target+1): 
            if j % nums[0] == 0:
                dp[0][j] = 1             
        
        for i in range(1,n):
            for j in range(target+1): 
                print(nums[i],j)
                if nums[i] > j:   #背包不能放入该物品
                    dp[i][j] = dp[i-1][j]
                elif nums[i] == j:   #背包放入该物品（放一个）
                    dp[i][j] = dp[i-1][j] + 1
                else:    #背包放入该物品的个数为k
                    times = j // nums[i]
                    for k in range(0,times+1):
                        dp[i][j] = dp[i][j] + dp[i-1][j-k*nums[i]]
        return dp[-1][-1]

但是上述代码是有一点问题的，如下。我们默认从1开始循环，也就是说对于大小为0的背包是不考虑的。但是实际上对于大小为0的背包，我们不放入任何物品，就是一个方案，即dp[0][0] = 1。

        for j in range(1,target+1): 
            if j % nums[0] == 0:
                dp[0][j] = 1

 例如给定物品[2,3,5]，背包的大小为6，那么我们放三个大小为2的物品是一个方案，放两个大小为3的的物品也是一个方案。在dp第二行计算dp[3][6]的时候（这里直接以物品的大小作为行的index），dp[3][6] = dp[2][6] + dp[2][0]，由于默认从1开始循环， dp[2][0]=0，因此dp[3][6] = 1 + 0 = 1，而实际上dp[3][6] =2，就出错了。

从0开始循环（正确）从1开始循环（错误）
0  1  2  3  4  5  6
2 [1, 0, 1, 0, 1, 0, 1]
3 [1, 0, 1, 1, 1, 1, 2]
5 [1, 0, 1, 1, 1, 2, 2]		   0  1  2  3  4  5  6
2 [0, 0, 1, 0, 1, 0, 1]
3 [0, 0, 1, 1, 1, 1, 1]
5 [0, 0, 1, 1, 1, 2, 1]

此外实际上通过上面的分析，if elif else可以合并为一个，k等于0就是不放入，k=1就是放入一个，以此类推，因此可以合并。

    def backPackIV(self, nums, target):
        nums.sort()
        n = len(nums)
        dp = [[0] * (target+1) for j in range(n)]   #截止到第i个数字，填满大小为j的背包有多少种方案
        for j in range(target+1):  #从0开始循环
            if j % nums[0] == 0:
                dp[0][j] = 1             
        for i in range(1,n):       
            for j in range(target+1):
                times = j // nums[i]
                for k in range(0,times+1):
                    dp[i][j] = dp[i][j] + dp[i-1][j-k*nums[i]]
        return dp[-1][-1]
  • 一维的dp数组

dp[j]表示填满大小为j的背包的方案数。由于物品是可以重复选取的，因此内循环的顺序的正序的。

对于第i个物品，有：

  1. 其大小nums[i]>j，说明这个物品一定无法被放入背包，那么其方案数不变，直接continue（相当于dp[j] = dp[j]）
  2. 其大小nums[i]=j，说明这个物品单独就可以放入这个背包并且装满，因此直接在当前的方案数上+1，dp[j] = dp[j] + 1
  3. 其大小nums[i]<j，那么此物品可以放入背包或者不放入背包。不放入的话其方案数就等于dp[j]，无需增加，因此k从1开始循环。放入背包的话，根据放入的个数不同，需要添加相应的方案数，dp[i-1][j-k*nums[i]]。因此动态方程为dp[j] = dp[j] + dp[j-k*nums[i]]
    def backPackIV(self, nums, target):
        nums.sort()
        n = len(nums)
        dp = [0] * (target + 1)
        for i in range(n):
            for j in range(target+1): 
                if nums[i] > j:##背包不能放入该物品 dp[j] = dp[j]
                    continue
                elif nums[i] == j:  #背包放入该物品（放一个）
                    dp[j] = dp[j] + 1
                else:  
                    times = j // nums[i]
                    for k in range(1,times+1):
                        dp[j] = dp[j] +  dp[j-k*nums[i]]
        return dp[-1]

这个代码看似没有问题，但实际上是错误的，仍以给定物品[2,3,5]，背包的大小为6为例。上述代码生成的dp矩阵如下，可以看出当i=0,即nums[i] = 2时，大小为6的背包填满的方案只有一种，就是2,2,2,即dp[6] = 1。但是由于引入了k，当k=1时，dp[6] = dp[6] + dp[4] = 0 + 1 = 1.当k = 2时，dp[6] = dp[6] + dp[2] = 1 + 1 = 2，等于多算了一次。

     0  1  2  3  4  5  6
2  [0, 0, 1, 0, 1, 0, 2]
3  [0, 0, 1, 1, 1, 1, 3]
5  [0, 0, 1, 1, 1, 2, 3]

因此这里直接去掉k循环即可，即：

        for i in range(n):
            for j in range(target+1): 
                if nums[i] > j:##背包不能放入该物品 dp[j] = dp[j]
                    continue
                elif nums[i] == j:  #背包放入该物品（放一个）
                    dp[j] = dp[j] + 1
                else:  
                    dp[j] = dp[j] +  dp[j-nums[i]]

进一步地，可以将if elif else做一个合并。这里需要初始化dp[0]=1，其功能就是弥补上述dp[j] = dp[j] + 1

    def backPackIV(self, nums, target):
        n = len(nums)
        dp = [0 for _ in range(target+1)]
        dp[0] = 1
        for i in range(n):
            for j in range(nums[i],target+1):
                dp[j] = dp[j - nums[i]] + dp[j]
        return dp[-1]

方案数

0/1背包（要么放入背包，要么不放入）

完全背包（可以多次选取）

二维

dp[i][j]对于前i个物品，装满大小为j的背包的方案数

外循环物品，内循环背包大小（正序）

dp[i][j] = dp[i-1][j] + dp[i-1][j-nums[i]]              =  不放入背包   +  放入背包

外循环物品，内循环背包大小（正序）

dp[i][j] = dp[i][j] + dp[i-1][j-k*nums[i]]

k = 0：不放入背包

k > 0:  放入背包

dp[j]填满大小为j的背包的方案数

（1）外循环物品，内循环背包大小（倒序）

（2）初始化dp[0]=1

dp[j] = dp[j] + dp[j-nums[i]]

          =    不放入背包   +  放入背包

（1）外循环物品，内循环背包大小（正序）

（2）初始化dp[0]=1

dp[j] = dp[j] + dp[j - nums[i]]

            =    不放入背包   +  放入背包

Mr_health
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LintCode：背包问题
weixin_43462819的博客
09-22 233
题目列表和解答： https://blog.csdn.net/luoshengkim/article/details/76514558 关于背包问题的总结看最下面。 92. Backpack class Solution { public: /** * @param m: An integer m denotes the size of a backpack * @pa...
LintCode:针对LintCode问题的Java解决方案
05-26
从LintCode（ ）托管Java解决方案来解决问题。 一旦出现新问题或新测试案例，我将尝试修改解决方案。 平方 问题 等级 语 0 [2 Sum.java]（ Sum.java） Java 1个 [3 Sum Closest.java]（ Sum Closest.java） ...
LintCode 背包问题
木子的博客
05-11 1217
背包问题   描述 笔记  数据  评测 在n个物品中挑选若干物品装入背包，最多能装多满？假设背包的大小为m，每个物品的大小为A[i]   注意事项 你不可以将物品进行切割。 样例 如果有4个物品[2, 3, 5, 7] 如果背包的大小为11，可以选择[2, 3,
Lintcode 背包问题
u013174482的博客
07-29 268
牛人代码Backpack I Problem 单次选择+最大体积 Given n items with size Ai, an integer m denotes the size of a backpack. How full you can fill this backpack?Notice You can not divide any item into small pieces.Exampl
LintCode背包问题总结
Logan's
08-01 4082
背包是动态规划的一种题型，它的特点如下： 特点：  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
LintCode:背包问题
yaphone的博客
07-31 808
LintCode:背包问题首先想到的是建个二维数组，动态规划，超时了。。。class Solution: # @param m: An integer m denotes the size of a backpack # @param A: Given n items with size A[i] # @return: The maximum size def bac
Lintcode背包问题一窝端
小孩子少吃糖的博客
02-11 173
今天来对Lintcode上面的背包专题来个总结，除了付费的题全都做完了，就来回顾一下； 不得不说，做题自己悟永远是王道，北大版的《背包九讲》我是硬生生没有看下去，衰······ 言归正传，让我们开始正文，这篇文章会贼长的我感觉······ 一.不可分割不可重复使用的背包问题 背包问题 在n个物品中挑选若干物品装入背包，最多能装多满？假设背包的大小为m，每个物品的大小为A[i] int back...
LintCode : 背包问题 II
yaphone的博客
10-11 611
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 92.背包问题
未命名
02-11 188
LintCode 92.背包问题 背包问题 对于每个总重量，我们能知道有没有方案能做到，就可以解决。 背包问题中，数组大小和总承重有关 确定状态： 需要知道N个物品是否能拼出重量W(W=0,1,…,M)W (W =0, 1, …, M)W(W=0,1,…,M)。 最后一步：最后一个物品（重量AN−1A_{N-1}AN−1​）是否进入背包，**情况一：**如果前N−1N-1N−1个物品能拼出WWW，...
lintcode125背包问题II
李的博客
06-22 425
题目 有n件物品和一个尺寸为m的背包。 给定数组A表示每个项目的大小，数组V表示每个项目的价值。求可以在背包里放入的最大价值？ Example 1: Input: m = 10, A = [2, 3, 5, 7], V = [1, 5, 2, 4] Output: 9 Explanation: Put A[1] and A[3] into backpack, getting the max...
lintcode:lintcode源代码
04-29
4. **动态规划**：动态规划是一种用于求解最优化问题的方法，通过将大问题分解为小问题并存储中间结果来避免重复计算，如背包问题、最长公共子序列等。 5. **贪心算法**：对于具有局部最优解的问题，贪心策略往往能...
leetcode-lintcode
04-04
- 动态规划：将复杂问题分解为相互关联的子问题，解决如背包问题、最长公共子序列等。 - 贪心算法：局部最优解可能导致全局最优，适用于背包问题、活动选择等。 - 回溯法：尝试所有可能的解决方案，如八皇后问题...
lintcode阶梯训练美国大公司所有题目代码和笔记合集
05-30
背包问题是动态规划的经典实例，考察了对物品价值和重量的权衡决策。在给定容量的背包中，如何选取物品以使总价值最大？动态规划的思想是从小规模问题出发，逐步构建解决方案，直到解决原问题。 三、《加油站问题...
LintCodeSolutions:LintCode解决方案
03-10
例如，Fibonacci数列、背包问题、最长公共子序列等。 4. **贪心策略**：在一些优化问题中，贪心算法能够得到满意的结果。Python的高效执行能力使得贪心策略易于实现，如最小生成树、活动选择等。 5. **图论与网络...
python创建表格并写入内容
Mr_health的博客
03-11 5264
def output_xls(xls_path, cato, recall, prec, ap, mrecall, mprec, mAP): book = xlwt.Workbook() #创建一个Excel sheet1 = book.add_sheet('1') sheet1.write(0,0,'catogory_name') sheet1.write(...
PIL.Image和cv2的图片读取转换
Mr_health的博客
10-13 3792
这里读取一个RGB的图片 img = Image.open(imgpath) print(img,img.size()) img.show() print的结果如下，可以看到是没有第三波段的，只显示出了H和W <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=500x355 at 0x13E73B4ACC0> (500, 355) 如果这时候想用cv2来进行展示，即cv2.imshow（img），就会出现错误。因为cv2接受
Python多线程和多进程的Join和daemon（守护）的用法
Mr_health的博客
01-09 3540
转载于https://www.cnblogs.com/cnkai/p/7504980.html Python多线程与多进程中join()方法和daemon的效果是相同的。 基本知识 下面仅以多线程为例： 首先需要明确几个概念： 知识点一：当一个进程启动之后，会默认产生一个主线程，因为线程是程序执行流的最小单元，当设置多线程时，主线程会创建多个子线程，在python中，默认情况下（其实就是...
【python】logger模块
Mr_health的博客
09-23 1296
def setup_logger(logger_name, root, phase, level=logging.INFO, screen=False, tofile=False): '''set up logger''' lg = logging.getLogger(logger_name) #获取logger对象 formatter = logging.Formatter('%(asctime)s.%(msecs)03d - %(levelname)s: %(message).
动态规划艺术：背包问题详解
"这篇文档是崔添翼编写的《背包问题九讲2.0RC1》，是一份关于动态规划在解决背包问题中的经典教程。它最初以HTML形式发表，后经作者用LATEX修订，内容涵盖01背包、完全背包、多重背包、混合背包问题、二维费用的背包...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值