動態規劃是為了求解一種包含大量重疊子問題的最優化問題的方法。基本思想是，將原問題分解為若干相似的子問題，在求解的過程中通過子問題的解求出原問題的解。聽起來和分治法很相似，但是，分治法只是不斷地將問題分解成小問題求解，而動規之所以優秀是它會進行類似於記憶化搜尋的過程，在求解的過程中把每一個子問題的解儲存下來（不管後面會不會用到），然後在求解更大的問題時，從這些子問題的解裡面尋求當前問題的最優解。所以，從這裡也可以看出動規解法的限定條件是，該問題有一個最優子結構，就是由它分解出的子問題的解也是最優的。

    這樣看起來是很抽象的，我們接下來一個個模型看下去吧。感覺對 dp 不太好分類，個人就做簡單的整理，程式碼不對或是分類有問題請大家指出，謝謝！

    首先是線性動規。

     單調遞增最長子序列

     這個問題的基本模型是，給一個序列，要求它的最長遞增子序列，子序列的值是遞增的，它的座標在原序列中也是遞增的，但不要求連續。

     如，給一串數字， 0 2 3 4 3 4 6  9 13 24 11 26，那麼它的單調遞增最長子序列就是 0 2 3 4 6 9 13 24 26

     給一串字母，a f r e f j l m o d, 單調遞增最長子序列就是 a e f j l m o

     下面是求一個字母序列的單調遞增子序列 

     解1：

     輸入字串為 str, 用一個數組 dp 記錄問題的解， dp[i] 表示以 str[i] 結束的單調遞增最長子序列的長度。 

     狀態轉移方程： dp[i] = max(1, dp[j] + 1)  , str[j] < str[i]

     複雜度為 O（n^2）

      程式碼：    

#include <iostream>
#include <string>
#include <cstring>

using namespace std;

#define max(a,b) (a)>(b)?(a):(b)

int main()
{
	int dp[10001],ans;
	int T;
	cin>>T;
	while(T--)
	{
		ans = 1;
		string str;
		cin>>str;
		int n = str.size();
		for(int i = 0;i < n;++i)
		{
			dp[i] = 1;
			for(int j = 0;j < i;++j)
			{
				if(str[i] > str[j])
				{
					dp[i] = max(dp[i],dp[j] + 1);
					if(dp[i] > ans) ans = dp[i];
				}
			}
		}
		cout<<ans<<endl;
	}
	return 0;
}
 

    解二：

    陣列 dp 存不是答案子序列，但它和子序列長度是一樣的，因為它的不斷更新，所以總能確保答案正確，多看幾遍。複雜度大概只有 O(100*N)，因為最長單調遞增子序列的長度是不可能超過127的。

#include<iostream>
#include<string>
#include<cstring>

using namespace std;

//求最長單調遞增子序列長度
int length(string str)
{
	int dp[128], ans = 1;;
	memset(dp,0,sizeof(dp));
	int n = str.size();
	dp[0] = str[0]; //初始化
	for(int i = 0;i < n;++i)
	{
		for(int j = ans - 1;j >= 0; --j)
		{
			if(j == 0 && dp[0] > str[i]) dp[0] = str[i];
			if(dp[j] < str[i])
			{
				dp[j+1] = str[i];
				if(j == ans - 1) ans++;
				break;
			}
		}
	}
	return ans;
}

int main()
{
	int T;
	string str;
	cin>>T;
	while(T--)
	{
		cin>>str;
		cout<<length(str)<<endl;
	}
	return 0;
}

    單調遞增最長子序列應用：

     攔截導彈：

     題意：就是給一個序列然後求它的單調遞減最長子序列的長度。

     思路：按照最長單調遞增子序列的思路，只要把遞增的比較改為遞減的比較就好，length1 函式為上面解法一的修改解法， length2 為上面解法二的修改解法，而且運用二分查詢存放位置。

     程式碼：

