之前初學了一點關於動態規劃的知識，但沒有系統的學習，最近在空閒時間根據紫書（演算法競賽入門經典）開始了比較有計劃的學習，先寫下這篇部落格，作為筆記。

一、我對動態規劃的看法。
動態規劃，即是把原問題劃分為各個規模更小的問題去解決，原問題的最優解包括了各個子問題的最優解（感覺本質上是分治法）。所以動態規劃用於求解最優值，解題過程中最重要的是確定好狀態轉換方程。對於動態規劃的學習，我覺得需要知道的基礎概念不多，就是了解了動態規劃的想法，然後就是做題訓練了，從題目中學習DP才比較有效率。

二、一般的解題思路、步驟。
1、定義狀態：一個狀態遵循什麼規則需要我們自己定義，我們可以通過定義不同的規則來定義不同的狀態，但要寫出每一個狀態的轉移方程的難度不同，所以需要我們有目的的篩選，這就需要從題目訓練中學習。通過量的累積達到質的變化。
2、判斷一個狀態有幾種可能的決策：在遵循自己對狀態所定義的規則的條件下，確保對條件的列舉不存在缺漏的情況下，列舉出某一狀態下可能出現的不同決策，即各種可能的狀態轉變方向。
3、根據不同的決策列出對應的狀態轉移方程：狀態轉移方程需要確保可以得到最優的結果並且對各種可能出現的情形沒有漏舉的情況。

三、如何定義狀態
做了一些題，我發現對狀態的定義，我們都是用陣列來表示，可能是一維陣列，也可能是多維陣列。陣列的維度根據不同的題目要求而定，有時可以有多解，就是可以用不同維度的陣列來解題，但這種情況下一般多維的解題陣列可以降維到最簡。下面還是通過一些基礎、經典的例題來說明。

四、DP例題（一下兩題都是紫書的，暫時找不到具體來源）
DAG模型（DAG——有向無環圖):即是把動態規劃的題目的解題轉為有向無環圖去解題。
1、矩形巢狀
題目描述：有n個矩形，每一個矩形可以用兩個整數a、b描述表示長和寬，如矩形X(a,b)。矩形可以90°旋轉。當一個矩形的長和寬都分別嚴格小於另一個矩形的長和寬時，該矩形可以巢狀在另一個矩形之中。如(1,5)可以巢狀在(2,6)中，但不可以巢狀在(3,4)中。要求選出儘量多的矩形排成一行，使得除了最後一個之外，每一個矩形都可以巢狀在下一個矩形之內。如果有多解，矩形編號的字典序應該儘量的小。

分析：一個矩形要巢狀在另一個矩形中需要有一點的條件（前一個矩形較長的一條邊小於後一個矩形的較長的一條邊，以及前一個矩形較短的一條邊小於後一個矩形的較短的一條邊），這樣可以把前後兩個矩形看成兩個不同的節點，前一個矩形巢狀在後一個矩形裡，看成有一條從後一個矩形指向前一個矩形的有向邊。這樣就可以把問題轉換為求解有向圖的最長路且這個有向圖是無環的，即DAG。
要求最長路，我們可以定義一個狀態，如 d[i] 表示從結點 i 出發的最長路長度，這樣的話可以求出，狀態轉移方程為 d[i] = max(d[i],d[j]+1)，其中 j 是結點 i 的下一個結點，即存在一條有向邊從 i 指向 j。
為什麼狀態轉換方程是這樣呢？首先在每一個當前狀態下，我們只有一種決策可行，就是前往下一個，即使下一個點有多種選擇，但本質上都一樣，就是要前往下一個點。然後將當前狀態和下一個狀態比較，d[i]表示從結點 i 出發的最長路徑，因為存在從 i 到 j 的有向邊，所以如果從結點 j 出發的最長路徑加上從 i 到 j 之間的路徑的和得到的新的路徑比原來從結點 i 出發的最長路徑還長，那麼我們就更新從結點 i 出發的最長路徑長度，也就得出了上面的狀態轉移方程。因為每一個結點我們都和與它相連的結點相比較，所以最終得出的是最優結果。
（關於狀態的選取，我覺得還是需要多做題從題目中學習，以後自己做的時候才會有比較清晰的思路）

程式碼：

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;

const int MAXN=1e3+5;
// g[i][j]為鄰接矩陣，表示一張圖，這張圖上有從 i 到 j 的有向邊
// d[i]為狀態陣列
int g[MAXN][MAXN],d[MAXN],n;

//記錄矩形的資訊
struct Rec
{
    int x,y;
} rec[MAXN];

int DP(int i)
{
    //記憶化搜尋，如果該點已經計算過就不用再算，防止重複運算，在一些資料大的題中可能會導致超時
    if(d[i]>0) return d[i];
    for(int j=1; j<=n; j++) //遍歷i的所有可達出邊
        if(g[i][j]) //判斷是否有從 i 到 j 的有向邊
            //注意max(,)中後者不是 d[j]+1，而是DP(j)+1，因為這時候 d[j]可能還未計算，所以我們用是的DP(j)，
            //因為DP函式的作用就是要來求出 d[j] 的值的。
            d[i]=max(d[i],DP(j)+1);
    return d[i];
}
//按最小字典序輸出最優決策下的矩形編號
//選取最大的 d[i] 對應的 i ,如果有多個 i，則選擇最小的i 才能保證字典序最小 
void print(int i)
{
    cout<<i<<' ';
    for(int j=1; j<=n; ++j)
    {
        //當 i 和 j 之前存在有向邊並且在最長路徑上，j 是 i 的下一個點，則輸出 j。 
        if(g[i][j]&&d[i]==d[j]+1)
            print(j);
        break;
    }
}
//檢查是否滿足巢狀條件
int check(Rec r1,Rec r2)
{
    if((r1.x<r2.x&&r1.y<r2.y)|| (r1.x<r2.y&&r1.y<r2.x))
        return 1;
    return 0;
}

