動態規劃演算法(DP)學習＜1＞

是一種用來最優化問題的方法，將一個複雜問題分解成若干個子問題，再通過將每個子問題的最優解記錄下來，這樣在再次碰到子問題的時候，就有一個直接的答案。重點就是其取消了重複計算環節。

通常使用遞迴和遞推兩種方法實現動態規劃，遞迴又叫做：記憶化搜尋。

可以從一個Fibonacci數列的計算為例：
計算斐波那契數列的經典方法就是遞迴，也就是如下：

int F(int n)
{
	if(n==0||n==1) return 1;
	else return F(n-1)+F(n-2);
}

這裡就涉及了重複計算的問題，例如我要計算F(5)。那麼要計算F(4)和F(3)而F4=F3+F2，F3=F2+F1；可以看到F2被計算了兩遍。如果可以把重複計算的值在計算一遍後儲存起來，則可以實現程式的優化。

分析其迭代過程：可以用一個一位陣列dp[maxn]記錄被計算過的F(n)的值。

			   dp[i]=F(i-1)+F(i-2)；

那麼可以將原函式改寫：

int F(int n)
{	
	int maxn=1000;
	int dp[maxn];
	for(int i=0;i<maxn;i++)
		dp[i]=-1;
	//設定成-1，如果不等於-1則說明其已經被賦值，直接輸出。
	if(n==1||n==0)	return 1;
	if(dp[n]!=-1) return dp[n];
	else
		dp[n]=F(n-1)+F(n-2);
	return dp[n];
}

這裡就可以看出記憶化搜尋的意思來，就是用一個陣列記錄需要被重複計算的部分，等到再次呼叫到的時候直接輸出。

記憶化搜尋能夠把複雜度降級。

這裡可以引出動態規劃的一個要素，就是重疊子問題和最優子結構，它被分解為幾個子結構後，每個子結構每次決策過程中要有最優解。

下面以一個問題為例，再分步思考動態規劃問題。

最大連續子序列和

 給定一個數字序列A1，A2，A3...,An，求i,j（1<=i<=j<=n），使得Ai+...+Aj最大，輸出最大和

這裡使用動態規劃解法，假設一個dp[i][j]二維陣列，用來儲存i和j指向的值。
他的子問題是什麼？假設現在有

                     A1=-2, A2=11, A3=-4, A4=-3

暴力方法就是遍歷，其過程可以寫下為：

A[1->1]=-2  A[1->2]=-2+11  A[1->3]=-2+11-4  A[1->4]=-2+11-4-3
		    A[2->2]=11     A[2->3]=11-4     A[2->4]=11-4-3
		                   A[3->3]=-4       A[3->4]=-4-3
		                                    A[4->4]=-3

總結可以得到其子問題：
在這裡需要考慮：需要得到的結果是最大值。可以將最大值設為dp[i]，表示以A[I]為結尾的一系列最大值。
而每次計算得到的最大值是什麼？

	dp[i]=dp[i-1]+A[i]

這裡再考慮如果A[i]>dp[i-1]，那麼如果加上，則dp[i]<A[i]，這是不合理的，所以這種情況可以加上

   dp[i]=max(dp[i-1]+A[i],A[i])

而邊界條件則是：

   dp[0]=A[0]

這樣就不會發生在迭代的時候卡殼的問題。
整個邏輯完成了之後就可以開始程式碼編寫了。

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn=10010;
int A[maxn],dp[maxn];
int main()
{
	//輸入數列
	int n;
	scanf(%d,&n);
	for(int i=0;i<n;i++)
	{sacnf(%d,&A[i]);}
	//數列輸入完畢
	dp[0]=A[0];
	for(int i=1;i<n;i++)
	{
		dp[i]=max(dp[i-1],A[i]);
	}
	//已經完成，接下來比較輸出	
	int k=0;
	for(int i=1;i<n;i++)
	{
		if(dp[i]>dp[k])
			k=i;
	}
	printf(%d,&dp[k]);
	return dp[k];
}

再來看一個問題

最長迴文子串

給出一個字串S，求S的最長迴文子串長度
eg：字串"PATZJUJZTACCBCC"的最長迴文子串為"ATZJUJZTA"，長度為9。

怎麼判斷是不是迴文串？這是首要的問題。
傳統判斷迴文的方法：

	兩頭夾：先判斷s[0] 與s[len-1],再是s[1]與s[len-1-1]，。。。。以此迴圈

那麼判斷是不是迴文的方法就確定了，這是一個可以分解成子問題的過程。

暴力方法就是遍歷所有的子串組合，在這個過程中，有許多的重複計算。
在每次判定的組合裡，都會重複之前的步驟，判定某個子串是不是迴文。
那麼是否需要一個數列，儲存之前計算過的關於某子串是不是迴文的資訊？

這就是優化的地方。
那麼判斷一個子串是不是迴文的DP寫法呢？

//虛擬碼
bool dp[i][j];
if(s[i]==s[j])
	dp[i][j]==dp[i+1][j-1];  //j>=1
else if(s[i]!=s[j])
	dp[i][j]=0;

我判斷我自身是不是迴文，只需要先比較我的兩頭是不是相等，再判斷我裡面是不是迴文，而裡面是不是迴文這個資訊已經在之前計算過了。

這是一個遞迴的過程。

那麼其邊界條件需要考慮的：
1.自身與自身，長度為1的迴文子串，不能讓不能讓i+1>j-1
2.根據i+1>j-1，則j>i+2；那麼j=i+1的情況呢？要設定為邊界條件。
//兩條都是根據j>i+2的條件來寫的

for(i=0;i<len;i++)
	dp[i][i]=1;
dp[i][i+1]=(s[i]==s[i+1])?1:0;

完成了設定後就可以開始寫程式碼了。

#include <iostream>
#include <string>
#define MAXN 1010

using namespace std;
int main()
{
int dp[MAXN][MAXN];//dp只有0和1
string s;
cin>>s>>endl;
int ans=1;
memset(dp,0,sizeof(dp)); //初始化為0
//邊界處理
for(int i=0;i<s.size();i++)
{
	dp[i][i]=1;
	if(i<len-1)
	{
		dp[i][i+1]=(s[i]==s[i+1])?1:0;
		ans=2;
	}	
}
//這裡進行篩選的方式也需要考慮，是根據i,j雙迴圈的方式進行？還是根據固定長度L，遍歷完一個長度的序列後再遍歷L++的值呢
//看哪種方式能夠不卡殼，那麼i,j雙迴圈的方式明顯不行，選用固定長度方式
for(int L=3;L<s.size();L++)
{	int j=i+L-1
	for(int i=1;i+L-1<s.size();i++)
	{
		if(s[i]==s[j])
			dp[i][j]=dp[i+1][j-1];
		else
			dp[i][j]=0;	
	}
	if(dp[i][j]==1)
		ans=j-i+1;
}
return ans;
}

《演算法筆記》