觀察下面的數字金字塔，查詢從最高點到底部任意結束的路徑，使路徑經過的數字之和最大。每一步可以從當前點走到左下方的點或者右下方的點。

                         13

                   11         8

             12          7          26

       6          14          15          8

12          7          13         24         11

（每個點與左下方和右下方有連線線，請自己想象喔！！）

最優路線：13-8-26-15-24=86.

本題介紹四種方法給大家，有助於大家對動態規劃有更深入的瞭解。

方法一：搜尋

路徑起點終點明確，走法固定，可以考慮搜尋解決。

定義遞迴函式void  dfs(int x,int y,int curr),表示從（1，1）走到點（x，y）的權值和curr。

當x=n時，到達邊界。用所得的curr和ans比較，如果curr比較大，更新ans的值。

如果x<n,繼續遞迴，dfs(x+1,y,curr+a[x+1][y])和dfs(x+1,y+1,a[x+1][y+1])。

參考程式：

#include<iostream>
using namespace std;
int a[1010][1010],ans=0;
int n;//輸入數塔層數n
void dfs(int x,int y,int curr)
{
	if(x==n)
	{
		if(curr>ans) ans=curr;
		return ;
	}
	dfs(x+1,y,curr+a[x+1][y]);
	dfs(x+1,y+1,curr+a[x+1][y+1]); 
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
			cin>>a[i][j];
	dfs(1,1,a[1][1]); 
	cout<<ans<<endl; 
	return 0;
}
 

此方法實際把所有的路徑都走了一遍，由於每條路徑有n-1步組成，每一步有左下，右下兩種選擇，路徑總數為2^n-1   時間複雜度為O(2^n-1),

方法二：記憶化搜尋

方法一有嚴重的問題，當n比較大時會花費太多時間，因為它進行了重複的搜尋。如一條路徑為13-11-12-6-12，另一條為13-11-12-6-7，對於11，12，6這些點進行了重複的搜尋。我們完全可以在第一次搜尋這些點時，就將這些點到終點的最大權值和記錄下來，當我們再次到達這個點，就可以直接呼叫，不用重複搜尋，這種方法就叫記憶化搜尋。

因此，我們需要重新定義遞迴函式dfs。定義dfs（int x，int y）表示（x，y）到終點的最大權值和，最後的答案就是dfs（1，1）.

為了避免重複搜尋，我們開設一個數組dg[x][y]表示（x，y）點到終點的最大權值。

參考程式：

#include<iostream>
using namespace std;
int a[550][550],dg[550][550];
int n;
int dfs(int x,int y)
{
	if(dg[x][y]==-1)//判斷是否已經計算過 
	{
		if(x==n)  dg[x][y]=a[x][y];
		else dg[x][y]=max(dfs(x+1,y),dfs(x+1,y+1))+a[x][y];
	}
	return dg[x][y];//計算過直接返回 
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
		{
			cin>>a[i][j];
			dg[i][j]=-1;
		}	
	dfs(1,1);
	cout<<dg[1][1]<<endl;
	return 0;
}

由於每一個點都只計算過一次，且是O（1）的時間，所以這種方法的時間複雜度為O（N*N）(n的平方）

方法三：動態規劃（順推法）

方法二的記憶化搜尋，從本質來講已經算是動態規劃了。下面從動態規劃的角度分析解題過程。

1.確定狀態：

題目求解（1，1）到最底層路徑的最大權值，路徑起點固定，終點和中間點不確定，因此定義dg[x][y]表示從（1，1）出發到（x，y）路徑的最大權值和。最終答案就是尋找最底層的最大值，ans=max{dg[n][1],dg[n][2],dg[n][3]...dg[n][n]}.

2.確定狀態轉移方程和邊界條件

不去考慮（1，1）到（x，y）中間是怎麼走的，只需要考慮（x，y）上一步是怎麼來的，上一步可能是（x-1，y），也可能是（x-1，y-1），因此dg[x][y]的最大值就是上一步的最大權值和：max{dg[x-1][y],dg[x-1][y-1])，再加上自己的權值a[x][y]。

所以狀態轉移方程就是：dg[x][y]=max{dg[x-1][y],dg[x-1][y-1]}+a[i][j]。

與遞迴一樣，我們也需要終止條件，防止無限遞迴下去。我們發現dg[x][y]的值取決於dh[x-1][y],dg[x-1][y-1]，隨著遞迴的深入，最後一定會遞迴到dg[1][1]，dg[1][1]不能再使用狀態轉移方程了，所以給dg[1][1]附一個初值，即a[1][1]。

參考程式

#include<iostream>
using namespace std;
int a[550][550],dg[550][550];
int n;
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
			cin>>a[i][j];
	dg[1][1]=a[1][1];	
	for(int i=2;i<=n;i++)
	{
		for(int j=1;j<=i;j++)
		{
			dg[i][j]=max(dg[i-1][j-1],dg[i-1][j])+a[i][j];
		}
	 } 
	 int ans=0;
	 for(int i=1;i<=n;i++)
	 	ans=max(ans,dg[n][i]);
	cout<<ans<<endl;
	return 0;
}

這種方法的時間複雜度一樣是O（n*n）（n的平方）

方法四：動態規劃（逆推）

從根節點，最底層的點出發，向上走，選擇它上一層兩個方向的最大值為最大的路徑，然後從n-1層繼續向上，找自己兩個方向的最大值，一直到（1，1）。

動態規劃求解過程就可以歸納為：自頂向下分析，自底向上計算。

下面具體分析整個過程，大家就明白了。

以問題描述中的樣例為例。

第4層  6  14  15  8

6這個點要找最大路徑，就要選擇和它連線12和7中的最大值，同理14選擇7和13中最大值，15選擇13和24中最大值，8選擇24和11中最大值，他們分別選擇兩個方向的最大值，然後第4層就更新為了

18  27  39  32

同理第三層12  7  26

尋找兩個方向的最大值，不過兩個方向的值已經更新，選擇新的值中的最大值，12選擇18和27，7選擇27和39，26選擇39和32

得到第三層為39  46  65

第二層 11  8

更新為57  73

最後第一層選擇57和73，a[1][1]就為73+13=86，即最後的答案。

參考程式：

#include<iostream>
using namespace std;
int a[550][550];
int n;
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
			cin>>a[i][j];	
	for(int i=n-1;i>=1;i--)
	{
		for(int j=1;j<=i;j++)
			a[i][j]+=max(a[i+1][j],a[i+1][j+1]);//尋找最大的路徑 
	 } 
	cout<<a[1][1]<<endl;
	return 0;
}