。
   動態規劃（dynamic programming）與分治演算法相似，都是通過組合子問題的解來求解原問題(在這裡，“programming”指的是一種表格法，並非編寫計算機程式)。
一、與分治演算法區別：
   1.子問題是否重疊性
   ①分治演算法將問題劃分為互不相交的子問題，遞迴地求解子問題，再將它們的解組合起來，求出原問題的解。
   ②動態規劃應用於子問題重疊的情況，即不同子問題具有公共的子子問題（子問題的求解釋遞迴進行的，將其劃分為更小的子子問題）
   2.子問題是否重複求解

   ①分治演算法會反覆求解那些公共子問題。
   ②動態規劃對每個子子問題只求解一次，將其解儲存在一個表格中。(空間換時間)
二、動態規劃的求解步驟
   1.刻畫一個最優解的結構特徵。
   2.遞迴地定義最優解的值。
   3.計算最優解的值，通常採用自底向上的方法。
   4.利用計算出的資訊構造一個最優解。
   步驟1~3是動態規劃演算法求解問題的基礎，如果我們僅僅需要一個最優解的值，而非解本身，可以忽略步驟4。如果確實要做步驟4，有時就需要在執行步驟3的過程中維護一些額外資訊，以便用來構造一個最優解。
三、鋼條切割
   第一個應用動態規劃的例子是求解一個如何切割鋼條的簡單問題。
   Serling公司購買長鋼條，將其切割為短鋼條出售，切割工序本身沒有成本支出。公司管理層希望知道最佳的切割方案。假定我們知道Serling公司出售一段長度為i英寸的鋼條的價格為pi(i=1,2,..,單位為美元)。鋼條的長度均為整英寸，下圖給出一個價格表的樣例。
   

   鋼條切割問題時這樣的：給定一段長度為n英寸的鋼條和一個價格表pi(i=1,2,...,n),求切割鋼條方案，使得銷量收益rn最大,注意，如果長度為n英寸的鋼條的價格pn足夠大，最優解可能就是完全不需要切割。
   考慮n=4的情況，可以知道切割為p2+p2=5+5=10的收益（其中長度為n英寸的鋼條共有2^（n-1）種不同的切割方案，當然我們可以按照長度非遞減的順序切割小段鋼條，切割方案會少得多），為最優解。
   對於上述價格表樣例，我們可以觀察所有最優收益值ri(i=1,2,..,10)及對應的最優切割方案：
   r1=1，切割方案1=1（無切割）
   r2=5，切割方案2=2（無切割）
   r3=8，切割方案3=3（無切割）
   r4=10，切割方案4=2+2
   r5=13，切割方案5=2+3
   r6=17，切割方案6=6（無切割）
   r7=18，切割方案7=1+6或7=2+2+3=4+3
   r8=22，切割方案8=2+6
   r9=25，切割方案9=3+6
   r10=30，切割方案10=10（無切割）

   更一般地，對於rn(n>=1)，我們可以用更短的鋼條的最優切割收益來描述它：
          rn=max（pn,r(1)+r(n-1),r(2)+r(n-2),...,r(n-1)+r(1)） （這裡可以優化一下，例如7=1+6和7=6+1其實是一樣的，故到r(n/2)+r(n-n/2)時即可）
   其中第一個引數pn對應不切割，直接出售長度為n英寸的鋼條方案。其他n-1個引數對應另外n-1種方案；對應每個i=1,2,...,n-1,首先將鋼條切割為長度為i和n-i的兩段，接著求解這兩段的最優切割收益ri和r(n-i)（每種方案的最優收益為兩段的最優收益之和）。
   由於無法預知哪種方案會獲得最優收益，我們必須考察所有可能的i，選取其中收益最大者。
   注意到，為了求解規模為n的原問題，我們先求解形式完全一樣，但規模更小的子問題。即當完成首次切割後，我們將兩段鋼條看成兩個獨立的鋼條切割問題例項。我們通過組合兩個相關子問題的最優解，並在所有可能的兩段切割方案中選取組合收益最大者，構成原問題的最優解。我們稱鋼條切割問題滿足最優子結構(optimal substructure)性質：問題的最優解由相關子問題的最優解組合而成，而這些子問題可以獨立求解。