int main()
{
    int i,m,j;
    cin>>m;//例子數
    while(m--)
    {
        memset(d,0,sizeof(d));
        memset(g,0,sizeof(g));
        cin>>n;
        for(i=1; i<=n; i++)
            cin>>rec[i].x>>rec[i].y;
        // 確定哪兩個點之間有邊連線
        for(i=1; i<=n; i++)
            for(j=1; j<=n; j++)
                if(i!=j)
                    g[i][j]=check(rec[i],rec[j]);
        DP(1);
        int ans=-1,dex;
        for(i=1; i<=n; i++)
            if(ans<d[i])
            {
                ans = d[i];
                dex = i;
            }   
        //因為陣列 d[i] 求出的是從結點 i 出發的最長路，計算的是一條路徑上的邊數，所以答案需要 +1 得到總結點數 
        cout<<ans+1<<endl; 
        print(dex);
    }
}

2、硬幣問題
題目描述：有 n 種硬幣，面值分別為V1,V2,…,Vn,每種都有無限多，給定非負整數S，可以選用多少個硬幣使得面值之和恰好為S？輸出硬幣數目的最小值和最大值。1<=n<=100,0<=S<=10000,1<=Vi<=S。

分析：這型別的題其實也可以用DAG模型去解題。如我們把每種面值看作一個點，表示“還需要湊足的面值”。比如 d[i] 中 i 表示還需要湊足 i 元，而整個 d[i]陣列，我們可以表示湊足 i 需要多少硬幣。故初始狀態為 d[S]，目標狀態為d[0]。（初學時覺得很巧妙，用模型解題，思路會比較清晰）。
接下來確定狀態轉移方程。同樣的，我們要明確在每一個狀態下，下一種狀態有多少中決策。因為我們有各種面值的硬幣，所以把這些面硬幣根據輸入的順序編號，選擇面值小於我們當前所需面值的硬幣來湊足我們需要的面值。比如我們使用了第 j 個硬幣，那麼d[i] 的下一個狀態就是
d[ i - V[j] ] + 1。( +1 ，加上使用的面值為 V[j] 硬幣)，由於題目要求最大和最小數目，所以我們把當前狀態與下一個狀態比較，分別取最大值和最小值即可。因此，求最大值狀態轉移方程為：d[i] = max(d[i],d[i-V[j]]+1)，最小值為：d[i] = min(d[i],d[i-V[j]]+1)。

下面給出求最大值，以及同時求最大和最小值的核心程式碼

//最長路
int dp_max(int s)// 第一個 s 是題目中的 S。 
{
    //記憶化搜尋已經計算過的點不用重複計算
    if(vis[s])
        return d[s];
    //標記該結點已經訪問過 
    vis[s] = 1;
    //因為題目中 S 可以為 0,所以初始將 d[i]設定為正常情況下取不到的負數。 
    d[s]=-1000;
    for(int i=1; i<=n; ++i)
        // 如果硬幣面值小於目前還需要湊足的面值才進行下一步狀態轉換 
        if(s>=v[i])
            d[s] = max(d[s],dp_max(s-v[i])+1);
    return d[s];
}

//同時求最大最小值 
void max_min()
{
    // 先把陣列初始化為不能取到的值，min 和 max 函式才有效
    memset(minv,INF,sizeof(minv));
    memset(maxv,-INF,sizeof(maxv));
    //如果需要湊足的面值為 0，那麼當然不需要任何硬幣 
    maxv[0] = minv[0] = 0; 
    //依次計算每一種面值需要的硬幣數 
    for(int i=1; i<=s; ++i)
        for(int j=1; j<=n; ++j)
            if(i>=v[j])
            {
                // 當前狀態 與 如果選擇了當前的硬幣 v[j] 後的狀態比較
                // 因為對任意錢數，都是由已有的硬幣湊成
                // 對任意錢數都選擇最少或最多的組成，再往上湊即也是最少或最多
                maxv[i]=max(maxv[i],maxv[i-v[j]]+1);
                minv[i]=min(minv[i],minv[i-v[j]]+1);
            }
    cout<<maxv[s]<<endl<<minv[s]<<endl;
    //也可以在計算最大值最小值的同時記錄下每種最優決策對應取的硬幣編號
    /*if(maxv[i]<maxv[i-v[j]]+1)
    {
        maxv[i]=maxv[i-v[j]]+1;
        max_coin[i]=j;
    }
    if(minv[i]>minv[i-v[j]]+1)
    {
        minv[i]=minv[i-v[j]]+1;
        min_coin[i]=j;
    }*/
}

小結：
個人感覺學習動態規劃，涉及的知識挺多的，最好是一次學習一種題型，然後自己做好歸納。比如這類題型的狀態一般怎麼定義，可以用什麼模型去做等。比如上面的兩道例題都是跟DAG最長最短路有關，對於這種題型，一般可以定義兩種狀態：
(1)設d[i]為從 i 出發的最長路，則d[i]=max{d[j]+1,d[i]}((i,j)∈E)。
(2)設d[i]為以 i 結束的最短路，則d[i]=max{d[j]+1,d[i]}((j,i)∈E)。
然後就是刷題，題做多了，我感覺對動態規劃的理解會自然而然的深。