python 动态规划设计leetcode_leetcode_动态规划_python

总的要点:

明确dp的含义。初始化时注意限制输入,初始化后注意迭代时要从初始化之后开始!从初始化之后开始!从初始化之后开始!

步骤:明确含义和递推公式,创建dp;初始化dp;迭代dp.

二维dp和滚动数组的区别:二维dp最后一个for内更新所用的参量在该循环内不会改变,但滚动数组会改变所用的参数(这也是为什么可以写成滚动数组的原因)。写成滚动数组要注意遍历的顺序。不是把dp定义成二维就是二维dp。

无论元素能否重复使用,二维dp中for循环的嵌套顺序是无所谓的,因为最内层的for循环不会改变该层循环所需要的参数。且迭代时都是顺序。

而对于滚动数组,如果元素不能重复使用,则元素在外背包在内,顺序不能颠倒,且背包要倒序,以使得物品不会重复放置;如果元素可以重复使用,嵌套顺序可以交换,且背包是正序。

组合类问题,如各种是否能凑到目标和,dp与元素排列顺序无关的,外层物品内层包->这样相当于物品遍历的顺序就是该物品在集合中的相对次序,先出现的不会排在后出现的后面

排列类问题,需要各种顺序,所以外层包内层物品。

总而言之,bugfree的写法:先确定dp的含义和递推公式,并根据递推公式确定初始化的值(因为有很多初始化的实际意义很难解释,只是方便计算)。然后确定是组合问题还是排列问题,组合问题则物品在外背包在内,排列问题则背包在外物品在内;如果物品可以重复则顺序,如物品不能重复则倒序([a,b] 的倒序为range(a,b-1,-1)。

leetcode714.买卖股票的最佳时机含手续费

给定一个整数数组 prices,其中第 i 个元素代表了第 i 天的股票价格 ;非负整数 fee 代表了交易股票的手续费用。你可以无限次地完成交易,但是你每笔交易都需要付手续费。如果你已经购买了一个股票,在卖出它之前你就不能再继续购买股票了。返回获得利润的最大值。注意:这里的一笔交易指买入持有并卖出股票的整个过程,每笔交易你只需要为支付一次手续费。

思路:dp[i]表示第i天手里可能有的现金的最大值,dp[i][0]表示该天手中没有股票,dp[i][1]表示该天手中有股票。则当天手中没有股票可能是因为:1.前一天也没有股票。2.前一天有股票今天卖了。当天有股票可能是因为:1.昨天有股票今天继续持有;2.昨天没有股票今天卖了。统一交易费在卖出股票时交。

classSolution:def maxProfit(self, prices: List[int], fee: int) ->int:#易错点:利润和不等于每天利润和的拆解,因为每次拆解都需要手续费

#dp[i][0]:最多现金:第i天没有股票 dp[i][1]:有股票

dp = [[0, 0] for i inrange(len(prices)) ]

dp[0][1] = -prices[0]for i in range(1, len(prices)):

dp[i][0]= max(dp[i-1][0], dp[i-1][1]+prices[i]-fee)

dp[i][1] = max(dp[i-1][0]-prices[i], dp[i-1][1])return max(dp[len(prices)-1])

leetcode70.爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢?注意:给定 n 是一个正整数。

思路:dp[i]为爬到第i个台阶的方法数量。则按最后一次上的台阶数量,总方法分为两类:最后上1个和最后上2个。所以dp[i] = dp[i-1] + dp[i-2]。(注意不要再将最后上两个台阶拆成两种方案,因为拆开->上两次一个台阶的方案属于dp[i-1]中。所以直接按最后一步走多少个台阶把方法分成两类。)初始化时初始化第一和第二个台阶,即选项阶梯,所以要在前面判断给定的n是否大于等于2。因为(1,2)和(2,1)属于两种方案,所以其实是排列问题,所以背包在外物品在内。可以重复选择物品,所以顺序遍历。

classSolution:def climbStairs(self, n: int) ->int:if n <= 2:returnn

dp= [0 for i in range(n+1)]

dp[1] = 1dp[2] = 2step_choice= [1, 2]for i in range(3, n+1):for j inrange(len(step_choice)):

step=step_choice[j]if step <=i:

dp[i]+= dp[i-step]return dp[n]

leetcode746.使用最小花费爬楼梯

数组的每个下标作为一个阶梯,第 i 个阶梯对应着一个非负数的体力花费值 cost[i](下标从 0 开始)。每当你爬上一个阶梯你都要花费对应的体力值,一旦支付了相应的体力值,你就可以选择向上爬一个阶梯或者爬两个阶梯。请你找出达到楼层顶部的最低花费。在开始时,你可以选择从下标为 0 或 1 的元素作为初始阶梯。

思路:实际上需要爬到第i+1个楼梯。dp[i]表示爬到第i个楼梯所需要的最小花费,则该花费的方案是:上一次爬一个、或上一次爬两个中的最小值。比较绕的是到底要爬到哪一层。

leetcode62.不同路径

一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为 “Start” )。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为 “Finish” )。

