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” )。

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

思路：方法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)]