原文：

常用的算法設計思想主要有動態規劃、貪婪法、隨機化算法、回溯法等等，這些思想有重疊的部分，當面對一個問題的時候，從這幾個思路入手往往都能得到一個還不錯的答案。

本來想把動態規劃單獨拿出來寫三篇文章呢，后來發現自己學疏才淺，實在是只能講一些皮毛，更深入的東西嘗試構思了幾次，也沒有什么進展，打算每種設計思想就寫一篇吧。

動態規劃（Dynamic Programming）是一種非常有用的用來解決復雜問題的算法，它通過把復雜問題分解為簡單的子問題的方式來獲得最優解。

一、自頂向下和自底向上

總體上來說，我們可以把動態規劃的解法分為自頂向下和自底向上兩種方式。
一個問題如果可以使用動態規劃來解決，那么它必須具有“最優子結構”，簡單來說就是，如果該問題可以被分解為多個子問題，并且這些子問題有最優解，那這個問題才可以使用動態規劃。

• 自頂向下（Top-Down）

自頂向下的方式其實就是使用遞歸來求解子問題，最終解只需要調用遞歸式，子問題逐步往下層遞歸的求解。我們可以使用緩存把每次求解出來的子問題緩存起來，下次調用的時候就不必再遞歸計算了。
舉例著名的斐波那契數列的計算：

#!/usr/bin/env python
# coding:utf-8
def fib(number):
    if number == 0 or number == 1:
        return 1
    else:
        return fib(number - 1) + fib(number - 2)
if __name__ == '__main__':
    print fib(35)

有一點開發經驗的人就能看出，fib(number-1)和fib(number-2)會導致我們產生大量的重復計算，以上程序執行了14s才出結果，現在，我們把每次計算出來的結果保存下來，下一次需要計算的時候直接取緩存，看看結果：

#!/usr/bin/env python
# coding:utf-8
cache = {}
def fib(number):
    if number in cache:
        return cache[number]
    if number == 0 or number == 1:
        return 1
    else:
        cache[number] = fib(number - 1) + fib(number - 2)
        return cache[number]
if __name__ == '__main__':
    print fib(35)

耗費時間為 0m0.053s 效果提升非常明顯。

• 自底向上（Bottom-Up）
  自底向上是另一種求解動態規劃問題的方法，它不使用遞歸式，而是直接使用循環來計算所有可能的結果，往上層逐漸累加子問題的解。
  我們在求解子問題的最優解的同時，也相當于是在求解整個問題的最優解。其中最難的部分是找到求解最終問題的遞歸關系式，或者說狀態轉移方程。

這里舉一個01背包問題的例子：
你現在想買一大堆算法書，需要很多錢，所以你打算去搶一個商店，這個商店一共有n個商品。問題在于，你只能最多拿 W kg 的東西。Wi和Vi
分別表示第i個商品的重量和價值。我們的目標就是在能拿的下的情況下，獲得最大價值，求解哪些物品可以放進背包。對于每一個商品你有兩個選擇：拿或者不拿。
首先我們要做的就是要找到“子問題”是什么，我們發現，每次背包新裝進一個物品，就可以把剩余的承重能力作為一個新的背包來求解，一直遞推到承重為0的背包問題：
作為一個聰明的賊，你用 m[i,w]
表示偷到商品的總價值，其中i表示一共多少個商品，w表示總重量，所以求解m[i,w]就是我們的子問題，那么你看到某一個商品i的時候，如何決定是不是要裝進背包，有以下幾點考慮：
該物品的重量大于背包的總重量，不考慮，換下一個商品；
該商品的重量小于背包的總重量，那么我們嘗試把它裝進去，如果裝不下就把其他東西換出來，看看裝進去后的總價值是不是更高了，否則還是按照之前的裝法；
極端情況，所有的物品都裝不下或者背包的承重能力為0，那么總價值都是0；

由以上的分析，我們可以得出m[i,w]
的狀態轉移方程為：

有了狀態轉移方程，那么寫起代碼來就非常簡單了，首先看一下自頂向下的遞歸方式，比較容易理解：

#!/usr/bin/env python
# coding:utf-8
cache = {}
items = range(0,9)
weights = [10,1,5,9,10,7,3,12,5]
values = [10,20,30,15,40,6,9,12,18]
# 最大承重能力
W = 4
def m(i,w):
    if str(i)+','+str(w) in cache:
        return cache[str(i)+','+str(w)]
    result = 0
    # 特殊情況
    if i == 0 or w == 0:
        return 0
    # w < w[i]
    if w < weights[i]:
        result = m(i-1,w)
    # w >= w[i]
    if w >= weights[i]:
        # 把第i個物品放入背包后的總價值
        take_it = m(i-1,w - weights[i]) + values[i]
        # 不把第i個物品放入背包的總價值
        ignore_it = m(i-1,w)
        # 哪個策略總價值高用哪個
        result = max(take_it,ignore_it)
        if take_it > ignore_it:
            print 'take ',i
        else:
            print 'did not take',i
    cache[str(i)+','+str(w)] = result
    return result
if __name__ == '__main__':
    # 背包把所有東西都能裝進去做假設開始
    print m(len(items)-1,W)

改造成非遞歸，即循環的方式，從底向上求解：

