1.杨辉三角形初始化边界条件时要初始化两条边
n = int(input(''))
arr = []
for i in range(n):
arr.append([])
for j in range(i+1):
if j == 0 or i == j:
arr[i].append(1)
else:
arr[i].append(arr[i-1][j-1] + arr[i-1][j])
print(" ".join(str(a) for a in arr[i]))
2. 节点选择
树形的dp,底层是递归的形式。
自下而上决策,所以从树的下一节点推到当前节点视为一个子问题。
dp的形式是二维的,因为在一个子问题中,可根据是否选择当前节点分为两类
如果选择当前节点,那么该子问题的权重为节点权重加上下一节点里,不含下一节点的权重的和
如果不选择当前节点,那么该子问题的权重为下一节点的权重中最大的那个的和
def dfs(node,pre):
global value,table
for i in table.get(node):
if i !=pre:
dfs(i,node)
value[node][0]+=max(value[i][0],value[i][1])
value[node][1]+=value[i][0]
def main():
global value, table
n = int(input())
value = list(map(int, input().split()))
value = list(map(lambda x:[0,x],value))
value.insert(0,0)
table = {}
for i in range(n):
table.update({i + 1: []})
for i in range(n - 1):
father, child = list(map(int, input().split()))
table.get(father).append(child)
table.get(child).append(father)
print(table)
dfs(1,0)
print(max(value[1][0],value[1][1]))
if __name__=='__main__':
main()
复制别人的(哭哭哭,不会)
3.耐摔指数:动态规划——耐摔指数_zx841的博客-CSDN博客
(大佬的博文)
4. 爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢?
示例 1:
输入:n = 2
输出:2
解释:有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶
示例 2:输入:n = 3
输出:3
解释:有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶
提示:
1 <= n <= 45
def climbStairs(self, n: int) -> int:
a = b = 1
for i in range(2, n + 1):
a, b = b, a + b
return b
5. 使⽤最⼩花费爬楼梯
给你一个整数数组 cost ,其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用,即可选择向上爬一个或者两个台阶。
你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。
请你计算并返回达到楼梯顶部的最低花费。
示例 1:
输入:cost = [10,15,20]
输出:15
解释:你将从下标为 1 的台阶开始。
- 支付 15 ,向上爬两个台阶,到达楼梯顶部。
总花费为 15 。
示例 2:输入:cost = [1,100,1,1,1,100,1,1,100,1]
输出:6
解释:你将从下标为 0 的台阶开始。
- 支付 1 ,向上爬两个台阶,到达下标为 2 的台阶。
- 支付 1 ,向上爬两个台阶,到达下标为 4 的台阶。
- 支付 1 ,向上爬两个台阶,到达下标为 6 的台阶。
- 支付 1 ,向上爬一个台阶,到达下标为 7 的台阶。
- 支付 1 ,向上爬两个台阶,到达下标为 9 的台阶。
- 支付 1 ,向上爬一个台阶,到达楼梯顶部。
总花费为 6 。
提示:
2 <= cost.length <= 1000
0 <= cost[i] <= 999
class Solution:
def minCostClimbingStairs(self, cost: List[int]) -> int:
length=len(cost)
if length==0:
return
if length==1:
return cost[0]
if length==2:
return min(cost[0],cost[1])
if length==3:
return min(cost[0]+cost[2],cost[1])
dp=[0,cost[0],min(cost[0],cost[1]),min(cost[0]+cost[2],cost[1])]
for i in range(4,len(cost)+1):
a=min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2])
dp.append(a)
print(dp)
return dp[len(cost)]
6.买卖股票的最佳时机
给定一个数组 prices ,它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票,并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润,返回 0 。
示例 1:
输入:[7,1,5,3,6,4]
输出:5
解释:在第 2 天(股票价格 = 1)的时候买入,在第 5 天(股票价格 = 6)的时候卖出,最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格;同时,你不能在买入前卖出股票。
示例 2:输入:prices = [7,6,4,3,1]
输出:0
解释:在这种情况下, 没有交易完成, 所以最大利润为 0。
提示:
1 <= prices.length <= 105
0 <= prices[i] <= 104
class Solution:
def maxProfit(self, prices: List[int]) -> int:
dp0 = 0
dp1 = - prices[0]
dp2 = float('-inf')
for i in range(1, len(prices)):
dp1 = max(dp1, dp0 - prices[i])
dp2 = max(dp2, dp1 + prices[i])
return max(dp0, dp2)
7. 最⻓公共⼦序列
给定两个字符串 text1 和 text2,返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ,返回 0 。
一个字符串的 子序列 是指这样一个新的字符串:它是由原字符串在不改变字符的相对顺序的情况下删除某些字符(也可以不删除任何字符)后组成的新字符串。
例如,"ace" 是 "abcde" 的子序列,但 "aec" 不是 "abcde" 的子序列。
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。示例 1:
输入:text1 = "abcde", text2 = "ace"
输出:3
解释:最长公共子序列是 "ace" ,它的长度为 3 。
示例 2:输入:text1 = "abc", text2 = "abc"
输出:3
解释:最长公共子序列是 "abc" ,它的长度为 3 。
示例 3:输入:text1 = "abc", text2 = "def"
输出:0
解释:两个字符串没有公共子序列,返回 0 。提示:
1 <= text1.length, text2.length <= 1000
text1 和 text2 仅由小写英文字符组成。
class Solution:
def longestCommonSubsequence(self, text1: str, text2: str) -> int:
m, n = len(text1), len(text2)
f = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if text1[i - 1] == text2[j - 1]:
f[i][j] = f[i - 1][j - 1] + 1
else:
f[i][j] = max(f[i - 1][j], f[i][j - 1])
return f[m][n]