问总共有多少条不同的路径?

python 动态规划设计leetcode_leetcode_动态规划_python_第1张图片

思路:方法1:排列组合。相当于一共需要向下走m-1步,向右走n-1步,即从m+n-2中选m-1向下其余均向右Cm+n-1n-1。计算时为了防止溢出,每次都除。Cmn类公式上下都有n项,所以直接range(0,n) (此处为n-1),减去即可。

classSolution:def uniquePaths(self, m: int, n: int) ->int:

res= 1num1= m+n-2count= n-1num2= n-1

for i inrange(count):

res= res*(num1-i)/(num2-i)return round(res)

方二:动态规划。dp[i][j]走到(i,j)的路径数目。初始化时注意最左边的一列和最上边的一行只有一种路径。且在迭代时,从1开始,即不要修改初始化的值!因为python里list索引-1也是有效的,不会报错但结果不正确。所以动态规划类问题注意在迭代时避开初始化的位置!避开初始化的位置!避开初始化的位置!

leetcode63.不同路径2

一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为“Start” )。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为“Finish”)。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径?

思路:类似62.区别在于1.初始化时,对于最上面和最左边,一旦有障碍,则后面所有点都不可达,路径数目为0。2.中间如果是障碍,直接路径为0。

leetcode343.整数拆分

给定一个正整数 n,将其拆分为至少两个正整数的和,并使这些整数的乘积最大化。 返回你可以获得的最大乘积。

思路:方法一:可以证明(利用多项的均值不等式,对拆成m个加和的m求导,算出最佳均值为e),将数拆成3的加和乘积最大,如果不能,若余1则退一个3补两个2,余2则直接补2.注意判断数字是否小于3,3以下单论。

classSolution:def integerBreak(self, n: int) ->int:if n==2: #注意这两种情况需要单独考虑 因为推公式时单独考虑了

return 1

if n == 3:return 2order_3= n//3

if n%3 ==0:return int(math.pow(3, order_3))elif n%3 == 1:#退1个3补两个2

return int(math.pow(3, order_3-1)*4)else:return int(math.pow(3, order_3)*2)

方法二:dp[i]表示拆分数字i可以获得的最大乘积。假设其中一个差分数为j,则dp[i]为dp[i]本身,(拆分成两个,i-j不拆分)j*(i-j),(拆分成三个及以上,i-j拆分)j*dp[i-j]中的最大值。注意j的取值范围,因为另一个数要拆分则必然大于等于2,所以j最大取到i-2,因此是i-1的半开区间。

classSolution:def integerBreak(self, n: int) ->int:

dp= [0 for i in range(n+1)]

dp[2] = 1

#dp[3] = 2

for i in range(3,n+1): #i=num1+(i-num1)

for num_1 in range(1,i-1):#注意范围 从1开始 因为要保证另一个索引大于等于2 所以半开为i-1

dp[i] = max(dp[i], num_1*(i-num_1), num_1 * dp[i-num_1])return dp[n]

leetcode96.不同的二叉搜索树

给定一个整数 n,求以 1 ... n 为节点组成的二叉搜索树有多少种?

