一、動態規劃的概念
動態規劃（Dynamic Programming）是通過組合子問題的解而解決整個問題的。分治算法是指將問題劃分成一些獨立的子問題，遞歸地求解各子問題，然後合併子問題的解而得到原始問題的解，與此不同，動態規劃適用於子問題不是獨立的情況，也就是各個子問題包含公共的子問題。在這種情況下，採用分治法會做許多不必要的工作，即重複地求解公共地子問題。動態規劃算法對每個子問題只求解一次，將其結果保存在一張表中，從而避免每次遇到各個子問題時重新計算答案。
動態規劃通常應用於最優化問題。此類問題可能有很多種可行解。每個解有一個值，而我們希望找出具有最優（最大或最小）值的解。稱這樣的解爲該問題的“一個”最優解，而不是“確定的”最優解，因爲可能存在多個取最優值的解。
爲了節約重複求相同子問題的時間，引入一個數組，不管他們是否對最終解有用，把所有子問題的解存於該數組中，這就是動態規劃所採用的基本方法。
二、動態規劃求解的一般步驟
動態規劃算法的設計可以分爲如下4個步驟：
1> 描述最優解的結構。
2> 遞歸定義最優解的值。
3> 按自底向上的方式計算最優解的值。
4> 由計算出的結果構造一個最優解。
這就是動態規劃算法的一般步驟，單這麼說肯定沒有任何意義，下面我們會通過求解最長公共子序列問題來說明，如何一步步的適用動態規劃思想分析問題。
三、最長公共子序列問題描述
問題描述：字符序列的子序列是指從給定字符序列中隨意地（不一定連續）去掉若干個字符（可能一個也不去掉）後所形成的字符序列。令給定的字符序列 X = "x0, x1, ... xm-1"，字符序列 Y = "y0, y1, ... , yk-1"是X的子序列，則存在X的一個嚴格遞增（注意：不是連續遞增）下標序列<i0, i1, ... , ik-1>，使得對所有的j=1=0, 1, ... , k-1，有xj = yj。例如，X="ABCBDAB", Y="BCDB"是X的一個子序列。
先給出問題：假設字符串X = “ABCBDAB”， Y=“BDCABA”，求他們的最長公共子序列。
四、動態規劃求解最長公共子序列問題
1> 描述最優解的結構。
解決上述問題的一種強力方法是枚舉出X的所有子序列，然後逐一檢查看其是否爲Y的子序列，並隨時記錄所發現的最長子序列。X的每個子序列對應於X的下標集{1，2，... ，m}的一個子集。X共有2^m個子序列，因此這種方法需要指數時間，這對長序列來說是不實際的。
設 X = <x1, x2, ... , xm> 和 Y = <y1, y2, ... , yn>爲兩個序列，並設Z = <z1, z2, ... , zk>爲X和Y的任意一個最長公共子序列。則我們可以得出以下的結論：
1) 如果Xm = Yn，那麼zk = Xm = Yn，而且zk-1是Xm-1和Yn-1的一個最長公共子序列。
2) 如果Xm != Yn，那麼zk != Xm蘊含Z是Xm-1和Yn的一個最長公共子序列。
3) 如果Xm != Yn，那麼zk != Yn蘊含Z是Xm和Yn-1的一個最長公共子序列。
這樣，在找X和Y的最長公共子序列時，如果有Xm-1 = Yn-1，則進一步解決一個子問題，找"x0, x1, ... , xm-2" 和 "y0, y1, ... , yn-2"的一個最長公共子序列；如果Xm-1 != Yn-1，則需要解決兩個子問題，找出"x0, x1, ... , xm-2" 和 "y0, y1, ... , yn-1"的一個最長公共子序列和找出 "x0, x1, ... , xm-1" 和 “y0, y1, ... , yn-2”的一個最長公共子序列，再去兩者中較長者作爲X和Y的最長公共子序列。
2> 遞歸定義最優解的值
最長公共子序列問題的遞歸解涉及到建立一個最優解的遞歸式。定義c[i, j]的序列爲Xi 和 Yj的一個最長公共子序列的長度。如果i = 0 或 j = 0，其中一個的序列長度爲0，因此最長公共子序列的長度爲0。由最長公共子序列問題的最優子結構可得遞歸式
3> 按自底向上的方式計算最優解的值
引入一個二維數組，C[i][j]，用C[i][j]記錄X[i]與Y[j]的最長公共子序列的長度，B[i][j]記錄C[i][j]是通過那一個子問題的值求得的，以決定搜索我們是自底向上進行遞推計算，那麼在計算c[i,j]之前，c[i-1][j-1]，c[i-1][j]與c[i][j-1]均已計算出來。此時我們根據X[i] = Y[j]還是X[i] != Y[j]，就可以計算出c[i][j]。
for (int i = 1; i <= nXlen; i++)
{
for (int j = 1; j <= nYlen; j++)
{
if (strX[i] == strY[j])
{
C[i][j] = C[i-1][j-1] + 1;
B[i][j] = 0;
}
else
{
//! 注意這裏的=號，它表示了，如果C[i-1][j] == C[i][j-1]的時候，它既可以向左走又可以向上走
//! 而此時選擇了向左走，按照此種方式輸出最長公共子序列的時候，只能輸出一條，需改進！！
<span style="color:#FF0000;">if (C[i-1][j] >= C[i][j-1])</span>
{
C[i][j] = C[i-1][j];
B[i][j] = 1; //! 左移
}
else
{
C[i][j] = C[i][j-1];
B[i][j] = -1; //! 右移
}
}
}
} 
void PrintAllCase(int B[][MAX_LEN], const string &strX, int i, int j)
{
if (i == 0 || j == 0)
{
return ;
}
if (B[i][j] == 0)
{
PrintAllCase(B, strX, i-1, j-1);
cout << strX[i-1];
}
else if (B[i][j] == 1)
{
PrintAllCase(B, strX, i-1, j);
}
else
{
PrintAllCase(B, strX, i, j-1);
}
}五、C++實現代碼
/************************************************************************/
/* 動態規劃求解最長公共子序列 */
/************************************************************************/
#include <stdlib.h>
#include <iostream>
#include <string>
using namespace std;
#define MAX_LEN 100
void LCS(const string &strX, const string &strY, int nXlen, int nYlen, int C[][MAX_LEN], int B[][MAX_LEN])
{
for (int i = 0; i <= nXlen; i++)
{
C[i][0] = 0;
}
for (int j = 0 ; j <= nYlen; j++)
{
C[0][j] = 0;
}
for (int i = 1; i <= nXlen; i++)
{
for (int j = 1; j <= nYlen; j++)
{
if (strX[i] == strY[j])
{
C[i][j] = C[i-1][j-1] + 1;
B[i][j] = 0;
}
else
{
//! 注意這裏的=號，它表示了，如果C[i-1][j] == C[i][j-1]的時候，它既可以向左走又可以向上走
//! 而此時選擇了向左走，按照此種方式輸出最長公共子序列的時候，只能輸出一條，需改進！！
if (C[i-1][j] >= C[i][j-1])
{
C[i][j] = C[i-1][j];
B[i][j] = 1; //! 左移
}
else
{
C[i][j] = C[i][j-1];
B[i][j] = -1; //! 右移
}
}
}
}
}
void PrintAllCase(int B[][MAX_LEN], const string &strX, int i, int j)
{
if (i == 0 || j == 0)
{
return ;
}
if (B[i][j] == 0)
{
PrintAllCase(B, strX, i-1, j-1);
cout << strX[i-1];
}
else if (B[i][j] == 1)
{
PrintAllCase(B, strX, i-1, j);
}
else
{
PrintAllCase(B, strX, i, j-1);
}
}
int main()
{
string strX = "ABCBDAB";
string strY = "BDCABA";
int C[MAX_LEN][MAX_LEN]; //! 記錄最長公共子序列的長度
int B[MAX_LEN][MAX_LEN]; //! 記錄最長公共子序列的移動線路
int nXlen = strX.length();
int nYlen = strY.length();
LCS(strX, strY, nXlen, nYlen, C, B);
cout << "The max length of LCS is " << C[nXlen][nYlen] << endl;
cout << "The LCS are : ";
PrintAllCase(B, strX, nXlen, nYlen);
system("PAUSE");
return 0;
}當前算法實現在輸出最長公共子序列的時候只能輸出一條，如果需要輸出所有的則需要改進。
六、補充：最長公共子串
注意區別：最長公共子序列（不連續）
最長公共子串（連續）
其最主要的區別就是遞歸式上的不同。
/************************************************************************/
/*
<span style="color:#FF0000;"> 注意：該題是傳統LCS最長公共子序列的變種問題，其解題思路是一樣的。
注意區分
最長公共子序列（不連續）
最長公共子串（連續）
對應的遞歸式：
最長公共子序列：
c[i][j] =
0 i == 0 or y == 0
c[i-1][j-1] + 1 strA[i] = strB[j]
max{c[i][j-1], c[i-1][j]} strA[i] != strB[j]
最長公共子串
c[i][j] =
0 i == 0 or y == 0 or strA[i] != strB[j]
c[i-1][j-1] + 1 strA[i] = strB[j]
遞歸式的主要區別：
1. 當strA[i] != strB[j]時，最長公共子序列是在c[i][j-1]和c[i-1][j]中取較大者；
而最長公共子串則是0，因爲當這個位置的不相等時必須重新開始計數，因爲必須連續。
2. 獲取最長公共子序列或最長公共子串的長度是，最長公共子序列一定是在Matrix的最大位置處；
而最長公共子串則是在Matrix二維數組中的最大值纔是。
3. 在寫代碼上只是在LCS遞歸式上的處理不同，其他均相同。</span>
*/
/************************************************************************/
#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;
#define MAX_LEN 100
void LCS2(const string &strA, const string &strB, int nLenA, int nLenB, int myMatrix[][MAX_LEN], int &nMaxLen)
{
for (int i = 0 ; i <= nLenA; i++)
{
myMatrix[0][i] = 0;
}
for (int j = 0; j <= nLenB; j++)
{
myMatrix[j][0] = 0;
}
int nMaxTmp = 0 ;
for (int i = 1; i <= nLenA; i++)
{
for (int j = 1; j <= nLenB; j++)
{
if (strA[i] == strB[j])
{
myMatrix[i][j] = myMatrix[i-1][j-1] + 1;
if (myMatrix[i][j] > nMaxTmp)
{
nMaxTmp = myMatrix[i][j];
}
}
else
{
myMatrix[i][j] = 0;
}
}
}
nMaxLen = nMaxTmp;
}
int main()
{
string strA = "GCCCTAGCCAGDE";
string strB = "GCGCCAGTGDE";
int nLenA = strA.length();
int nLenB = strB.length();
int CostMatrix[MAX_LEN][MAX_LEN] = {0};
int nMaxLen = 0;
LCS2(strA, strB, nLenA, nLenB, CostMatrix, nMaxLen);
//! 此時最大長度就不是CostMatrix矩陣的最後位置了，而是CostMatrix中的最大值。
cout << "The max length is : " << nMaxLen << endl;
system("PAUSE");
return 0;
}