Python之动态规划问题

动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。

动态规划之Fib数列

有个小孩上楼梯，共有N阶楼梯，小孩一次可以上1阶，2阶。走到N阶楼梯，一共有多少种走法？
DP之自顶向下分析方式：
爬到第N阶楼梯，一共只有2种情况(全划分，加法原理)，从第N-1阶爬1阶到第N阶；从第N-2阶爬2阶到第N阶；
因此：way(N)=way(N-1)+way(N-2)

"""动态规划 先解决小数据量的 再层层递推的解决大数据量级的问题 时间复杂度o(n)"""
"""上楼梯问题：N阶楼梯 一次能上1或2层 共有多少种上法"""

#使用fib数列
def fib2(n):
    memo=[-1 for x in range(n)]
    memo[0]=1
    memo[1]=2
    for i in range(2,n):
        memo[i]=memo[i-1]+memo[i-2]
    return memo[n-1]
print(fib2(5))
----------------------------------------------
8

任务安排问题

在做任务时间不冲突的情况下，求出所做任务的收益最大值。

# 数组arr存储的是每个任务的收益；
arr = [0, 5, 1, 8, 4, 6, 3, 2, 4]
#数组prev存储的是指定任务之前可以执行的任务
prev = [0, 0, 0, 0, 1, 0, 2, 3, 5]

def dp_opt(arr):
    #计算任务的长度
    len_arr = len(arr)
    # 存储执行到每个任务可以获得的最优解;
    opt = [0 for i in range(len_arr)]
    opt[0] = 0
    opt[1] = arr[1]
    for i in range(2, len(arr)):
        # 不选择做这个任务的最优解；
        A = opt[i - 1]
        # 选择做这个任务的最优解；
        B = arr[i] + opt[prev[i]]
        opt[i] = max(A, B)
    return opt[-1]
print(dp_opt(arr))

不相邻数最大和

问题描述: 给定数组A=[1,2,4,1,7,8,3]，求出数组A中互不相邻的数的最大和。
例如：如果选择了8，则不能选择7和3，在本例中最大的和为1+4+7+3=15

arr=[0,1,2,4,1,7,8,3]

def dp_result(arr):
    memo=[0 for i in range(len(arr))]
    memo[0]=0
    memo[1]=arr[1]
    memo[2]=arr[2]
    print(memo[0])
    print(memo[1])
    print(memo[2])
    for i in range(3,len(arr)):
        A=memo[i-1]
        B=arr[i]+memo[i-2]
        memo[i]=max(A,B)
        print(memo[i],end=',')
    return memo[-1]

print('\n数组中互不相临的数的最大和为:',dp_result(arr))
------------------------------------------------------
0
1
2
5,5,12,13,15,
数组中互不相邻的数的最大和为: 15

使用numpy解决：

import numpy as np

A=[1,2,4,1,7,8,3]

def non_rec_f(A):
    opt=np.zeros(len(A))
    opt[0]=A[0]
    opt[1]=max(A[0],A[1])
    for i in range(2,len(A)):
        opt[i]=max(opt[i-2]+A[i],opt[i-1])
    return opt[-1]
print(non_rec_f(A))
----------------------------------------------
15.0