遞迴方法求解最優鋼條切割問題
   除了上述求解，鋼條切割問題還存在一種相似的但更為簡單的遞迴求解：我們將鋼條從左邊切割下長度為i的一段，只對右邊剩下的長度為n-i的一段繼續進行切割（遞迴求解），對左邊的一段不再進行切割。
   即問題分解的方式為：將長度為n的鋼條分解為左邊開始一段，以及剩下部分繼續分解的結果。這樣不做任何切割方案就可以描述為：第一段的長度為n，收益為pn,剩餘部分長度為0，對應的收益為r0=0。於是我們可以得到上述公式的簡化版本：
          rn=max（pi+r(n-i)） (1<=i<=n)
   在此公式中，原問題的最優解只包含一個相關子問題（右端剩餘部分）的解，而不是兩個。
自頂向下遞迴實現

   下面的過程實現了公式的計算，它採用的是一種直接的自頂向下的遞迴方法。(原文是虛擬碼，這裡是C++語言的實現)

   int CUT_ROD(int *p,int n) /* 過程CUT_ROD以價格陣列p[1..n]和整數n為輸入，返回長度為n的鋼條的最大收益 */
   {
       if(n==0) return 0;    /* 若n=0，不可能有任何收益，返回0 */
	   int q=INT_MIN;        /* 將最大收益q初始化為負無窮，以便for迴圈可以正確計算 */
	   for(int i=1;i<=n;i++) q=max(q,p[i]+CUT_ROD(p,n-i));
	   return q;             /* 返回計算結果 */
   }

   下面給出的是自頂向下CUT-ROD過程的c++語言程式碼，加入了備忘機制：

	int MEMOIZED_CUT_ROD(int *p,int n)
	{
		int *r=new int[n+1];
		for(int i=0;i<=n;i++) r[i]=INT_MIN;        /* 初始化為負無窮，這是一種常見的表示“未知值”的方法（已知的收益總是非負值）*/
		return MEMOIZED_CUT_ROD_AUX(p,n,r);
	}
	int MEMOIZED_CUT_ROD_AUX(int *p,int n,int *r)
	{
		int q;
		if(r[n]>=0) return r[n];         /* 若所需值已知，直接返回 */
		if(n==0) q=0;                    /* 否則計算 */ 
		else                              
		{
			q=INT_MIN;
			for(int i=1;i<=n;i++) q=max(q,p[i]+ MEMOIZED_CUT_ROD_AUX(p,n-i,r));
		}
		r[n]=q;                         /* 存入r[n] */
		return q;
	}

自底向上版本更為簡單：

	int BOTTOM_UP_CUT_ROD(int *p,int n)
	{
		int q;
		int *r=new int[n+1];
		r[0]=0;
		for(int i=1;i<=n;i++)
		{
			q=INT_MIN;
			for(int j=1;j<=i;j++) q=max(q,p[j]+r[i-j]); /* 內for迴圈的迭代次數構成一個等差數列。 */
			r[i]=q;
		}
		return r[n];
	}

    下面給出的是BOTTOM_UP_CUT_ROD的擴充套件版本，它對長度為i的鋼條不僅計算最大收益值ri，還儲存最優解對應的第一段鋼條的切割長度si：

	void EXTENDED_BOTTOM_UP_CUT_ROD(int *p,int n,int *r,int *s) /* 原文是返回兩個陣列，這裡通過傳入兩個陣列完成同樣操作 */
	{
		int q;
		r[0]=0;
		for(int i=1;i<=n;i++) 
		{
			q=INT_MIN;
			for(int j=1;j<=i;j++)
			{
				if(q<p[i]+r[i-j])
				{
					q=p[i]+r[i-j];
					s[i]=j;
				}	
			}
			r[i]=q;
		}
	}

    下面過程輸出長度為n的鋼條的完整最優切割方案：

	void PRINT_CUT_ROD_SOLUTION(int *p,int n)
	{
		int *r=new int [n+1];
		int *s=new int [n+1];
		EXTENDED_BOTTOM_UP_CUT_ROD(p,n,r,s);
		while(n>0)
		{
			cout<<s[n];
			n=n-s[n];
		}
	}

    下面給出完整的程式碼實現，以及遞迴與動規解法的效率對比。

