我想很多人第一次學習遞迴的時候，老師或者書本上可能會舉漢諾塔的例子。

但是今天，我們討論的重點不是簡單的漢諾塔演算法，而是三柱漢諾塔的延伸。先來看看經典的三柱漢諾塔。

一、三柱漢諾塔（Hanoi_Three）：

我想大家對於三柱漢諾塔的理解以及演算法的實現應該是很熟練了。

我在這裡簡單的過一遍三柱漢諾塔的演算法思想：

有A、B、C三根柱子，A柱上有n個盤子，現在需要將A上所有的盤子轉移到C上，請給出搬運次數最少的步驟。

演算法思想：

1、將A上n-1個盤子以C為快取，全部轉移到 B 柱上。

2、將A上留下的第n個盤子，直接轉移到 C  柱上。

3、將B上的n-1個盤子，以A為快取，全部轉移到 C 柱上。

很容易得到演算法的遞迴方程為：T(n)=2*T(n-1)+1，不難算出步數是T(n)=2^n-1。

具體的程式碼如下：

1. void Move( char x, char y )  
2. {  
3.     printf("%c --> %c\n", x, y); //列印路徑，x-->y
4. }  
5. void Hanoi_Three( int n, char a, char b, char c )  
6. {  
7.     if( n <= 0 )  
8.         return ;      
9.     step++;     //步驟+1
10.     if( n == 1 )  
11.     {  
12.         Move( a, c );   //將a柱上的一個盤子直接移動到c柱
13.         return ;      
14.     }  
15.     else
16.     {  
17.         Hanoi_Three( n-1, a, c, b);     //將a上n-1個盤子以c為快取，全部轉移到 b 柱上
18.         Move( a, c );                   //將A上留下的第n個盤子，直接轉移到 C  柱上
19.         Hanoi_Three( n-1, b, a, c);     //將b上的n-1個盤子，以a為快取，全部轉移到 c 柱上
20.     }  
21. }  

二、四柱漢諾塔（Hanoi_Four）：

當柱子為四根時，對於只是將盤子全部轉移到另一根柱子上這個目的來說，是大大降低了難度，而且演算法的複雜度也大大降低了。但是，這個時候，如果要你找到一個最優的、步驟最少的實現方法，可以說難度是提升了一個數量級。

有些人可能會質疑，為什麼，我用三柱漢諾塔的思想不是很優化了嗎？

別急，且讓我慢慢向你道來。

先來看看這種‘看上去很合理’的解法：

假設，A，B，C，D，分別為：源位置，快取，快取，目的位置。

因為三柱的時候，我們是將A的前n-1個盤子放到B上快取，然後將第n個盤子放到C柱上。

現在的情況好很多，有兩個可以快取的柱子，因此，看上去移動起來更加方便，原來B上需要快取的n-1個盤子，現在可以只是n-2個盤子，而將第n-1個盤子放到C上快取。

具體的流程如下（非最優解法）：

1、從A藉助C、D將 n-2個盤子移動到B上。

2、將第n-1個盤子移動到C上。

3、將第n個盤子移動到D上。

4、將第n-1個盤子移動到D上。

5、從B藉助A、C將 n-2個盤子全部移動到D上。

看上去，非常完美，筆者也一度覺得這個思想沒有破綻，甚至我還自以為找到了k根柱子漢諾塔的通用方法（想當然的將B柱上快取的數量從n-2個，改為n-（k-2）個盤子）。直到我看了這篇文章：

    雖然我們想到讓盤子儘量不發生重疊來保證步數的最少，但是這並不能絕對保證。或許在盤子較少的情況下是可行的，但是盤子增多時，那些多餘的只有一個盤子的柱子是可以加以利用的（可能的優化在這裡）。雖然這麼做加多了每次的移動步數，但是卻從另一個側面減少了遞迴的數量，因此我們需要從這裡邊找一個平衡點。

下面我們來看看，1941年，美國的J. S. Frame，給出的四柱漢諾塔的演算法思想，也叫Frame演算法：

1、用4柱漢諾塔演算法把A柱上部分的n- r個碟子通過C柱和D柱移到B柱上【F( n- r )步】。

2、用3柱漢諾塔經典演算法把A柱上剩餘的r個碟子通過C柱移到D柱上【2^r-1步】（參照上述三柱時的情況）。

3、用4柱漢諾塔演算法把B柱上的n-r個碟子通過A柱和C柱移到D柱上【F(n-r)步】。

4、依據上邊規則求出所有r（1≤r≤n）情況下步數f(n)，取最小值得最終解。

因此Frame演算法的遞迴方程如下：

F(n)=min(2*F(n-r)+2^r-1)，（1≤r≤n）。

