动态规划算法

一 从斐波那契数列看动态规划

斐波那契数列：
　　Fn= Fn−1 + Fn−2
使⽤递归和⾮递归的⽅法来求解斐波那契数列的第n项

1 递归实现

# 子问题的重复计算
def fibnacci(n):
    if n == 1 or n == 2:
        return 1
    else:
        return fibnacci(n - 1) + fibnacci(n - 2)

2 非递归实现

# 动态规划（DP）的思想 = 递推式
def fibnacci_no_recurision(n):
    f = [0, 1, 1]
    if n > 2:
        for i in range(n - 2):
            num = f[-1] + f[-2]
            f.append(num)
    return f[-1]

print(fibnacci_no_recurision(100))

二  钢条切割问题

某公司出售钢条，出售价格与钢条⻓度之间的关系如下表：

问题：现有⼀段⻓度为n的钢条和上⾯的价格表，求切割钢条⽅案，使得总收益最⼤

⻓度为4的钢条的所有切割⽅案如下：（c⽅案最优）

⻓度为n的钢条的不同切割⽅案有⼏种？

 

设⻓度为n的钢条切割后最优收益值为r可以得出递推式：

• rn = max(pn, r1 + rn!1, r2 + rn!2,··· , rn!1 + r1)

第⼀个参数pn表示不切割

其他n-1个参数分别表示另外n-1种不同切割⽅案，对⽅案i=1,2,...,n-1

• 将钢条切割为⻓度为i和n-i两段
• ⽅案i的收益为切割两段的最优收益之和

考察所有的i选择其中收益最⼤的⽅案

三 钢条切割问题之最优子结构

可以将求解规模为n的原问题，划分为规模更⼩的⼦问题：完成⼀次切割后，可以将产⽣的两段钢条看成两个独⽴的钢条切个问题。 
组合两个⼦问题的最优解，并在所有可能的两段切割⽅案中选取组合收益最⼤的，构成原问题的最优解。 
钢条切割满⾜最优⼦结构：问题的最优解由相关⼦问题的最优解组合⽽成，这些⼦问题可以独⽴求解

钢条切割问题还存在更简单的递归求解⽅法

从钢条的左边切割下⻓度为i的⼀段，只对右边剩下的⼀段继续进⾏切割，左边的不再切割

递推式简化为 ：

　　

不做切割的⽅案就可以描述为：左边⼀段⻓度为n，收益为pn，剩余⼀段⻓度为0，收益为r0=0。

(1) 自顶向下递归实现

时间复杂度 O(2n)实现效果差

递归算法由于重复求解相同⼦问题，效率极低

动态规划的思想：

• 每个⼦问题只求解⼀次，保存求解结果
• 之后需要此问题时，只需查找保存的结果

p = [0, 1, 5, 8, 9, 10, 17, 17, 20, 21, 23, 24, 26, 27, 27, 28, 30, 33, 36, 39, 40]

def cut_rod_recurision(p, n):
    if n == 0:
        return 0
    else:
        res = p[n]
        for i in range(1, n):
            res = max(res, cut_rod_recurision(p, i) + cut_rod_recurision(p, n - i))
    return res


print(cut_rod_recurision(p, 20))


def cut_rod_recurision(p, n):
    if n == 0:
        return 0
    else:
        res = 0
        for i in range(1, n + 1):
            res = max(res, p[i] + cut_rod_recurision(p, n - i))
        return res


print(cut_rod_recurision(p, 20))

 (2) 自底向上递归实现

时间复杂度：O(n2 )

p = [0, 1, 5, 8, 9, 10, 17, 17, 20, 21, 23, 24, 26, 27, 27, 28, 30, 33, 36, 39, 40]

def cut_rop_dp(p, n):
    r = [0]
    for i in range(1, n + 1):
        res = 0
        for j in range(1, i + 1):
            res = max(res, p[j] + r[i - j])
        r.append(res)
    return r[n]


print(cut_rop_dp(p, 20))

(3) 钢条切割重构解

如何修改动态规划算法，使其不仅输出最优解，还输出最优切割⽅案？
对每个⼦问题，保存切割⼀次时左边切下的⻓度

四 最⻓公共子序列

个序列的⼦序列是在该序列中删去若⼲元素后得 到的序列。
例：“ABCD”和“BDF”都是“ABCDEFG”的⼦序列

最⻓公共⼦序列（LCS）问题：给定两个序列X和Y，求X和Y⻓度最⼤的公共⼦序列。
例：X="ABBCBDE" Y="DBBCDB" LCS(X,Y)="BBCD"

应⽤场景：字符串相似度⽐对

 最优解的递推式：

c[i,j]表示Xi和Yj的LCS⻓度

　　

 例如：要求a="ABCBDAB"与b="BDCABA"的LCS：

由于最后⼀位"B"≠"A"：因此LCS(a,b)应该来源于LCS(a[:-1],b)与LCS(a,b[:-1])中更⼤的那⼀个

计算公共最长子序列长度实现代码：

def lcs_length(x, y):
    m = len(x)
    n = len(y)
    c = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if x[i - 1] == y[j - 1]:  # i j位置上的字符匹配的时候， 来自于左上方+1
                c[i][j] = c[i - 1][j - 1] + 1
            else:
                c[i][j] = max(c[i - 1][j], c[i][j - 1])
    return c[m][n]

print(lcs_length("ABCDBAB", "BDCABA"))

实现输出最⻓公共⼦序列的值

def lcs(x, y):
    '''
    记录最长公共子序列路径
    :param x:
    :param y:
    :return:
    '''
    m = len(x)
    n = len(y)
    c = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
    b = [[0 for _ in range(n + 1)] for _ in range(m + 1)]  # 1 左上方 2 上方 3 左方
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if x[i - 1] == y[j - 1]:  # i j位置上的字符匹配的时候， 来自于左上方+1
                c[i][j] = c[i - 1][j - 1] + 1
                b[i][j] = 1
            elif c[i - 1][j] > c[i][j - 1]:  # 来自于上方
                c[i][j] = c[i - 1][j]
                b[i][j] = 2
            else:
                c[i][j] = c[i][j - 1]
                b[i][j] = 3
    return c[m][n], b


def lcs_traceback(x, y):
    c, b = lcs(x, y)
    i = len(x)
    j = len(y)
    res = []

    while i > 0 and j > 0:
        if b[i][j] == 1:  # 来自左上方=>匹配
            res.append(x[i - 1])
            i -= 1
            j -= 1
        elif b[i][j] == 2:  # 来自上方=>不匹配
            i -= 1
        else:  # == 来自左方=>不匹配
            j -= 1
    return "".join(reversed(res))


# 输出公共最长子序列
print(lcs_traceback("ABCBDAB", "BDCABA"))

五 动态规划

什么问题可以使⽤动态规划⽅法？

最优⼦结构

• 原问题的最优解中涉及多少个⼦问题
• 在确定最优解使⽤哪些⼦问题时，需要考虑多少种选择

重叠⼦问题