学习数据结构笔记--动态规划概念、切割钢条问题

原创已于 2022-03-16 16:19:22 修改 · 391 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#学习 #动态规划 #数据结构

于 2022-03-16 16:17:51 首次发布

这篇博客深入探讨了动态规划的概念，通过实例展示了如何避免递归过程中重复计算的问题。文章首先从递归角度出发，解释了自顶向下的方法，然后转向自底向上的解决方案，通过代码实现动态规划的剪枝 rod 切割问题。作者还介绍了如何重构解法以提高效率，强调了动态规划的最优子结构和重叠子问题的特点。

这是学习动态规划的笔记。

动态规划概念是当你需要计算一个具有多个子类问题的问题的时候，避免重复运算，可以采用动态规划的方式进行分析。

先从自顶向下切割，也就是从递归出发，一直递归到最底部。

# p是关于价格的一个关系式。
p = [0,1,5,8,9,10,17,17,20,24]

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

这个递归会计算大量的重复算式，十分复杂，所以可以用一个连加符号进行表示。

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

还有一种是自底向上的方法

def cut_rod_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]
#

思路，去搜素1的时候需要0，然后2的时候需要1和 0 直接找就可以啦，不用再去算。

重构解

前面我们知道，动态规划如果每次都需要对子问题进行运算会消耗大量时间做重复的计算，如果可以用一个空间存储后面每次计算都只要调用即可。

记录左边不用切割的最大长度。

def cut_rod_extend(p, n):
    r = [0]
    s = [0]
    for i in range(1, n+1):
        res_r= 0  # 价格最大值
        res_s = 0  #　价格最大值对应方案最左边不切割的长度
        for j in range(1, i+1):
            if p[j] + r[i - j] > res_r:
                res_r = p[j] + r[i - j] # 计算的是r = pn + max（rn-i）
                res_s = j
        r.append(res_r)
        s.append(res_s)
    return r[n],s

def cut_rod_solution(p, n): # 这里是计算每个最左边需要切割的段数
    r, s = cut_rod_extend(p, n)
    ans = [] # 用一个列表存储这些信息
    while n > 0:
        ans.append(s[n])  # 前情提要，s是计算出来的列表，包括前面的数字至少需要怎么切
        n -= s[n] 
    return ans

r,s = cut_rod_extend(p,10)
print(s)
print(cut_rod_solution(p,10))

动态规划需要最优子结构：原问题的最优解中涉及多个子问题

在确定最优解使用哪些子问题。

重叠子问题