leetcode，lintcode刷题心得（2）——动态规划——背包问题——lintcode综合排名前三

我对背包问题的看法

由于琢磨了一道最基础的题目，找打了空间复杂度为o(n)的算法

思路如下，dp[i]表示第i个目标值时的最大容量或者价值

如果数组元素可以重复，则对dp的内循环采用从小到大的策略
否则，从大到小循环

注意的是，边界条件的选取。对于这个选取，我喜欢举一个小栗子，通过流程图，直观的看出细节

一些小栗子

Lintcode 92 背包问题1

class Solution:
    #d[j]表示当size等于j时,最多能承重的大小
    def backPack(self, m, A):
        dp = [0] * (m + 1)
        for i in range(len(A)):
            for j in range(m, A[i] - 1, -1):
                dp[j] = max(dp[j], dp[j - A[i]] + A[i])
        return dp[m]

Lintcode 125 背包问题2

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

Lintcode 440 背包问题3

class Solution:
    def backPackIII(self, A, V, m):
        if not A:
            return 0
        else:
            dp=[0]*(m+1)
            for i in range (len(A)):
                #注意只取一次和很多次的区别，重复取，从小到大内循环
                for j in range(A[i],m+1):
                    dp[j]=max(dp[j],dp[j-A[i]]+V[i])
        return dp[m]

Lintcode 562 背包问题4

class Solution:
    def backPackIV(self, nums, target):
        if not nums:
            return 0
        else:
            dp=[0]*(target+1)
            for i in range(len(nums)):
                for j in range(nums[i],target+1): #可重复,从小到大内循环
                    if dp[j-nums[i]]==0: #初始状态，从0到1的判断，验证nums[2,3,6],target=6
                        if j%nums[i]==0:
                            dp[j]+=1
                    else:
                        dp[j]+=dp[j-nums[i]]
        return dp[target]

背包问题4还可以改进一下代码，注意到初始状态，若只令dp[0]=1也符合要求，故有如下方案

class Solution:
    def backPackIV(self, nums, target):
        if not nums:
            return 0
        else:
            dp=[0]*(target+1)
            dp[0]=1
            for i in range(len(nums)):
                for j in range(nums[i],target+1):
                    dp[j]+=dp[j-nums[i]]
        return dp[target]

Lintcode 563 背包问题5

class Solution:
    def backPackV(self, nums, target):
        if not nums:
            return 0
        else:
            dp=[0]*(target+1)
            for i in range(len(nums)):
                for j in range(target,nums[i]-1,-1): #不能重复，内循环从大到小
                    if dp[j-nums[i]]==0:
                        if j/nums[i]==1:
                            dp[j] +=1
                    else:
                        dp[j]+=dp[j-nums[i]]
        return dp[target]        

同理，对于背包问题5，经检验，令dp[0]=1成立，因为对于任何大于0的数，它本身便是一种方案，简洁代码如下

class Solution:
    def backPackV(self, nums, target):
        if not nums:
            return 0
        else:
            dp=[0]*(target+1)
            dp[0]=1
            for i in range(len(nums)):
                for j in range(target,nums[i]-1,-1):
                    dp[j]+=dp[j-nums[i]]
        return dp[target]        

还有些题目，因为不是vip，做不起（贫穷的泪水）
加油！今天又进步了一些~