思路:首先要明确一个概念,对于递增序列,相同数量的节点意味着相同数量的BST种类,因为BST与各个元素间的相对值大小有关,但与具体是多少值无关。dp[i]:i个节点的递增序列能构成的BST种类。根节点可以选择1到i,所以j的范围取[1,i+1),二叉树种类数等于所有根节点带来的种类之和。注意迭代时要跳过初始化!跳过初始化!跳过初始化!

classSolution:def numTrees(self, n: int) ->int:

dp= [0 for i in range(n+1)]

dp[0]= 1dp[1] = 1

for i in range(2, n+1):for j in range(1,i+1):#注意范围

dp[i] += dp[j-1]*dp[i-j]return dp[n]

leetcode416.分割等和子集

给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集,使得两个子集的元素和相等。

思路:即找到集合使得集合内元素的和为数组总和的一半。因为所有数字都是整数,所以如果总和不能被2整除则返回False。相当于nums为物品的重量,dp[i]为向容量为i的背包里装东西。方法一:dp[i]表示容量为[i]的背包在目前已经见过物品的组合情况下是否能装满。注意dp[0]要初始化为True。方法二:dp[i]表示容量为i的背包在目前已见过物品品的组合情况下最多能装多少,最后判断target是否能装满。

易错点:1.因为每个物品只能选择一次,所以外层写物品内层写背包,且背包是倒序。2.正序闭区间[a,b]写法为range(a,b+1),即末尾的加上步长,所以[a,b]倒叙的写法为[b,a-1],加上步长-1。

classSolution:def canPartition(self, nums: List[int]) ->bool:#有一个重量为sum/2的背包,最多可以放多少东西 等于则可以

sum_all=sum(nums)if sum_all%2:returnFalseelse:

capacity_bag= sum_all//2dp= [0 for i in range(capacity_bag+1)] #dp[i]:dp[重量]

for i inrange(len(nums)):

weight_object=nums[i]for j in range(capacity_bag,weight_object-1,-1): #[weight_object, capacity_bag]倒序

dp[j] = max(dp[j], dp[j-weight_object]+weight_object)if dp[capacity_bag] ==capacity_bag:returnTruereturn dp[capacity_bag] == capacity_bag

leetcode1049.最后一块石头的重量

有一堆石头,每块石头的重量都是正整数。

每一回合,从中选出任意两块石头,然后将它们一起粉碎。假设石头的重量分别为 x 和 y,且 x <= y。那么粉碎的可能结果如下:如果 x == y,那么两块石头都会被完全粉碎;如果 x != y,那么重量为 x 的石头将会完全粉碎,而重量为 y 的石头新重量为 y-x。最后,最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下,就返回 0。

思路:将一堆石头分成两部分,每部分接近总重量的一半。注意写倒序的两个要点:范围,范围,范围,要写-1,要写-1,要写-1。

leetcode494.目标和

给定一个非负整数数组,a1, a2, ..., an, 和一个目标数,S。现在你有两个符号 + 和 -。对于数组中的任意一个整数,你都可以从 + 或 -中选择一个符号添加在前面。返回可以使最终数组和为目标数 S 的所有添加符号的方法数。

思路:相当于凑目标和,加号集合和减号集合的和已知,差已知,所以凑加号集合的目标和。首先考虑目标:方法数。因此dp[i]设置为装满i容量包的方法数。初始化:dp[0] = 1。迭代:因为不能重复,所以倒序。边界条件:因为都是整数,所以目标和非整数不行;S的绝对值不能大于所有数的和。

classSolution:def findTargetSumWays(self, nums: List[int], S: int) ->int:#left+right = sum(nums) left-right = S->left = (sum(nums)+S)//2

sum_positive_set = (sum(nums)+S)//2

if (sum(nums)+S)%2 or abs(S)>sum(nums): #注意

return0

dp= [0 for i in range(sum_positive_set+1)] #dp[i] 凑到i有多少种方法

dp[0] = 1

for i inrange(len(nums)):

value_num=nums[i]for j in range(sum_positive_set,value_num-1,-1):

dp[j]+= dp[j-value_num] #已有的方法加上通过nums[i]可以凑出的方法

return dp[sum_positive_set]

leetcode474.一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。请你找出并返回 strs 的最大子集的大小,该子集中 最多 有 m 个 0 和 n 个 1 。

