python 算法回顾(3) 递归和动态规划

递归问题

大问题分解成 多个 相同的小问题

递归和栈，有一定的关联

整数转换成任意进制的代码（递归方法）

思路： 进制转换问题 --> 整数除和求余数 

整数除和求余数（除以“进制基base” // base 和 对“进制基” 求余数 %base）

def convert_scale(n, base):
    convert_string = '0123456789ABCDEF'

    if n < base:
        return convert_string[n]
    else:
        return convert_scale(n // base, base) + convert_string[n % base]


print(convert_scale(233, 16))

递归和栈有一点的关系：当一个函数被调用的时候，系统会把调用时的现场数据压入到系统调用栈

python 内置的sys模块可以获取和调整最大的递归深度

import sys

print(sys.getrecursionlimit())  # 1000
sys.setrecursionlimit(3000)
print(sys.getrecursionlimit())  # 3000

递归可视化：分形树

import turtle
import time


def tree(branch_len, t):
    if branch_len > 5:
        time.sleep(1)
        t.forward(branch_len)  # 画树干
        t.right(20)  # 右斜20度
        tree(branch_len - 10, t)  # 递归调用，画右边的小树， 树干减15
        t.left(40)  # 向左回40度， 急左斜20度
        tree(branch_len - 10, t)  # 递归调用，画左边的小树， 树干减15
        t.right(20)  # 向右回20度，即回正
        t.backward(branch_len)  # 海龟退回到原来的位置


t = turtle.Turtle()
t.left(90)
t.penup()
t.backward(100)
t.pendown()
t.pencolor('green')
t.pensize(2)
tree(75, t)
t.hideturtle()
turtle.done()

河内塔的问题

分治策略

优化问题和贪心策略

找零兑换问题： 找零尽可能让硬币的数量最小

找零问题的递归解法

import time


def rec_mc(coin_value_list, change):
    min_coins = change  # 表示change元用change个1元
    if change in coin_value_list:
        return 1  # 最小规模直接返回
    else:
        for i in [c for c in coin_value_list if c <= change]:
            num_coins = 1 + rec_mc(coin_value_list, change - i)  # 调用自身，减小规模：每次减去一种硬币面值，
            if num_coins < min_coins:  # 挑选最小数量
                min_coins = num_coins
    return min_coins


star_time = time.time()
print(rec_mc([1, 5, 10, 25], 63))
print("time consume", time.time() - star_time)  # time consume 64.45321083068848

找零问题的递归解法， 改进后的代码： (记忆化/函数值缓存提高了递归解法的性能)

import time


def rec_mc(coin_value_list, change, known_results):  # 增加参数
    min_coins = change  # 表示change元用change个1元
    if change in coin_value_list:  # 递归基本结束条件
        known_results[change] = 1
        return 1  # 最小规模直接返回
    elif known_results[change] > 0:
        return known_results[change]  # 表明已经有了最优解， 查表成功，直接使用最优解
    else:
        for i in [c for c in coin_value_list if c <= change]:
            num_coins = 1 + rec_mc(coin_value_list, change - i, known_results)  # 调用自身，减小规模：每次减去一种硬币面值，
            if num_coins < min_coins:  # 挑选最小数量
                min_coins = num_coins
                known_results[change] = min_coins  # 找到最优解，记录到表中
    return min_coins


star_time = time.time()
print(rec_mc([1, 5, 10, 25], 63, [0]*64))
print("time consume", time.time() - star_time)  # time consume 0.0002810955047607422

找零问题的 动态规划解法 

动态规划算法采用了一种更有条理的方式来得到问题的解

找零兑换的动态规划算法从最简单的“1分钱找零”的最优解开始，逐步递加上去，直到我们需要的找零钱数

在找零递加的过程中，设法保持每一分钱的递加都是最优解，一直加到求解找零钱数，自然得到最优解。

递加的过程能保持最优解的关键是，其依赖于更少钱数最优解的简单计算，而更少钱数的最优解已经得到了。

问题的最优解    包含了  更小规模子问题的最优解，这是一个最优化问题能够用动态规划策略解决的必要条件。

简单版

# Dynamic programming
def dp_cake_change(coin_value_list, change, min_coins):
    # 从1分钱开始到change逐个计算最少硬币数
    for cents in range(1, change + 1):
        # 1. 初始化一个最大值
        coin_count = cents
        # 2. 减去每个硬币，向后查最少硬币数， 同时
        for j in [c for c in coin_value_list if c <= cents]:
            if min_coins[cents - j] + 1 < coin_count:
                coin_count = min_coins[cents - j] + 1
        # 3.得到当前的最少硬币数，记录到表中
        min_coins[cents] = coin_count

    return min_coins[change]


print(dp_cake_change([1, 5, 10, 21, 25], 63, [0] * 64))

完整版

# Dynamic programming
def dp_cake_change(coin_value_list, change, min_coins, coins_used):
    # 从1分钱开始到change逐个计算最少硬币数
    for cents in range(1, change + 1):
        # 1. 初始化一个最大值
        coin_count = cents
        new_coin = 1  # 初始化一个新加的硬币
        # 2. 减去每个硬币，向后查最少硬币数， 同时记录总的最少数
        for j in [c for c in coin_value_list if c <= cents]:
            if min_coins[cents - j] + 1 < coin_count:
                coin_count = min_coins[cents - j] + 1
                new_coin = j  # 对应最小数量，所减的硬币
        # 3.得到当前的最少硬币数，记录到表中
        min_coins[cents] = coin_count
        coins_used[cents] = new_coin  # 记录本步骤加的一个硬币
    return min_coins[change]


def print_coins(coins_used, change):
    coin = change
    while coin > 0:
        this_coin = coins_used[coin]
        print(this_coin)
        coin = coin - this_coin


money = 63
coin_list = [1, 5, 10, 21, 25]
the_min_coins = [0] * (money + 1)
the_coins_used = [0] * (money + 1)

print(dp_cake_change(coin_list, money, the_min_coins, the_coins_used))
print_coins(coins_used=the_coins_used, change=63)

博物馆大盗问题动态规划解法代码

# 宝物的重量和价值
tr = [
    None,
    {'w': 2, 'v': 3},
    {'w': 3, 'v': 4},
    {'w': 4, 'v': 8},
    {'w': 5, 'v': 8},
    {'w': 9, 'v': 10}
]

# 大盗最大承重
max_w = 20

# 初始化二维表格m[(i, w)]
# 表示前i个宝物中，最大重量w的组合，所得到的的最大价值
# 当i什么都不取，或w上限为0， 价值均为0
m = {(i, w): 0 for i in range(len(tr)) for w in range(max_w + 1)}


# 逐个填写二维表格
for i in range(1, len(tr)):
    for w in range(1, max_w + 1):
        if tr[i]['w'] > w:  # 装不下第i个宝物
            m[(i, w)] = m[(i - 1), w]
        else:
            # 不装第i个宝物，装第i个宝物，两种情况下最大价值
            m[(i, w)] = max(m[(i - 1, w)], m[(i - 1, w - tr[i]['w'])] + tr[i]['v'])

# 输出结果
print(m[(len(tr) - 1, max_w)])

为了进一步理解，我将结果m这个无序字典转换成有序字典。 然后用excel表显示出来，加深理解

其他知识： 无序字典变有序字典

from collections import OrderedDict
m={3:2,2:1,1:0}
print(OrderedDict(sorted(m.items())))

博物馆大盗问题递归解法代码

# 宝物的重量和价值(这里用set()集合使得tr为不可变类型,还可以用来计算，tuple()的话就不能计算)
tr = {
    (2, 3),
    (3, 4),
    (4, 8),
    (5, 8),
    (9, 10)
}

# 大盗最大承重
max_w = 20

# 初始化记忆化表格m
# Key是（宝物组合，最大重量），value是最大价值
m = {}


def theif(tr, w):
    # 情况: 什么都没得选，或者最大负重为0
    if tr == set() or w == 0:
        m[(tuple(tr), w)] = 0  # tuple是key的要求
        return 0  # 返回的最大重量是0
    # 如果表中存在，则直接返回
    elif (tuple(tr), w) in m:
        return m[(tuple(tr), w)]
    # 核心部分
    else:
        vmax = 0
        for t in tr:  # 每个t的都有可能产生最大v_max
            if t[0] <= w:
                # 逐个从集合中去掉某个宝物，递归调用
                # 选出所有价值中的最大值
                v = theif(tr-{t}, w-t[0]) + t[1]
                vmax = max(vmax, v)
        m[(tuple(tr), w)] = vmax
        return vmax


print(theif(tr, max_w))

递归总结

1.结束条件

2.缩小规模

3.调用自身