动态规划算法

---

学习视频：https://www.bilibili.com/video/BV1AB4y1w7eT

1、穷举法/暴力规划法

时间复杂度：
数组中的每个数，可以取，也可以不取，复杂度：O(2^n)
子序列最多遍历n次，复杂度：O(n)
总复杂度：O(n*2^n)

L=[1,5,2,4,3]
def e(nums,i):
    if i ==len(nums)-1:
        return 1
    max_len=1
    for j in range(i+1,len(nums)):
        if nums[j]>nums[i]:  # 可取，也可以不取，复杂度2^n
            max_len=max(max_len,e(nums,j)+1)
    return max_len
def length_of_e(nums):
    return max(e(nums,i) for i in range(len(nums)))  # 子序列遍历，复杂度n次
print(length_of_e(L))

2、记忆化搜索/带备忘录递归/递归树剪枝

方法1存在问题：子序列一直存在被重复遍历的情况，所以可以借助长度保存。当下次使用时已存在此子序列长度，则直接返回。
注意：memo的使用。
优势：以空间换时间

L=[1,5,2,4,3]
memo={}
def e(nums,i):
    if i in memo:
        return memo[i]
    if i ==len(nums)-1:
        return 1
    max_len=1
    for j in range(i+1,len(nums)):
        if nums[j]>nums[i]:
            max_len=max(max_len,e(nums,j)+1)
    memo[i]=max_len
    return max_len
def length_of_e(nums):
    return max(e(nums,i) for i in range(len(nums)))
print(length_of_e(L))

3、非递归/迭代方式

优势：直接计算时间复杂度，避免递归函数开销

n=int(input())
s=[int(i) for i in input().split()]
L=[1]*n 
for i in reversed(range(n)):
    for j in range(i+1,n):
        if s[j]>s[i]: # 注意这里的前提条件，若未进入循环，则为1.
            L[i]=max(L[i],L[j]+1) # 拿L[i]和L[j]+1相比，如果大于1，就更新值。
print(max(L))