思路:最大子集元素数量dp[0的个数][1的个数]。需要注意两点:1.迭代时最大的情况有两个:最大子集没有该元素,即已经是最大的;最大子集有该元素,则总大小为另一半集合的大小加上1(该元素的大小)。3.虽然dp设置为二维,但并不是二维dp,而是滚动数组,因为迭代时涉及到本轮for的变量。而本题不能元素不能重复取用,所以要用倒序。

classSolution:def findMaxForm(self, strs: List[str], m: int, n: int) ->int:

dp= [[0 for i in range(n+1)] for i in range(m+1)] #dp[0的个数][1的个数]子集大小 注意次序

defgetNumZeroAndOne(string):

num_one=0

num_zero=0for i inrange(len(string)):if string[i] == '0':

num_zero+= 1

elif string[i] == '1':

num_one+= 1

returnnum_zero, num_onefor i_str inrange(len(strs)):

string_temp=strs[i_str]

num_zero, num_one=getNumZeroAndOne(string_temp)for i in range(m, num_zero-1, -1): #注意倒序

for j in range(n, num_one-1,-1):

dp[i][j]= max(dp[i][j], dp[i-num_zero][j-num_one]+1) #注意+1

return dp[m][n]

leetcode518.零钱兑换2

给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。

思路:可以重复使用,所以遍历顺序从前往后。dp[i]表示组合数,外层for循环表示在num[:i]中的组合数。

classSolution:def change(self, amount: int, coins: List[int]) ->int:if notcoins:return 1 if amount == 0 else0

dp= [0 for i in range(amount+1)]

dp[0]= 1

for i inrange(len(coins)):

value_coin=coins[i]for i_dp in range(value_coin, amount+1):

dp[i_dp]+= dp[i_dp-value_coin]return dp[amount]

leetcode377.组合总和4

给定一个由正整数组成且不存在重复数字的数组,找出和为给定目标正整数的排列个数(长度不限)。

思路:排列问题,物品的顺序要求各种都有,所以背包在外物品在内。可以重复,所以顺序遍历。注意:背包是否能放下物品。

classSolution:def combinationSum4(self, nums: List[int], target: int) ->int:

dp= [0 for i in range(target+1)]

dp[0]= 1

for i in range(1, target+1): #排列问题先背包后物品

for num_temp innums:if num_temp <=i:

dp[i]+= dp[i-num_temp]return dp[target]

leetcode279.完全平方数

给定正整数 n,找到若干个完全平方数(比如 1, 4, 9, 16, ...)使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。给你一个整数 n ,返回和为 n 的完全平方数的 最少数量 。

思路:和为i的集合最小元素数量dp[i]。num dp[i] = min(dp[i], dp[i-num]+1)。所以dp[i]初始化为无限大,dp[0]=0。强调数量,所以是组合问题。可以重复取用->顺序遍历。注意平方数中要考虑1,1的平方=1而其他数的平方均比本身大。所以可以单拿1出来或者在平方数内考虑到n。

classSolution:def numSquares(self, n: int) ->int:#排列还是组合->for谁在外谁在内 是否可以重复选元素:顺序还是倒序

dp = [float('inf') for i in range(n+1)]

dp[0]=0for i in range(1, n+1):

num= i*ifor j in range(num, n+1):

dp[j]= min(dp[j], dp[j-num]+1)return dp[n]

leetcode139.单词拆分

给定一个非空字符串 s 和一个包含非空单词的列表 wordDict,判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

说明:拆分时可以重复使用字典中的单词。你可以假设字典中没有重复的单词。

思路:dp[i]表示s[:i)是否可以拆分,则i的最大值为len(s),所以range内取len(s)+1。dp[i] = dp[i] or dp[j] and s[j:i] in wordDict。因此dp[0]取True

classSolution:def wordBreak(self, s: str, wordDict: List[str]) ->bool:

dp= [False for i in range(len(s)+1)] #dp[i]:s[:i]是否在字典里

dp[0] =Truefor i in range(len(s)+1):for j inrange(i):

dp[i]= dp[i] or s[j:i] in wordDict anddp[j]return dp[len(s)]

你可能感兴趣的:(python,动态规划设计leetcode)