Python 动态规划理解

一、用空间换取时间

动态规划可以将指数级别的复杂度简化为幂级别的复杂度，但是却增加了空间，采取用空间换时间的策略，也有人称之为带备忘录的的递归。

二、例题

一个经典的动态规划的问题 nums = 【1，5，4，2，3】选取最长递增子序列的长度

第一思路：递归枚举将所有的可能全部列出来，然后寻找最大的在一个

#memo  = {}
def L(nums,i):#返回这个数组从第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)):#接着遍历从i以后的最长的长度
        if nums[j]>nums[i]:
            max_len=max(max_len,L(nums,j)+1)
    #memo[i] = max_len
    return max_len

def length_of_LIS(nums):
    return max(L(nums,i) for i in range(len(nums)))

nums=[1,5,2,4,3]
print(length_of_LIS(nums))

这样我们会发现有很多重复的计算，使算法效率大大降低，所以可以采用一个字典\哈希表来进行存储，将之前得到的计算的数值存起来，这样到再次用到这个结果的时候就直接返回，这样就能大大的降低算法的时间复杂度。

本题或者采用迭代的方式

def length_of_LIS(nums):
    n = len(nums)
    L= [1]*n

    for i in reversed(range(n)):
        for j in range(i+1,n):
            if nums[j]>nums[i]:
                L[i]=max(L[i],L[j]+1)
    return max(L)
nums = [1,5,2,3,6]
print(length_of_LIS(nums))

首次建立一个数组用于保存结果，采用两层for循环，第一层for循环倒着遍历从最后一个数开始的最长子序列，第二成for循环查找之前数字的最大子序列，并选出最大的保存到数组当中，最后这样返回数组中的最大值就可以了。