#!/usr/bin/env python
# coding:utf-8
cache = {}
items = range(1,9)
weights = [10,1,5,9,10,7,3,12,5]
values = [10,20,30,15,40,6,9,12,18]
# 最大承重能力
W = 4
def knapsack():
    for w in range(W+1):
        cache[get_key(0,w)] = 0
    for i in items:
        cache[get_key(i,0)] = 0
        for w in range(W+1):
            if w >= weights[i]:
                if cache[get_key(i-1,w-weights[i])] + values[i] > cache[get_key(i-1,w)]:
                    cache[get_key(i,w)] = values[i] + cache[get_key(i-1,w-weights[i])]
                else:
                    cache[get_key(i,w)] = cache[get_key(i-1,w)]
            else:
                cache[get_key(i,w)] = cache[get_key(i-1,w)]
    return cache[get_key(8,W)]
def get_key(i,w):
    return str(i)+','+str(w)
if __name__ == '__main__':
    # 背包把所有東西都能裝進去做假設開始
    print knapsack()

從這里可以看出，其實很多動態規劃問題都可以使用循環替代遞歸求解，他們的區別在于，循環方式會窮舉出所有可能用到的數據，而遞歸只需要計算那些對最終解有幫助的子問題的解，但是遞歸本身是很耗費性能的，所以具體實踐中怎么用要看具體問題具體分析。

• 最長公共子序列（LCS）
  解決了01背包問題之后，我們對“子問題”和“狀態轉移方程”有了一點點理解，現在趁熱打鐵，來試試解決LCS問題：
  字符串一“ABCDABCD”和字符串二”BDCFG”的公共子序列（不是公共子串，不需要連續）是BDC，現在給出兩個確定長度的字符串X和Y，求他們的最大公共子序列的長度。
  首先，我們還是找最優子結構，即把問題分解為子問題，X和Y的最大公共子序列可以分解為X的子串Xi和Y的子串Yj的最大公共子序列問題。
  其次，我們需要考慮Xi和Yj的最大公共子序列C[i,j]需要符合什么條件：

• 如果兩個串的長度都為0，則公共子序列的長度也為0；

• 如果兩個串的長度都大于0且最后面一位的字符相同，則公共子序列的長度是C[i?1,j?1]的長度加一；

• 如果兩個子串的長度都大于0，且最后面一位的字符不同，則最大公共子序列的長度是C[i?1,j]和C[i,j?1]的最大值；

最后，根據條件獲得狀態轉移函數：

由此轉移函數，很容易寫出遞歸代碼：

#!/usr/bin/env python
# coding:utf-8
cache = {}
# 為了下面表示方便更容易理解，數組從1開始編號
# 即當i,j為0的時候，公共子序列為0，屬于極端情況
A = [0,'A','B','C','B','D','A','B','E','F']
B = [0,'B','D','C','A','B','A','F']
def C(i,j):
    if get_key(i,j) in cache:
        return cache[get_key(i,j)]
    result = 0
    if i > 0 and j > 0:
        if A[i] == B[j]:
            result = C(i-1,j-1)+1
        else:
            result = max(C(i,j-1),C(i-1,j))
    cache[get_key(i,j)] = result
    return result
def get_key(i,j):
    return str(i)+','+str(j)
if __name__ == '__main__':
    print C(len(A)-1,len(B)-1)

上面程序的輸出結果為5，我們也可以像背包問題一樣，把上面代碼改造成自底向上的求解方式，這里就省略了。
但是實際應用中，我們可能更需要求最大公共子序列的序列，而不只是序列的長度，所以我們下面額外考慮一下如何輸出這個結果。
其實輸出LCS字符串也是使用動態規劃的方法，我們假設LCS[i,j]表示長度為i的字符串和長度為j的字符串的最大公共子序列，那么我們有以下狀態轉移函數：

其中C[i,j]是我們之前求得的最大子序列長度的緩存，根據上面的狀態轉移函數寫出遞歸代碼并不麻煩：

#!/usr/bin/python
# coding:utf-8
"""Dynamic Programming"""
CACHE = {}
# 為了下面表示方便，數組從1開始編號
# 即當i,j為0的時候，公共子序列為0，屬于極端情況
A = [0, 'A', 'B', 'C', 'B', 'D', 'A', 'B', 'E', 'F']
B = [0, 'B', 'D', 'C', 'A', 'B', 'A', 'F']
def lcs_length(i, j):
    """Calculate max sequence length"""
    if get_key(i, j) in CACHE:
        return CACHE[get_key(i, j)]
    result = 0
    if i > 0 and j > 0:
        if A[i] == B[j]:
            result = lcs_length(i-1, j-1)+1
        else:
            result = max(lcs_length(i, j-1), lcs_length(i-1, j))
    CACHE[get_key(i, j)] = result
    return result
def lcs(i, j):
    """backtrack lcs"""
    if i == 0 or j == 0 :
        return ""
    if A[i] == B[j]:
        return lcs(i-1, j-1) + A[i]
    else:
        if CACHE[get_key(i-1, j)] > CACHE[get_key(i, j-1)]:
            return lcs(i-1, j)
        else:
            return lcs(i, j-1)
def get_key(i, j):
    """build cache keys"""
    return str(i) + ',' + str(j)
if __name__ == '__main__':
    print lcs_length(len(A)-1, len(B)-1)
    print lcs(len(A)-1, len(B)-1)

本小節就暫時到這里了，其實我們很容易能體會到，動態規劃的核心就是找到那個狀態轉移方程，所以遇到問題的時候，首先想一想其有沒有最優子結構，很可能幫助我們省下大把的思考時間。