算法：記憶性搜索算法

轉載：JYRoy（轉載文章，方便本身回憶） 

一：簡述

　　記憶化搜索其實是遞歸來實現的，可是遞歸的過程當中有許多的結果是被反覆計算的，這樣會大大下降算法的執行效率。

　　而記憶化搜索是在遞歸的過程當中，將已經計算出來的結果保存起來，當以後的計算用到的時候直接取出結果，避免重複運算，所以極大的提升了算法的效率。

二：應用實例

　　題目描述

　　對於一個遞歸函數w(a,b,c)

• 若是 a<=0 or b<=0  or  c<=0 就返回值1.
• 若是 a>20 or b>20 or c>20就返回w(20,20,20)
  
• 若是 a<b而且b<c 就返回w(a,b,c-1)+w(a,b-1,c-1)-w(a,b-1,c)
  
• 其它的狀況就返回w(a-1,b,c)+w(a-1,b-1,c)+w(a-1,b,c-1)-w(a-1,b-1,c-1)

　　這是個簡單的遞歸函數，但實現起來可能會有些問題。當a,b,c均爲15時，調用的次數將很是的多。你要想個辦法才行.

　　/* absi2011 : 好比 w(30,-1,0)既知足條件1又知足條件2

　　這種時候咱們就按最上面的條件來算

　　因此答案爲1

　　*/

　　輸入輸出格式

　　輸入格式：

　　會有若干行。

　　並以-1,-1,-1結束。

　　保證輸入的數在[-9223372036854775808,9223372036854775807]之間，而且是整數。

 　輸出格式：

 　　輸出若干行，每一行格式：

　　w(a, b, c) = ans

　　注意空格。

　　輸入輸出樣例

　　輸入樣例#1： 

　　1 1 1
　　2 2 2
　　10 4 6
　　50 50 50
　　-1 7 18
　　-1 -1 -1

　　輸出樣例#1： 

　　w(1, 1, 1) = 2
　　w(2, 2, 2) = 4
　　w(10, 4, 6) = 523
　　w(50, 50, 50) = 1048576
　　w(-1, 7, 18) = 1

---

　　
　　這是一個很是經典的記憶化搜索的題目。
　　拿到這個題，首先能夠想到的就是遞歸的方法，看上去用遞歸能夠垂手可得的解決。可是遞歸的開銷是不通常的大。下面先給你們上一個遞歸的代碼，以便和以後的記憶化搜索的進行對比。
　　（注：此法若例子爲15 15 15，執行會半小時以上，並無優化代碼）
　　

 1 #include<iostream>
 2 #include<cstdio>
 3 #include <time.h>    //用來記時 
 4 using namespace std;
 5 clock_t start, finish;
 6 double duration;
 7 
 8 typedef long long ll;
 9 ll f[30][30][30];
10 
11 int w(ll a, ll b, ll c){      //遞歸的函數 
12     if(a<=0||b<=0||c<=0){
13         return 1;
14     }
15     else if(a>20||b>20||c>20){
16         return w(20,20,20);
17     }
18     else if(a<b&&b<c){
19         return w(a,b,c-1) + w(a,b-1,c-1) - w(a,b-1,c);
20     }
21     else{
22         return w(a-1,b,c)+w(a-1,b-1,c)+w(a-1,b,c-1)-w(a-1,b-1,c-1);
23     }
24 }
25 
26 int main(){
27     ll a, b, c;
28     while(1){
29         cin >> a >> b >> c;
30         start = clock();    //開始計時 
31         if(a==-1&&b==-1&&c==-1) return 0;
32         else{
33             printf("w(%lld, %lld, %lld) = %d\n", a, b, c, w(a, b, c));
34             finish = clock();    //結束記時 
35             duration = (double)(finish - start) / CLOCKS_PER_SEC;   //計算持續時間 
36             printf( "%f seconds\n", duration );
37         }
38     }
39     return 0;
40 } 

　　運行結果

 

記憶化搜索解法#

　　開闢一個數組 f[][][]，用來存儲計算出來的結果。

　　關於數組的大小：由於題目中給出了一個條件 「 若是 a>20 or b>20 or c>20就返回w(20,20,20) 」 那麼數組只要最小開到 f[21][21][21]就夠用了。

　　具體的步驟看代碼中的註解。

 1 #include<iostream>
 2 #include<cstdio>
 3 #include <time.h>   
 4 using namespace std;
 5 clock_t start, finish;
 6 double duration;
 7 
 8 typedef long long ll;
 9 ll f[30][30][30];
10 
11 int w(ll a, ll b, ll c){
12     if(a<=0||b<=0||c<=0){
13         return 1;
14     }
15     else if(a>20||b>20||c>20){
16         return w(20,20,20);
17     }
18     else if(f[a][b][c]!=0)return f[a][b][c];   //若是以前被計算過，那麼直接返回存在數組中的結果 
19                                                 //沒有計算過的，就進行的計算 
20     else if(a<b&&b<c){                            
21         f[a][b][c] = w(a,b,c-1) + w(a,b-1,c-1) - w(a,b-1,c);
22     }
23     else{
24         f[a][b][c]=w(a-1,b,c)+w(a-1,b-1,c)+w(a-1,b,c-1)-w(a-1,b-1,c-1);
25     }
26     return f[a][b][c];            //計算完畢以後返回計算出的結果 
27 }
28 
29 int main(){
30     ll a, b, c;
31     while(1){
32         cin >> a >> b >> c;
33         start = clock();    //開始計時 
34         if(a==-1&&b==-1&&c==-1) return 0;
35         else{
36             printf("w(%lld, %lld, %lld) = %d\n", a, b, c, w(a, b, c));
37             finish = clock();    //結束記時 
38             duration = (double)(finish - start) / CLOCKS_PER_SEC;   //計算持續時間 
39             printf( "%f seconds\n", duration );
40         } 
41     }
42     return 0;
43 } 

　　

　　運行結果

　　你們和遞歸的運行時間對比一下就能夠看出，當遞歸的次數多了以後，效率要高出不少。

三：總結過程　

　根據上面的題，能夠總結一個記憶化搜索的過程。 （注：原創做者此總結很精妙）

 1 f（problem p）{
 2     if(p has been solved){
 3          return the result      
 4     }else{
 5          divide the p into some sub-problems (p1, p2, p3...)
 6          f(p1);
 7          f(p2);
 8          f(p3);
 9          ...
10     }