/*  
 *  http://acm.nyist.net/JudgeOnline/problem.php?pid=79
 *
 * 求最長單調遞減子序列長度
 */

#include<iostream>
#include<cstring>
#include <cstdio>

using namespace std;

#define MAXN 20 + 1
#define max(a,b) (a)>(b)?(a):(b)  

int num[MAXN];
int dp[MAXN];

//直接 dp ，O(n^2)
int length1(int *num,int n,int *dp)
{
	int ans = 1;
	memset(dp,0,sizeof(dp));
	for(int i = 0;i < n;++i)
	{
		dp[i] = 1;
		for(int j = 0;j < i;++j)
		{
			if(num[j] > num[i])
			{
				dp[i] = max(dp[i],dp[j] + 1);
				ans = max(ans,dp[i]);
			}
		}
	}
	return ans;
}

//求最長單調遞減子序列長度,運用二分
int length2(int *num, int n, int *dp)
{
	int ans = 1;;
	memset(dp,0,sizeof(dp));
	dp[0] = num[0]; //初始化
	for(int i = 0;i < n;++i)
	{
		//二分查詢 num[i] 應放的位置
		int st = 0,ed = ans - 1;
		while(st <= ed)
		{
			int mid = (st + ed)/2;
			if(dp[mid] == num[i]) break;
			if(dp[mid] > num[i])
			{
				st = mid + 1;
			}
			else
			{
				ed = mid - 1;
			}
		}
		// st > ed 的時候才要將 num[i] 放進去，用紙演算一下，要放在 dp[st] 的位置
		if(st > ed)
		{
			dp[st] = num[i];
			if(st == ans) ans++;
		}
	}
	return ans;
}

int main()
{
	int N,M;
	scanf("%d",&N);
	while(N--)
	{
		scanf("%d",&M);
		for(int i = 0;i < M;++i)
			scanf("%d",&num[i]);
		cout<<length1(num, M, dp)<<endl;
	}
	return 0;
}

    題意：給 n 個整數，求一個子序列，有一箇中間數 i, 使得 i 的左邊遞增，右邊遞減，要這個子序列最長。輸出 n - length, length 為該子序列的長度。

    思路：這還是單調遞增最長子序列的問題，只是多了一步，要一個左邊遞增右邊遞減加起來最長的序列，資料較小，所以我們可以列舉。對佇列裡的每個數 i ，計算以它為中心的最長遞增和最長遞減，長度加起來和答案比較，更新 ans. 複雜度為 O(n^3) 。

    程式碼：

/* 
 * http://www.rqnoj.cn/problem/26
*/

#include <iostream>
#include <cstring>
#include <cstdio>
#include <string>

using namespace std;

#define maxn 103

int n,p[maxn],dp[maxn];
int ans;

int solve()
{
	for(int i = 1;i <= n;++i)
	{
		for(int j = 1;j <= n;++j)
		{
			dp[j] = 1;
			for(int k = 1;k < j;++k)
			{
				if(p[k] < p[j]) dp[j] = max(dp[j],dp[k]+1);
			}
		}
	    int l = dp[i];

		for(int j = n;j >= i;--j)
		{
			dp[j] = 1;
			for(int k = n;k > j;--k)
			{
				if(p[k] < p[j]) dp[j] = max(dp[j],dp[k]+1);
			}
		}
		int r = dp[i];

		ans = max(ans,l+r-1);
	}
	return n-ans;
}

int main()
{
	while(scanf("%d",&n)!=EOF)
	{
		for(int i = 1;i <= n;++i)
			scanf("%d",&p[i]);

		printf("%d\n",solve());
	}
	return 0;
}

     這是線性 dp 的另一種型別。給出 n 個整數，求一個連續的子串，使得這個子串的和在所有子串中最大。

     思路：這道題的空間複雜度可以降到 O(1)，不需要把所有的數存起來，只要一邊輸入一邊判斷就好。我們用 last 表示到前一位的最大子串和，初始化是 0, 那麼以某個數結尾的最大子串和的最壞情況就是它本身，如果 last >0,到當前數的最大子串和肯定是當前數加上 last，然後動態更新 ans 就好。

    程式碼：

