漢諾塔問題

 

漢諾塔問題是一個經典的問題。漢諾塔（Hanoi Tower），又稱河內塔，源於印度一個古老傳說。大梵天創造世界的時候作了三根金剛石柱子，在一根柱子上從下往上按照大小順序摞着64片黃金圓盤。大梵天命令婆羅門把圓盤從下面開始按大小順序從新擺放在另外一根柱子上。而且規定，任什麼時候候，在小圓盤上都不能放大圓盤，且在三根柱子之間一次只能移動一個圓盤。問應該如何操做？

 

分析

若是是初次接觸相似的問題，乍看之下確定會感受無從下手。

要把64個圓盤從a柱子移動到c柱子上，第一步應該怎麼作？雖然能夠確定，第一步惟一的選擇是移動a最上面的那個圓盤，可是應該將其移到b仍是c呢？很難肯定。由於接下來的第二步、第三步……直到最後一步，看起來都是很難肯定的。能當即肯定的是最後一步：最後一步的盤子確定也是a最上面那個圓盤，而且是由a或b移動到c——此前已經將63個圓盤移動到了c上。

也許你會說，管他呢，先隨便試着移動一下好了。若是你這麼作，你會發現，接下來你會面臨愈來愈多相似的選擇，對每個選擇都「試」一下的話，你會偏離正確的道路愈來愈遠，直到你發現你接下來沒法進行爲止。

若是將這個問題的盤子數量減爲10個或更少，就不會有太大的問題了。但盤子數量爲64的話，你一共須要移動約1800億億步（18,446,744,073,709,551,615），才能最終完成整個過程。這是一個天文數字，沒有人可以在有生之年經過手動的方式來完成它。即便藉助於計算機，假設計算機每秒可以移動100萬步，那麼約須要18萬億秒，即58萬年。將計算機的速度再提升1000倍，即每秒10億步，也須要584年纔可以完成。注：在個人筆記本電腦上，每秒大約可以移動6~8百萬步。

雖然64個盤子超出了人力和現代計算機的能力，但至少對於計算機來講，這不是一個沒法完成的任務，由於與咱們人類不一樣，計算機的能力在不斷提升。

 

分解問題

 

一股腦地考慮每一步如何移動很困難，咱們能夠換個思路。先假設除最下面的盤子以外，咱們已經成功地將上面的63個盤子移到了b柱，此時只要將最下面的盤子由a移動到c便可。如圖：

當最大的盤子由a移到c後，b上是餘下的63個盤子，a爲空。所以如今的目標就變成了將這63個盤子由b移到c。這個問題和原來的問題徹底同樣，只是由a柱換爲了b柱，規模由64變爲了63。所以能夠採用相同的方法，先將上面的62個盤子由b移到a，再將最下面的盤子移到c……對照下面的過程，試着是否能找到規律：

1. 將b柱子做爲輔助，把a上的63個圓盤移動到b上
2. 將a上最後一個圓盤移動到c
3. 將a做爲輔助，把b上的62個圓盤移動到a上
4. 將b上的最後一個圓盤移動到c
5. ......

也許你已經發現規律了，即每次都是先將其餘圓盤移動到輔助柱子上，並將最底下的圓盤移到c柱子上，而後再把原先的柱子做爲輔助柱子，並重復此過程。

這個過程稱爲遞歸，即定義一組基本操做，這組操做將規模小一點（或大一點）的操做當作一個總體——無需關心它的細節，只當它已經完成了——而後執行剩下的操做。而在更小或更大的規模中也依此操做，直到規模達到預約值。

在數學上，有些公式就是採用遞歸的方式定義的。例如階乘和斐波那契數列（Fibonacci Sequence）。前者的公式爲：

規定0!=1!=1，對於n>=2，有n!=n*(n-1)!

這裏的n-1就是比n規模略小的階乘，而1就是規模的最小值（預約值）（0是做爲特殊值而專門規定的）。

著名的斐波那契數列定義以下，能夠看出，f(n)是由規模更小一些的f(n-1)和f(n-2)推導出來的：

f(0)=0，f(1)=1
f(n)=f(n-1)+f(n-2) (n>=2)

所以，遞歸實際上就是用本身來定義本身。

回到前面漢諾塔的問題上來。咱們假設函數func(n, a, b, c)用於將n個圓盤由a移動到c，b做爲輔助柱子。那麼咱們能夠這樣實現這個遞歸過程：

