1. 连续子数组的最大和
class Solution:
def FindGreatestSumOfSubArray(self , array: List[int]) -> int:
# write code here
# 动态规划解法 时间复杂度为 O(n)O(n),空间复杂度为 O(n)O(n)
# 新建dp数组,用于存放 以每个index为结尾的最大和子数组的最大和
# 注意for循环要以1开始,因为从0开始的话没有dp[0-1]
lenth = len(array)
if lenth == 0:
return 0
dp = [array[0]]*(lenth)
for i in range(1, lenth):
dp[i] = max(array[i], array[i] + dp[i-1])
return max(dp)
# 两个变量的方法 时间复杂度为 O(n)O(n),空间复杂度为 O(1)O(1)
# 一个变量用于去尝试做加法,看看加了array[i]是不是变大了,如果拖累了array[i],就把它前面的舍弃,只要array[i]
# 一个变量用于计算当前的累计最大值,相当于使用sum来表示dp数组的最大值
sum, res = 0, array[0]
for i in range(len(array)):
sum += array[i]
if array[i] > sum:
sum = array[i]
res = max(res,sum)
return res
# 跟上面的方法很类似,不同点在于,把上述array[i] > sum的判断条件换成了s<0
# 上面的方法是从当前元素的角度看待问题,这个方法是从下一步的角度看待问题
# 如果s<0说明目前的总和是负数,会拖累下一步的array[i+1]值,因此赶快把它置为0以不影响下一步
s,res = 0,array[0]
for num in array:
s += num
if res<s:
res = s
if s<0:
s = 0
return res
# 也是用两个变量,但需要额外限制数字大小的下限
# 这是一种更好理解的方法,如果前一步的总和now<0, 就舍弃掉,直接把now再次设为当前值
now=0
ans=-1000000000
for i in array:#此处i即代表array里面的第i个元素的值
if now<0 :
now=i#now<0,则舍去前面的
else :
now+=i
ans=max(ans,now)#更新ans
return ans
2.跳台阶
class Solution:
def jumpFloor(self , number: int) -> int:
# write code here
# 根据动态规划的思想,我们可以将跳上n级台阶有多少种跳法转换成:
# n-1级台阶有多少种跳法 + n-2级台阶有多少种跳法
# 因为从n-1级到n级只有一种固定跳法,从n-2级到n级也只有一种固定跳法(为什么呢?)
# n-2级到n级虽然有两种跳法,但是如果使用一阶一阶跳,那么这种情况已经包含在了n-1级台阶有多少种跳法中了,
# 因为n-1级台阶有多少种跳法包含n-2到n-1跳一阶,n-1到n肯定也是一阶
# 因此按照这个思路,我们定义dp_0为n-2级台阶有多少种跳法; dp_1为n-1级台阶有多少种跳法
# 要计算n阶,就dp_0 + dp_1,然后我们把这个n阶又作为下一次迭代的n-1级,即dp_1,显然之前的n-1阶就成了n-2阶了,因此dp_0=dp_1
dp_0 = 0
dp_1 = 1
for i in range(number):
temp = dp_1
dp_1 = dp_0 + dp_1
dp_0 = temp
return dp_1
3.斐波那契数列
class Solution:
def Fibonacci(self , n: int) -> int:
# write code here
# 跟跳台阶很相似
dp_1, dp_2, res = 1, 1, 1
for i in range(3, n+1):
res = dp_1 + dp_2
dp_2 = dp_1
dp_1 = res
return res