/*
 * http://acm.nyist.net/JudgeOnline/problem.php?pid=44
 */

#include <iostream>
#include <cstdio>

using namespace std;

#define INF -99999999
#define max(a,b) (a)>(b)?(a):(b)

int main()
{
	int T,n,last,cur;
	scanf("%d",&T);
	while(T--)
	{
		int sum = INF;
		last = 0;
		scanf("%d",&n);
		for(int i = 0;i < n;++i)
		{
			scanf("%d",&cur);
			//這是關鍵一步，如果前面的子串和 >0，那麼這一步的最大子串和為這一個數加上前一步的最大子串和
			if(last > 0) cur += last;
			sum = max(sum,cur);
			last = cur;
		}
		printf("%d\n",sum);
	}
	return 0;
}

    題意：長度為 n 的所有 0 1 串中，不含 11 的有多少個。

    思路：dp[i] 表示長度為 i 的 0 1串不含 11 的有多少個。初始條件是 dp[1] = 2   dp[3] = 3  

                算dp[i] 的時候，如果 i 位為 0 ，那麼前 i-1 位任取，所以 dp[i] += dp[i-1] 

                如果 i 位為 1，那麼 i-1 位只能為 0，前 i-2 位任取，所以 dp[i] += dp[i-2]

                狀態方程： dp[i] = dp[i-1] + dp[i-2]

     程式碼：

/*
 * http://acm.nyist.net/JudgeOnline/problem.php?pid=252
dp[i]表示第i為不含11的01串個數
第i位為0，則前 i-1 位可任取
第i位為1，則 i-1 位必為0，前 i-2 位任取
所以 dp[i] = dp[i-1] + dp[i-2];
*/

#include<iostream>
#include<cmath>

using namespace std;

#define MAXN 42

int main()
{
	int dp[MAXN],n;
	dp[2] = 3;
	dp[3] = 5;
	for(int i = 4;i <= 40;++i)
		dp[i] = dp[i-1] + dp[i-2];
	cin>>n;
	while(n--)
	{
		int k;
		cin>>k;
		cout<<dp[k]<<endl;
	}
	return 0;
}

    題意：使用一種加密方法，把 A-Z 對映為 1 - 26，那麼根據一個加密後的序列，可能有多種解密方法，比如給 124，你可以理解成 1、2、4，也可以看成 12、4，或者1 、24，所以要求求出共有多少中可能。

    思路：用 dp[i] 表示到第 i 位有多少種解密方法，則可以看到 dp[i] 和 dp[i-1] dp[i-2] 的關係。如果第 i 個數不是 0 ，那麼這個數可以作為單獨一個字母進行解碼，前面 i-1 位任取，所以 dp[i] += dp[i-1] 。如果第 i-1 位是 1 或者 i-1 位是2，i 位是小於 7 的數，那麼它們可以翻譯為一個字母解碼，前 i-2 位任取，所以 dp[i] += dp[i-2]。

   程式碼：

/*
 *http://soj.me/1001 
 */
#include <iostream>
#include <string>
#include <cstring>

using namespace std;

int main()
{
	string str;
	int ans[10000];
	int n;
	while(cin>>str&&str!="0")
	{
		memset(ans,0,sizeof(ans));
		ans[0] = 1;ans[1] = 1;
		n = str.size();
		for(int i=1;i<n;++i)
		{
			if(str[i]!='0') ans[i+1] += ans[i];
			if(str[i-1]=='1'||(str[i-1]=='2'&&str[i]<'7')) ans[i+1] += ans[i-1];
		}
		cout<<ans[n]<<endl;
	}
	return 0;
}