func:
if n!=0 then            ;預約值
  func(n-1, a, c, b)    ;將n-1個盤子由a移動到b，以c爲輔助柱子（注意參數順序）
  move a[n] to c        ;將a上的最後一個盤子移動到c
  func(n-1, b, a, c)    ;將n-1個盤子由b移動到c，以a爲輔助柱子
endif                   ;完成

func中有兩個遞歸調用，它們的規模恰好比n小1。註釋說明了每行代碼的做用和意圖。正如註釋裏所強調的那樣，注意參數的順序——參數位置不一樣，其表明的意義也不同。

第一個遞歸調用以c做爲輔助柱子，這沒有問題，由於c柱子的最下面的k個圓盤必定是全部圓盤中最大的k個，所以將其做爲輔助柱子不會出現大圓盤在小圓盤之上的狀況。

 

程序實現

 

下面是使用Java實現的漢諾塔程序，程序使用Stack實例來保存每一個柱子上的盤子及它們的順序。Stack是隊列的一種，其中的元素遵循「先進先出」（FIFO）的原則，即不容許從隊尾取元素。這種隊列一般也稱爲「棧」。棧對元素的進出約定與漢諾塔的規則一致。

resolve方法用來移動盤子，參數n表示要移動的盤子的數量，a是盤子所在的柱子，b是輔助柱子，c是目標柱子。注意此方法會首先檢查參數n，當n爲0時直接返回，這就是前面所說的「預約值」。若是沒有對預約值的判斷，resolve的遞歸過程將不會天然終止，而是無限進行下去，直到塞滿系統內存堆棧而致使程序奔潰。

另外要注意的是程序將盤子的初始數量設爲32個，你能夠修改該值，但建議不要設置的過大，緣由正如前面所計算的那樣，若是採用64個圓盤，你將至少須要數百年才能看到結果（更可能的結果是因爲步數太多，系統沒有足夠的內存而致使程序奔潰）。

import java.util.Iterator;
import java.util.Stack;

public class HanoiTower {
      public static void print(Stack<Integer> s) {
            Iterator<Integer> i = s.iterator();
             while (i.hasNext()) {
                  System.out.printf("%d ", i.next());
            }
            System.out.println();
      }

      public static void resolve(int n, Stack<Integer> a, Stack<Integer> b, Stack<Integer> c) {
            if (n==0) return;
            resolve(n-1, a, c, b);
            c.push(a.pop());
            resolve(n-1, b, a, c);
      }

      public static void main(String[] args) {
            int count = 32;
            Stack<Integer> a = new Stack<Integer>();
            Stack<Integer> b = new Stack<Integer>();
            Stack<Integer> c = new Stack<Integer>();

            for (int i=count; i>0; i--) {
                 a.push(i);
            }

            print(a);
            long start = System.currentTimeMillis();
            resolve(count, a, b, c);
            long end = System.currentTimeMillis();
            print(c);

            System.out.println((end - start)/1000);
      }
}

 

在個人筆記本電腦上運行該程序，消耗的時間統計以下：（Intel Core i3 3.2GHz處理器，2.2GHz 3GB內存）

正如備註中所顯示的，步數是圓盤數量的指數函數，即steps=2^n - 1，運行所需時間也聽從這個規律。

擴展：漢諾塔問題的非遞歸實現

理論上來講，遞歸算法都可以改成循環來完成。例如階乘問題，既能夠用遞歸定義給出，也能夠採用下面的方式來定義：

規定0的階乘爲1。對於其餘天然數，n的階乘能夠表示爲：

n!=1*2*3*...*n

這種方式實際上就是採用了循環來定義。

然而，並非全部的遞歸都能簡單直觀地改寫爲循環，例如前面所介紹的斐波那契數列的定義，和本文所討論的漢諾塔問題。

下面這個帖子介紹了不使用遞歸而是用循環來解漢諾塔問題的算法。

http://tieba.baidu.com/f?kz=1255166419

程序框架

hanoi函數

TODO

研究如何使用並行算法解決漢諾塔問題。例如，64個盤子，每次成功將一個盤子移動到目標柱子上的過程都是獨立的。所以能夠分別並行地計算。不過須要注意的是，成功移動第一個盤子的步數是最多的，佔到總步數的1/2；而第二個盤子須要總步數的1/4……最後一個盤子僅需1步。因此在實現並行方式時要考慮這種差別。而不是簡單地使每一個並行分支移動相同數量的盤子。