#include<iostream>
#include<ctime>
const int INT_MIN=-2147483647 - 1;
using namespace std;
/*自頂向下遞迴*/
int CUT_ROD(int *p,int n) 
{
       if(n==0) return 0;   
	   int q=INT_MIN;        
	   for(int i=1;i<=n;i++) q=max(q,p[i]+CUT_ROD(p,n-i));
	   return q;             
}
/*帶備忘的自頂向下法*/ 
int MEMOIZED_CUT_ROD_AUX(int *p,int n,int *r)
{
	int q;
	if(r[n]>=0) return r[n];         /* 若所需值已知，直接返回 */
	if(n==0) q=0;                    /* 否則計算 */ 
	else                              
	{
		q=INT_MIN;
		for(int i=1;i<=n;i++) q=max(q,p[i]+ MEMOIZED_CUT_ROD_AUX(p,n-i,r));
	}
	r[n]=q;                         /* 存入r[n] */
	return q;
}
int MEMOIZED_CUT_ROD(int *p,int n)
{
	int *r=new int[n+1];
	for(int i=0;i<=n;i++) r[i]=INT_MIN;        /* 初始化為負無窮，這是一種常見的表示“未知值”的方法（已知的收益總是非負值）*/
	return MEMOIZED_CUT_ROD_AUX(p,n,r);
}
/*自底向上法*/
int BOTTOM_UP_CUT_ROD(int *p,int n)
{
	int q;
	int *r=new int[n+1];
	r[0]=0;
	for(int i=1;i<=n;i++)
	{
		q=INT_MIN;
		for(int j=1;j<=i;j++) q=max(q,p[j]+r[i-j]); /* 內for迴圈的迭代次數構成一個等差數列。 */
		r[i]=q;
	}
	return r[n];
}
/*重構解*/
int EXTENDED_BOTTOM_UP_CUT_ROD(int *p,int n,int *r,int *s) /* 原文是返回兩個陣列，這裡通過傳入兩個陣列完成同樣操作 */
{
	int q;
	r[0]=0;
	for(int i=1;i<=n;i++) 
	{
		q=INT_MIN;
		for(int j=1;j<=i;j++)
		{
			if(q<p[j]+r[i-j])
			{
				q=p[j]+r[i-j];
				s[i]=j;
			}	
		}
		r[i]=q;
	}
	return r[n]; 
}
void PRINT_CUT_ROD_SOLUTION(int *p,int n)
{
	int *r=new int [n+1];
	int *s=new int [n+1];
	cout<<EXTENDED_BOTTOM_UP_CUT_ROD(p,n,r,s)<<" = "; 
	while(n>0)
	{
		cout<<"s["<<s[n]<<"] ";
		n=n-s[n];
	}
	cout<<endl; 
}
int main()
{
	int p[41]={0,1,5,8,9,10,17,17,20,24,30,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1};/*為了測試效能*/
	time_t start,finish,totaltime;
	cout<<"——————帶備忘的自頂向下法——————\n";
	start=clock();
	cout<<"n=40時最優解為："<<MEMOIZED_CUT_ROD(p,40)<<endl;
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	cout<<"\n執行時間為"<<totaltime<<"秒！"<<endl;
	cout<<"————————自底向上法————————\n";
	start=clock();
	cout<<"n=40時最優解為："<<BOTTOM_UP_CUT_ROD(p,40)<<endl;
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	cout<<"\n執行時間為"<<totaltime<<"秒！"<<endl;
	cout<<"————————自頂向下遞迴———————\n";
	start=clock();
	cout<<"n=40時最優解為："<<CUT_ROD(p,40)<<endl;
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	cout<<"\n執行時間為"<<totaltime<<"秒！"<<endl;
	cout<<"————————————————————\n";
	cout<<"n=30時最優解為："<<endl;
	PRINT_CUT_ROD_SOLUTION(p,30);
	cout<<"n=29時最優解為："<<endl;
	PRINT_CUT_ROD_SOLUTION(p,29);
	return 0;
	
}

當n=40時

   通過比較可以發現，動規與遞迴的效能，在時間上差很多，當n=40時，遞迴的的時間是28194秒，而動規的時間很小，當n=160時也是很小的時間。所以在時間上的節省是巨大的。