漢諾塔問題

漢諾塔問題是一個經典的問題。漢諾塔（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步。
所以在實現並行方式時要考慮這種差異。而不是簡單地使每個並行分支移動相同數量的盤子。

 

 

Dijkstra算法_北京地鐵換乘_android實現-附帶源碼.apk

 

Dijkstra算法_北京地鐵換乘_android實現   android 2.2+ 

 

源碼下載    apk下載

 

直接上圖片 如下：

 

 

Dijkstra(迪傑斯特拉)算法是典型的最短路徑路由算法，用於計算一個節點到其他所有節點的最短路徑。主要特點是以起始點為中心向外層層擴展，直到擴展到終點為止。Dijkstra算法能得出最短路徑的最優解，但由於它遍歷計算的節點很多，所以效率低。

　　Dijkstra算法是很有代表性的最短路算法，在很多專業課程中都作為基本內容有詳細的介紹，如數據結構，圖論，運籌學等等。

其基本思想是，設置頂點集合S並不斷地作貪心選擇來擴充這個集合。一個頂點屬於集合S當且僅當從源到該頂點的最短路徑長度已知。

初始時，S中僅含有源。設u是G的某一個頂點，把從源到u且中間只經過S中頂點的路稱為從源到u的特殊路徑，並用數組dist記錄當前每個頂點所對應的最短特殊路徑長度。Dijkstra算法每次從V-S中取出具有最短特殊路長度的頂點u，將u添加到S中，同時對數組dist作必要的修改。一旦S包含了所有V中頂點，dist就記錄了從源到所有其它頂點之間的最短路徑長度。

 

 

/**時間復雜度比較復雜，因為換乘結點的關系導致的 
    最壞情況下(每個站之間都有連線，但是地鐵線路圖實際上是不存在次情況的):O(2^n)
    相反
    最優情況下(之間只有唯一的連接點,次情況下也不是很現實的，有的地鐵換乘是多個換乘點都在同一條線上的)
    此時用hashtable所以是:O(1)
    */
    private java.util.HashSet<String> GetF(java.util.HashSet<String> beginlist)
    {
        if (mainht == null || mainht.isEmpty())
        {
            return null;
        }
        returnlist = new java.util.HashSet<String>();
        
        if (beginlist.isEmpty())
        {
            isend = 1;
        }
        else
        {
            /**O(n)
            */
            for (String strbegin : beginlist)
            {
                if (strbegin.indexOf("-") == -1 && mainht.containsKey(strbegin) == true) //have this key and first load data
                {
                    bxy = (double[])DCht.get(strbegin);
                    earry = mainht.get(strbegin).toString().split("[,]", -1);
                    for (String ar : earry)
                    {
                        exy = (double[])DCht.get(ar);
                        isadd = CK(isadd, bxy, exy);

                        if (isadd == true)
                        {
                            returnlist.add(strbegin + "-" + ar);
                            isend = 0;
                        }
                    }
                }
                else if (strbegin.indexOf("-") > -1 && mainht.containsKey(strbegin.substring(strbegin.lastIndexOf("-") + 1)) == true)
                {
                    temgstr = strbegin.substring(strbegin.lastIndexOf("-") + 1);
                    bxy = (double[])DCht.get(temgstr);
                    earry = mainht.get(temgstr).toString().split("[,]", -1); //exchange node
                    for (String ar : earry)
                    {
                        exy = (double[])DCht.get(ar);
                        isadd = CK(isadd, bxy, exy);

                        if (isadd == true)
                        {
                            if (!strbegin.contains(ar))
                            {
                                returnlist.add(strbegin + "-" + ar);
                            }
                            isend = 0;
                        }
                    }
                }

            }
        }
        
        earry = null;
        if (isend == 0)
        {
            return GetF(returnlist);
        }
        else
        {
            return null;
        }
    }

 

 

?

    //East South West North Northeast Northwest Southeast Southwest

private  boolean  CK( boolean  isadd, double [] bxy, double [] exy)

{

     return  true ;

}

　　

 

整個查詢過程耗時不超過20毫秒    

 

 

 

單源最短路徑問題，即在圖中求出給定頂點到其它任一頂點的最短路徑。在弄清楚如何求算單源最短路徑問題之前，必須弄清楚最短路徑的最優子結構性質。

一.最短路徑的最優子結構性質

   該性質描述為：如果P(i,j)={Vi....Vk..Vs...Vj}是從頂點i到j的最短路徑，k和s是這條路徑上的一個中間頂點，那么P(k,s)必定是從k到s的最短路徑。下面證明該性質的正確性。

   假設P(i,j)={Vi....Vk..Vs...Vj}是從頂點i到j的最短路徑，則有P(i,j)=P(i,k)+P(k,s)+P(s,j)。而P(k,s)不是從k到s的最短距離，那么必定存在另一條從k到s的最短路徑P'(k,s)，那么P'(i,j)=P(i,k)+P'(k,s)+P(s,j)<P(i,j)。則與P(i,j)是從i到j的最短路徑相矛盾。因此該性質得證。

二.Dijkstra算法

   由上述性質可知，如果存在一條從i到j的最短路徑(Vi.....Vk,Vj)，Vk是Vj前面的一頂點。那么(Vi...Vk)也必定是從i到k的最短路徑。為了求出最短路徑，Dijkstra就提出了以最短路徑長度遞增，逐次生成最短路徑的算法。譬如對於源頂點V0，首先選擇其直接相鄰的頂點中長度最短的頂點Vi，那么當前已知可得從V0到達Vj頂點的最短距離dist[j]=min{dist[j],dist[i]+matrix[i][j]}。根據這種思路，

假設存在G=<V,E>，源頂點為V0，U={V0},dist[i]記錄V0到i的最短距離，path[i]記錄從V0到i路徑上的i前面的一個頂點。

1.從V-U中選擇使dist[i]值最小的頂點i，將i加入到U中；

2.更新與i直接相鄰頂點的dist值。(dist[j]=min{dist[j],dist[i]+matrix[i][j]})

3.知道U=V，停止。

 

 

 

 

分類:  1程序1世界