【算法之Python篇】动态规划

爬楼问题

方法一

递归方法实现爬10阶楼梯的问题

def F(n):
    if n==1:
        return 1
    if n==2:
        return 2
    return F(n-2)+F(n-1)

print(F(10))

>>>89

方法二

10阶楼梯运用单纯递归的方法轻松得到结果，可是当阶数变成100的时候或者更多的时候，想要得出结果可就没有怎么轻松了，则就需要通过剔除重复项将算法进行优化。

def F(n):
    if n==1:
        return 1
    if n==2:
        return 2
    if res[n]!=0:
        return res[n]
    res[n]= F(n-2)+F(n-1)
    return  res[n]
step=100
res=[0 for i in range(step+1)]
print(F(step))

>>>573147844013817084101

通过观察方法一和方法二应该可以看到通过增加一个这条语句if res[n]!=0: return res[n]，或者更准确的来说是增加一个数组（或称备忘录）res[n]解决了100阶爬楼梯问题，此时增加的这条数组（或称备忘录）就是我们动态规划算法的标致之一。

方法三

通过计算上述算法时间复杂度为O（2^n），我们将它再优化到线性阶O（n）。

def F(n):
    for step in range(3,n+1):
        res[step]=res[step-1]+res[step-2]
    return res[n]
step=100
res=[0 for i in range(step+1)]
res[1]=1
res[2]=2
print(F(step))

>>>573147844013817084101

背包问题

问题描述：在背包有限的情况下使背包价值最大。
本题描述：背包容积为13。

可以分解成两种问题:
第一种，放入第i件物品，得出公式 V(i-1，j-w_i)+v_i
因为加入第i件物品，背包体积就要减去第i件物品的体积，相应价值也应该加上所以就得出上述公式
第二种，不放入第i件物品，得出公式 V(i-1，j)

根据上述公式得出的表达式
因当前背包容积j小于当前第i件物品的容量时物品放不进去所以为V(i-1，j)

##背包问题
def knapsack(v,w,c):
    #构建备忘录数组
    rec=[[0 for i in range(c+1)] for j in range(len(v))]
    #设计辅助跟踪数组:取值为0、1（0：i件物品没有放到背包，1：i件物品放到背包）
    route=[[0 for i in range(c+1)] for j in range(len(v))]
    
    #利用递推关系填写rec（1，1）开始填
    for i in range(1,len(v)):#控制当前填的i行
        for j in range(1,c+1):#控制当前填的j列，当前背包剩余容量为j
            if j<w[i]:#当前容量小于第i件物体体积
                rec[i][j]=rec[i-1][j]
            else:#比较放第i件物品的解和不放第i件物品的解rec[i][j]=max(rec[i-1][j],v[i]+rec[i-1][j-w])
                if rec[i-1][j]>v[i]+rec[i-1][j-w[i]]:
                    rec[i][j]=rec[i-1][j]  
                else:
                    #此处为放入i物品
                    route[i][j]=1
                    rec[i][j]=v[i]+rec[i-1][j-w[i]]
    #追踪放入的物品
    i=len(v)-1 #定位行
    j=c         #定位列       
    goods_list=[]#商品列表，存储最终放入物品清单
    while i>=1:
        if route[i][j]==1: #第i件物品放入背包
            goods_list.append(i)
            j=j-w[i]
        i=i-1#往上找i=i-1
    return rec[-1][-1],goods_list

#商品的价值信息
#商品价值	9	10	9	2	24
#商品体积	4	5	4	3	10
V=[0,9,10,9,2,24]
W=[0,4,5,4,3,10]
#!背包容量
C=13
print(knapsack(V,W,C))

>>>(28, [3, 2, 1])

最长公共子序列

问题描述：求两个给定序列的最长公共子序列。
与背包问题有异曲同工之处，也是需要对问题进行分析。
根据子序列分析也是有两种情况：
第一种最后的符号不相同
第二种最后的符号相同
据上得出下面公式

def com_str(x,y):
    rec=[[0 for j in range(len(y))] for i in range(len(x))]
    route=[[0 for j in range(len(y))] for i in range(len(x))]
    for i in range(1,len(x)):
        for j in range(1,len(y)):
            if x[i]==y[j]:
                rec[i][j]=rec[i-1][j-1]+1
                route[i][j]=1
            else :
                if rec[i][j-1]>rec[i-1][j]:
                    rec[i][j]=rec[i][j-1]
                    route[i][j]=3
                else:
                    rec[i][j]=rec[i-1][j]
                    route[i][j]=2
    #追踪
    i=len(x)-1
    j=len(y)-1
    item_list=[]
    while i>1:
        if route[i][j]==1:
            item_list.append(x[i])
            i-=1
            j-=1
        elif route[i][j]==2:
            i-=1
        else:
            j-=1
            
    return rec[-1][-1],item_list[::-1]



X=["","A","B","C","B","B","A","B"]
Y=["","B","D","C","B","B","B"]
print(com_str(X,Y))


>>>(5, ['B', 'C', 'B', 'B', 'B'])

硬币找零问题

import sys
def change(coins,amount):
    
    rec=[[0 for j in range(amount+1)] for i in range(len(coins))]
    route=[[0 for j in range(amount+1)] for i in range(len(coins))]
    rec[0]=[sys.maxsize]*(amount+1)#sys.maxsize无穷大
    for i in range(1,len(coins)):
        for j in range(1,amount+1):
            if j<coins[i]:
                rec[i][j]=rec[i-1][j]
            else:
                if rec[i-1][j]<1+rec[i][j-coins[i]]:
                    rec[i][j]=rec[i-1][j]
                else:
                    rec[i][j]=rec[i][j-coins[i]]+1
                    route[i][j]=1
                    
    #追踪
    coin_list=[]
    i=len(coins)-1
    j=amount
    while i>=1 and j>=1:
        if route[i][j]==1:
            coin_list.append(coins[i])
            j-=coins[i]
        else:
            i-=1
            
    return rec[-1][-1],coin_list           
                    
COINS=[0,1,3,4,5]
change(COINS,11)

>>>(3, [5, 5, 1])

总结

动态规划旨在剔除递归中的重叠子问题