动态规划

递归写法（速度慢）：

def fibonacci(n):
    if n in (1, 2):
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(8))

非递归形式：

def fibonacci(n):
    if n in (1, 2):
        return 1
    else:
        arr = [0]*n
        arr[0]=1
        arr[1]=1
        for i in range(2,n):
            arr[i]=arr[i-1]+arr[i-2]

    return arr[-1]

或

def fibonacci(n):
    if n in (1, 2):
        return 1
    else:
        arr = [1]*n
        for i in range(2,n):
            arr[i]=arr[i-1]+arr[i-2]

    return arr[-1]

存在的问题：重复的计算




选择不相邻的数，使其和最大

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

def rec_opt(n):
    if n == 0:
        return arr[0]
    if n == 1:
        return max(arr[0], arr[1])
    return max(arr[n] + rec_opt(n - 2), rec_opt(n - 1))

print(rec_opt(len(arr)-1))

非递归方法：

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


def rec_opt(n):
    opt = [0] * n
    opt[0] = arr[0]
    opt[1] = max(arr[0], arr[1])

    for i in range(2, n):
        opt[i] = max(arr[i] + opt[i - 2], opt[i - 1])

    return opt[-1]


print(rec_opt(7))

选择一组数使其和为9，假设数组的元素为非负。能找到返回True，否则 False

出口有3中选择：

递归写法：

arr =[3,34,4,12,5,2]
def rec_subset(i,s):
    if s==0:
        return True
    if i==0:
        return arr[0]==s
    if arr[i]>s:
        return rec_subset(i-1,s)
    A=rec_subset(i-1,s-arr[i])
    B=rec_subset(i-1,s)
    return A or B

print(rec_subset(len(arr)-1,9))

上图，arr[2]=4>3，所以arr[2]一定不选。


非递归形式：

import numpy as np

arr = [3, 34, 4, 12, 5, 2]


def dp_subset(S):
    subset = np.zeros((len(arr), S+1), dtype=bool)
    subset[:, 0] = True
    subset[0, 3] = True
    for i in range(1, len(arr)):
        for s in range(1, S + 1):
            if arr[i] > s:
                subset[i, s] = subset[i - 1, s]
            else:
                A = subset[i, s - arr[i]]
                B = subset[i - 1, s]
                subset[i, s] = A or B
    return subset[-1,-1]


print(dp_subset(9))