大家有沒有發現，其實，這個演算法思想跟我們之前認為合理的演算法基本一致，差別只是在於他將我們的n-2個碟子快取到B上，改為了將n- r個碟子轉移到B柱上。

差別即使核心，這個演算法的核心，就是計算n個盤子的情況下，r為何值時，能夠使得演算法最優。

找到了核心，我們現在的任務就明確了，就是對r值的計算。

這裡給出了一個較笨的方法--列舉（不知道各位有沒有其他方法）。就是將一定範圍內的n與r的所有取值帶入，得到滿足F（n）為最小值的r的值，記為K[n] = r；

具體的程式碼如下：

1. void Init_K(void )  
2. {  
3.     int i, k;     
4.     __int64 temp;     
5.     __int64 m[Max+1] = {0};       
6.     for( i = 1; i <= Max; i++ )  
7.     {  
8.         m[i] = INT_MAX;       
9.         for( k = 1; k <= i; k++ )  
10.         {  
11.             temp = 2*m[i-k] + (__int64)pow(2,k) - 1;      
12.             if( temp < m[i] )  
13.             {  
14.                 m[i] = temp;      
15.                 K[i] = k;     
16.                 //printf("K[%d] = %d, m[i] = %d\n", i, k, temp );   
17.             }  
18.         }  
19.     }  
20. }  

得到各個n對於的r之後，演算法將變的非常簡單，具體實現如下：

1. #include <stdio.h>
2. #include <math.h>
3. #define Max 100 
4. #define INT_MAX 0xfffffffffffffff
5. int K[Max+1] = {0};   
6. int step = 0;     
7. void Hanoi_Four( int n, char a, char b, char c, char d );     
8. void Hanoi_Three( int n, char a, char b, char c );    
9. void Move( char x, char y );      
10. void Move( char x, char y )  
11. {  
12.     printf("%c --> %c\n", x, y); //列印路徑，x-->y
13. }  
14. void Hanoi_Three( int n, char a, char b, char c )  
15. {  
16.     if( n <= 0 )  
17.         return ;      
18.     step++;     //步驟+1
19.     if( n == 1 )  
20.     {  
21.         Move( a, c );   //將a柱上的一個盤子直接移動到c柱
22.         return ;      
23.     }  
24.     else
25.     {  
26.         Hanoi_Three( n-1, a, c, b);     //將a上n-1個盤子以c為快取，全部轉移到 b 柱上
27.         Move( a, c );                   //將A上留下的第n個盤子，直接轉移到 C  柱上
28.         Hanoi_Three( n-1, b, a, c);     //將b上的n-1個盤子，以a為快取，全部轉移到 c 柱上
29.     }  
30. }  
31. void Hanoi_Four( int n, char a, char b, char c, char d )  
32. {  
33.     if( n <= 0 )  
34.         return ;      
35.     if( n == 1 )  
36.     {  
37.         step++;   
38.         Move( a, d );     
39.         return ;      
40.     }  
41.     else
42.     {  
43.         int kn = K[n];    
44.         //printf("kn = %d\n", K[n]);    
45.         Hanoi_Four( n-kn, a, c, d, b );     //用4柱漢諾塔演算法把A柱上部分的n- kn個碟子通過C柱和D柱移到B柱上
46.         Hanoi_Three( kn, a, c, d );         //用3柱漢諾塔經典演算法把A柱上剩餘的kn個碟子通過C柱移到D柱上。
47.         Hanoi_Four( n-kn, b, a, c, d );     //用4柱漢諾塔演算法把B柱上的n-r個碟子通過A柱和C柱移到D柱上
48.     }  
49. }  
50. void Init_K(void )  
51. {  
52.     int i, k;     
53.     __int64 temp;     
54.     __int64 m[Max+1] = {0};       
55.     for( i = 1; i <= Max; i++ )  
56.     {  
57.         m[i] = INT_MAX;       
58.         for( k = 1; k <= i; k++ )  
59.         {  
60.             temp = 2*m[i-k] + (__int64)pow(2,k) - 1;      
61.             if( temp < m[i] )  
62.             {  
63.                 m[i] = temp;      
64.                 K[i] = k;     
65.                 //printf("K[%d] = %d, m[i] = %d\n", i, k, temp );   
66.             }  
67.         }  
68.     }  
69. }  
70. int main()  
71. {  
72.     int n;    
73.     Init_K();     
74.     printf("Please enter the number of the Plates: \n");  
75.     while( scanf("%d", &n) != EOF )  
76.     {  
77.         step = 0;     
78.         Hanoi_Four( n, 'A', 'B', 'C', 'D' );      
79.         //Hanoi_Three( n, 'A', 'B', 'C' );  
80.         printf("**************************\nTotal Step: %d\n", step );    
81.         printf("Please enter the number of the Plates: \n");  
82.     }  
83.     return 0;     
84. }  

相關推薦