漢諾塔演算法的流程圖

A. 漢諾塔流程圖

你好！

漢諾塔流程圖：

voidmove(int,char,char,char);/*聲明函數,告訴系統我隨後要定義一個函數,他不對其中參數進行檢查,所以可以省略參數,一般只寫類型,表示有多少個什麼類型的參數,便於自己理解*/

main()

{intn;

printf("請輸入盤數n=");

scanf("%d",&n);

printf("在3根柱子上移%d只盤的步驟為: ",n);

move(n,'a','b','c');}/*函數調用,用a,b,c代表3跟柱子,把盤子數,柱子代碼傳給函數*/

voidmove(intm,charp,charq,charr)//定義函數

{if(m==1)

{printf("[%d]move1#from%cto%c ",step,p,r);

step=step+1;}

else{move(m-1,p,r,q);//調用本身函數,進行遞歸A

printf("[%d]move%d#from%cto%c ",step,m,p,r);

step=step+1;

move(m-1,q,p,r);//再次調用B

}

getch();}

遞歸其實是嵌套調用,

所謂嵌套調用,就是在一個函數里調用另一個函數,

main函數不能被調用的,

所以遞歸就是有限次的嵌套調用本身函數

每次調用,系統都會重新分配內存,

返回時就返回上次調用他的那塊內存中的調用函數處,

這樣理解應該很簡單了

漢諾塔流程圖解析：

這裡面的遞歸涉及一個漢諾塔的演算法問題,具體講明白的話有點麻煩,總體思路是假設盤子全在a柱上,想放到c上

第N個人就想要是有人搬動其他N-1個盤子到b,那他只要搬一次從a到c就可以,在讓那個人把N-1個盤子放到c上

第N-1那個人就想要是有人搬動其他N-2個盤子到c,他只要搬動一次從a到b就可以,在讓那個人把N-2個盤子放到b上

....

第1個人就直接把盤子從a到c

這樣形成遞歸

我在倆處調用標記了A,B,我寫出步躊,你看看.

假設3個盤子

A函數相當於雙重循環中的外層循環

B函數相當於雙重循環中的內層循環

1,主函數調用,p=a,q=b,r=c,m=3,運行A,調用本身(A第一次調用)傳入p,r,q(a,c,b)注意調用函數中p,r,q排列

2,被調函數是用p,q,r的順序接收傳入的p,r,q.p=a,q=c,r=b,m=2,執行A,調用本身(A第二次調用)調用傳入p,r,q(a,b,c)

3,p=a,q=b,r=c,m=1,執行if,輸出a->c,返回A第二次調用

4,本次函數中p=a,q=c,r=b,m=2,向下執行,輸出a->b,執行B,調用本身(B第一次調用),傳入q,p,r(c,a,b),m=1

5,p=c,q=a,r=b,m=1,執行if,輸出c->b,返回B第一次調用

6,向下執行,執行完畢,返回A第一次調用

7,本次函數中p=a,q=b,r=c,m=3,向下執行,輸出a->c,執行B,調用本身(B第一次調用),傳入q,p,r(b,a,c),m=2

8,p=b,q=a,r=c,m=2,執行A,調用本身(A'第一次調用,注意是B函數調用中再次調用A)傳入p,r,q(b,c,a)

9,p=b,q=c,r=a,m=1,執行if,輸出b->a,返回A'第一次調用

10,本次函數中p=b,q=a,r=c,m=2向下執行,輸出b->c,執行B,調用本身(B'的第一次調用,注意是B函數中再次調用B)傳入q,p,r(a,b,c),m=1

11,p=a,q=b,r=c,m=1,執行if,輸出a->c返回B'第一次調用

12,向下執行,執行完畢,返回B第一次調用

13,向下執行,執行完畢,返回主函數

仔細分析每次調用時當前變數p,q,r中所代表的a,b,c,每次調用時,p,q,r都是新的變數

我看了你的問題，估計你把調用函數中的p,q,r變數與被調函數中p,q,r變數搞混了

/*

4,向下執行,執行B,調用本身(B第一次調用),由於本次函數中p=a,q=c,r=b,m=2,先輸出a->b,再傳入q=c,p=a,r=b,m=1

這里不是[4]move3#fromatoc嗎

*/

注意調用傳入的順序是q,p,r,傳入的值是c,a,b的順序，被調函數中是拿p,q,r的順序在接收，所以被調函數中值的順序就該是p=c,q=a,r=b,執行if就輸出c->b

補充：流程圖步驟畫了好久額，有什麼疑問發我郵箱[email protected]

B. 漢諾塔該怎麼玩，方法

漢諾塔演算法介紹：

一位美國學者發現的特別簡單的方法：只要輪流用兩次如下方法就可以了。

把三根柱子按順序排成「品」字型，把所有圓盤按從大到小的順序放於柱子A上，根據圓盤數量來確定柱子排放的順序：

n若為偶數的話，順時針方向依次擺放為：ABC；而n若為奇數的話，就按順時針方向依次擺放為：ACB。這樣經過反復多次的測試，最後就可以按照規定完成漢諾塔的移動。

因此很簡單的，結果就是按照移動規則向一個方向移動金片：

如3階漢諾塔的移動：A→C,A→B,C→B,A→C,B→A,B→C,A→C。

(2)漢諾塔演算法的流程圖擴展閱讀：

漢諾塔經典題目：

三根相鄰的柱子，標號為A,B,C，A柱子上從下到上按金字塔狀疊放著n個不同大小的圓盤，要把所有盤子一個一個移動到柱子B上，且每次移動同一根柱子上都不可以出現大盤子在小盤子上方的情況。

至少需要幾次移動的問題，我們設移動次數為H(n）。

把上面n-1個盤子移動到柱子C上，把最大的一塊放在B上，把C上的所有盤子移動到B上，由此我們得出表達式：

H⑴ = 1

H(n) = 2*H(n-1）+1 (n>1）

很快我們就可以得到H(n）的一般式為：

H(n) = 2^n - 1 (n>0)

且這種方法的確是最少次數的，證明非常簡單，可以嘗試從2個盤子的移動開始證，可以試試。

進一步加深問題：

假如現在每種大小的盤子都有兩個，並且是相鄰的，設盤子個數為2n，問：⑴假如不考慮相同大小盤子的上下要幾次移動，設移動次數為J(n）；⑵只要保證到最後B上的相同大小盤子順序與A上時相同，需要幾次移動，設移動次數為K(n）。

⑴中的移動相當於是把前一個問題中的每個盤子多移動一次，也就是：

J(n) = 2*H(n) = 2*（2^n - 1） = 2^(n+1）-2

在分析⑵之前，我們來說明一個現象，假如A柱子上有兩個大小相同的盤子，上面一個是黑色的，下面一個是白色的，我們把兩個盤子移動到B上，需要兩次。

盤子順序將變成黑的在下，白的在上，然後再把B上的盤子移動到C上，需要兩次，盤子順序將與A上時相同，由此我們歸納出當相鄰兩個盤子都移動偶數次時，盤子順序將不變，否則上下顛倒。

回到最開始的問題，n個盤子移動，上方的n-1個盤子總移動次數為2*H(n-1），所以上方n-1個盤子的移動次數必定為偶數次，最後一個盤子移動次數為1次。

討論問題⑵：

綜上可以得出，要把A上2n個盤子移動到B上，可以得出上方的2n-2個盤子必定移動偶數次，所以順序不變，移動次數為：

J(n-1） = 2^n-2

然後再移動倒數第二個盤子，移動次數為2*J(n-1）+1 = 2^(n+1）-3，

最後移動最底下一個盤子，所以總的移動次數為：

K(n) = 2*（2*J(n-1）+1）+1 = 2*（2^(n+1）-3）+1 = 2^(n+2）-5

C. 漢諾塔問題

漢諾塔（又稱河內塔）問題是印度的一個古老的傳說。開天闢地的神勃拉瑪在一個廟里留下了三根金剛石的棒，第一根上面套著64個圓的金片，最大的一個在底下，其餘一個比一個小，依次疊上去，廟里的眾僧不倦地把它們一個個地從這根棒搬到另一根棒上，規定可利用中間的一根棒作為幫助，但每次只能搬一個，而且大的不能放在小的上面。解答結果請自己運行計算，程序見尾部。面對龐大的數字(移動圓片的次數)18446744073709551615，看來，眾僧們耗盡畢生精力也不可能完成金片的移動。

後來，這個傳說就演變為漢諾塔游戲:

1.有三根桿子A,B,C。A桿上有若干碟子
2.每次移動一塊碟子,小的只能疊在大的上面
3.把所有碟子從A桿全部移到C桿上

經過研究發現，漢諾塔的破解很簡單，就是按照移動規則向一個方向移動金片：
如3階漢諾塔的移動：A→C,A→B,C→B,A→C,B→A,B→C,A→C

此外，漢諾塔問題也是程序設計中的經典遞歸問題。

演算法思路：
1.如果只有一個金片，則把該金片從源移動到目標棒，結束。
2.如果有n個金片，則把前n-1個金片移動到輔助的棒，然後把自己移動到目標棒，最後再把前n-1個移動到目標棒

(非專業人士可以忽略以下內容)

補充：漢諾塔的演算法實現（c++）
#include <fstream>
#include <iostream>
using namespace std;

ofstream fout("out.txt");

void Move(int n,char x,char y)
{
fout<<"把"<<n<<"號從"<<x<<"挪動到"<<y<<endl;
}

void Hannoi(int n,char a,char b,char c)
{
if(n==1)
Move(1,a,c);
else
{
Hannoi(n-1,a,c,b);
Move(n,a,c);
Hannoi(n-1,b,a,c);
}
}

int main()
{
fout<<"以下是7層漢諾塔的解法:"<<endl;
Hannoi(7,'a','b','c');
fout.close();
cout<<"輸出完畢！"<<endl;
return 0;
}

C語言精簡演算法
/* Copyrighter by SS7E */
#include<stdio.h> /* Copyrighter by SS7E */
void hanoi(int n,char A,char B,char C) /* Copyrighter by SS7E */
{
if(n==1)
{
printf("Move disk %d from %c to %c\n",n,A,C);
}
else
{
hanoi(n-1,A,C,B); /* Copyrighter by SS7E */
printf("Move disk %d from %c to %c\n",n,A,C);
hanoi(n-1,B,A,C); /* Copyrighter by SS7E */
}
}
main() /* Copyrighter by SS7E */
{
int n;
printf("請輸入數字n以解決n階漢諾塔問題：\n");
scanf("%d",&n);
hanoi(n,'A','B','C');
}/* Copyrighter by SS7E */

php演算法：
<?php
function hanoi($n,$x,$y,$z){
if($n==1){
move($x,1,$z);
}else{
hanoi($n-1,$x,$z,$y);
move($x,$n,$z);
hanoi($n-1,$y,$x,$z);
}
}
function move($x,$n,$z){
echo 'move disk '.$n.' from '.$x.' to '.$z.'<br>';
}
hanoi(10,'x','y','z');
?>
java演算法：
public class Haniojava
{
public static void main(String args[])
{
byte n=2;
char a='A',b='B',c='C';
hanio(n,a,b,c);
}
public static void hanio(byte n,char a,char b,char c)
{
if(n==1)
System.out.println("move "+a+" to "+b);
else
{
hanio((byte)(n-1),a,c,b);
System.out.println("move "+a+" to "+b);
hanio((byte)(n-1),c,b,a);
}
}
}

#include<iostream.h>

void move(char ch1, char ch2) {
cout<<ch1<<"->"<<ch2<<' ';
}

void hanoi(int n, char a, char b, char c) {
if (n==1)
move (a,c);
else {
hanoi (n-1,a,c,b);
move (a,c);
hanoi (n-1,b,a,c);
}
}

void main() {
int m;
cout<<"Enter the number of disk to move:\n";
cin>>m;
cout<<"The step to moving "<<m<<" disk:\n";
hanoi (m,'A','B','C');
cin>>m;
}

用不了這么復雜
，設A上有n個盤子。
如果n=1，則將圓盤從A直接移動到C。
如果n=2，則：
1.將A上的n-1(等於1)個圓盤移到B上；
2.再將A上的一個圓盤移到C上；
3.最後將B上的n-1(等於1)個圓盤移到C上。
如果n=3，則：
A. 將A上的n-1(等於2，令其為n`)個圓盤移到B(藉助於C)，步驟如下：
(1)將A上的n`-1(等於1)個圓盤移到C上。
(2)將A上的一個圓盤移到B。
(3)將C上的n`-1(等於1)個圓盤移到B。
B. 將A上的一個圓盤移到C。
C. 將B上的n-1(等於2，令其為n`)個圓盤移到C(藉助A)，步驟如下：
(1)將B上的n`-1(等於1)個圓盤移到A。
(2)將B上的一個盤子移到C。
(3)將A上的n`-1(等於1)個圓盤移到C。
到此，完成了三個圓盤的移動過程。
從上面分析可以看出，當n大於等於2時，移動的過程可分解為三個步驟：
第一步 把A上的n-1個圓盤移到B上；
第二步 把A上的一個圓盤移到C上；
第三步 把B上的n-1個圓盤移到C上；其中第一步和第三步是類同的。
當n=3時，第一步和第三步又分解為類同的三步，即把n`-1個圓盤從一個針移到另一個針上，這里的n`=n-1。 顯然這是一個遞歸過程，據此演算法可編程如下：
move(int n,int x,int y,int z)
{
if(n==1)
printf("%c-->%c\n",x,z);
else
{
move(n-1,x,z,y);
printf("%c-->%c\n",x,z);
move(n-1,y,x,z);
}
}
main()
{
int h;
printf("\ninput number:\n");
scanf("%d",&h);
printf("the step to moving %2d diskes:\n",h);
move(h,'a','b','c');
}

D. 漢諾塔的演算法

演算法介紹：當盤子的個數為n時，移動的次數應等於2^n–1。後來一位美國學者發現一種出人意料的簡單方法，只要輪流進行兩步操作就可以了。首先把三根柱子按順序排成品字型，把所有的圓盤按從大到小的順序放在柱子A上，根據圓盤的數量確定柱子的排放順序：若n為偶數，按順時針方向依次擺放A、B、C；

若n為奇數，按順時針方向依次擺放A、C、B。

所以結果非常簡單，就是按照移動規則向一個方向移動金片：如3階漢諾塔的移動：A→C,A→B,C→B,A→C,B→A,B→C,A→C

漢諾塔問題也是程序設計中的經典遞歸問題。

(4)漢諾塔演算法的流程圖擴展閱讀

由來：

法國數學家愛德華·盧卡斯曾編寫過一個印度的古老傳說：在世界中心貝拿勒斯（在印度北部）的聖廟里，一塊黃銅板上插著三根寶石針。印度教的主神梵天在創造世界的時候，在其中一根針上從下到上地穿好了由大到小的64片金片，這就是所謂的漢諾塔。

不論白天黑夜，總有一個僧侶在按照下面的法則移動這些金片：一次只移動一片，不管在哪根針上，小片必須在大片上面。僧侶們預言，當所有的金片都從梵天穿好的那根針上移到另外一根針上時，世界就將在一聲霹靂中消滅，而梵塔、廟宇和眾生也都將同歸於盡。

不管這個傳說的可信度有多大，如果考慮一下把64片金片，由一根針上移到另一根針上，並且始終保持上小下大的順序。這需要多少次移動呢?這里需要遞歸的方法。假設有n片，移動次數是f(n).顯然f(1)=1,f(2)=3,f(3)=7，且f(k+1)=2*f(k)+1。此後不難證明f(n)=2^n-1。n=64時，

假如每秒鍾一次，共需多長時間呢？一個平年365天有31536000 秒，閏年366天有31622400秒，平均每年31556952秒，計算一下：18446744073709551615秒。

這表明移完這些金片需要5845.54億年以上，而地球存在至今不過45億年，太陽系的預期壽命據說也就是數百億年。真的過了5845.54億年，不說太陽系和銀河系，至少地球上的一切生命，連同梵塔、廟宇等，都早已經灰飛煙滅。

E. C語言漢諾塔問題，請問這個n=3的詳細步驟是什麼呀，大一新生沒聽懂

這是漢諾塔的演算法的問題。程序本身很簡單。

漢諾塔（又稱河內塔）問題是源於印度一個古老傳說的益智玩具。大梵天創造世界的時候做了三根金剛石柱子，在一根柱子上從下往上按照大小順序摞著64片黃金圓盤。大梵天命令婆羅門把圓盤從下面開始按大小順序重新擺放在另一根柱子上。並且規定，在小圓盤上不能放大圓盤，在三根柱子之間一次只能移動一個圓盤。

這個主要是看演算法，再一個就是遞歸的學習，程序本身非常簡單。

F. 漢諾塔問題的遞歸演算法流程圖

關鍵是第一步移法，奇數層的說，3層在第一柱，後兩根柱數數：123。所以，第一塊應放在第二根柱，4層，第一塊放第三柱。...........奇數層第一塊放第二柱，偶數層第一塊放第三柱。

G. 求漢諾塔遞歸全過程的演算法詳解圖，記得一定要是圖釋哦！！！

圖解是什麼意思呀。
這個演算法 那麼簡單沒必要搞得那麼復雜吧。
an = an-1 + 1;
你明白這個等式的意義嗎？
這個等式已經包含了遞歸演算法的全部含義。

an 表示 n個數的和，an-1 表示n-1個數的和 ，an = an-1 + 1;表示n個數的和可以通過n-1個數的和來求的。
上述說明哪些情況可以使用遞歸呢？
那就是：已知前一個步驟可以求得後一個步驟的結果的情況，並且前一個步驟和後一個步驟是有規律過度的。
比如漢諾塔問題：
移n個盤是已移n-1個盤為條件的，兩者的共同點是移盤。所以可以用f（n）表示移n個盤，f(n-1)表示移n-1個盤，那麼移n個盤和移n-1個盤有什麼關系呢？
這就需要預先分析問題才能得出具體的關系
在這個問題中，把n個盤從a移到c需要三個步驟來完成。
1.n-1個盤從a移到b
2 1個盤從a移到c
3 n-1個盤從b移到c
已知n-1個盤從a移到b是可行的，為什麼？
因為移1個盤是可行，那麼移2個盤也是可行，移 3個盤是已移2個盤為條件的，所以移3個盤也是可行的，所以移n個 盤是可行的。
所以根據已知條件可以解得：
設f(n, a, b,c) 表示 把n個盤從a移到c 藉助b --------------------------這里很關鍵，這是搞懂遞歸的關鍵關鍵。
那麼把n-1個盤從a移到b 藉助c 怎樣表示呢？
很明顯是：f(n-1, a, c,b)
那麼把1個盤從a移到c怎樣表示呢?
很明顯是：f(1, a, b,c)
那麼把n-1個盤從b移到c 藉助a 怎樣表示呢？
很明顯是：f(n-1, b, a,c)

所以f(n, a, b,c) = ( f(n-1, a,c,b) , f(1, a, b,c), f(n-1, b,a,c))
這和等差等比數列一個原理。
沒有什麼 特別的。

記住是問題有這樣遞推關系才可以使用這種方法。
如果要你計算1+2+8+22 的結果 你就不能使用遞歸。
因為該問題的後一步驟與前一步驟不具有規律性，所以已知前一個步驟並不能求的後一個步驟的值
1+2+3+4 ...+
這個問題就可以使用遞歸
原因你懂了吧。
至於爬樓梯問題，無限級分類 問題等一些遞歸問題，那不過時小菜一碟。
一句話：後一步驟依賴前一步驟並且二者聯系具有規律性，運用遞歸必然成功。

H. 漢諾塔遞歸演算法是什麼

如下：

1、漢諾塔（又稱河內塔）問題是源於印度一個古老傳說的益智玩具。大梵天創造世界的時候做了三根金剛石柱子，在一根柱子上從下往上按照大小順序摞著64片黃金圓盤。

大梵天命令婆羅門把圓盤從下面開始按大小順序重新擺放在另一根柱子上。並且規定，在小圓盤上不能放大圓盤，在三根柱子之間一次只能移動一個圓盤。

2、抽象為數學問題：從左到右有A、B、C三根柱子，其中A柱子上面有從小疊到大的n個圓盤，現要求將A柱子上的圓盤移到C柱子上去，期間只有一個原則：一次只能移到一個盤子且大盤子不能在小盤子上面，求移動的步驟和移動的次數。

演算法分析（遞歸演算法）：

實現這個演算法可以簡單分為三個步驟：把n-1個盤子由A 移到 B；把第n個盤子由 A移到 C；把n-1個盤子由B 移到 C。從這里入手，在加上上面數學問題解法的分析，我們不難發現，移到的步數必定為奇數步。

1、中間的一步是把最大的一個盤子由A移到C上去。

2、中間一步之上可以看成把A上n-1個盤子通過藉助輔助塔（C塔）移到了B上。

3、中間一步之下可以看成把B上n-1個盤子通過藉助輔助塔（A塔）移到了C上。

I. 求七塊漢諾塔完成所需步驟（不要編程，只要步驟

七塊漢諾塔完成所需步驟如下：用1到7表示七個漢諾塔圓盤，圓盤半徑默認為1<2<3<4<5<6<7；以ABC表示漢諾塔的三個柱子，A為最左，B為中間，C為最右；

1—C表示把1號圓盤移動到第三個柱子上，以此類推：

一、1—C；2—B；1—B；3—C；1—A；2—C；1—C；4—B；1—B；2—A；

二、1—A；3—B；1—C；2—B；1—C；5—C；1—A；2—C；1—C；3—A；

三、1—B；2—A；1—A；4—C；1—C；2—B；1—B；3—C；1—A；2—C；

四、1—C；6—B；1—B；2—A；1—A；3—B；1—C；2—B；1—B；4—A；

五、1—A；2—C；1—C；3—A；1—B；2—A；1—A；5—C；1—C；2—B；

六、1—B；3—C；1—A；2—C；1—C；4—B；1—B；2—A；1—A；3—B；

七、1—C；2—B；1—B；7—C；1—A；2—C；1—C；3—A；1—B；2—A；

八、1—A；4—C；1—C；2—B；1—B；3—C；1—A；2—C；1—C；5—A；

九、1—B；2—A；1—A；3—B；1—C；2—B；1—B；4—A；1—A；2—C；

十、1—C；3—A；1—B；2—A；1—A；6—C；1—C；2—B；1—B；3—C；

十一、1—A；2—C；1—C；4—B；1—B；2—A；1—A；3—B；1—C；2—B；

十二、1—B；5—C；1—A；2—C；1—C；3—A；1—B；2—A；1—A；4—C；

十三、1—C；2—B；1—B；3—C；1—A；2—C；1—C；

(9)漢諾塔演算法的流程圖擴展閱讀：

漢諾塔的演算法介紹

其實演算法非常簡單，當盤子的個數為n時，移動的次數應等於2^n – 1（有興趣的可以自己證明試試看）。後來一位美國學者發現一種出人意料的簡單方法，只要輪流進行兩步操作就可以了。首先把三根柱子按順序排成品字型，把所有的圓盤按從大到小的順序放在柱子A上，根據圓盤的數量確定柱子的排放順序：若n為偶數，按順時針方向依次擺放 A B C；

若n為奇數，按順時針方向依次擺放 A C B。

⑴按順時針方向把圓盤1從現在的柱子移動到下一根柱子，即當n為偶數時，若圓盤1在柱子A，則把它移動到B；若圓盤1在柱子B，則把它移動到C；若圓盤1在柱子C，則把它移動到A。

⑵接著，把另外兩根柱子上可以移動的圓盤移動到新的柱子上。即把非空柱子上的圓盤移動到空柱子上，當兩根柱子都非空時，移動較大的圓盤。

這一步沒有明確規定移動哪個圓盤，你可能以為會有多種可能性，其實不然，可實施的行動是唯一的。

⑶反復進行⑴⑵操作，最後就能按規定完成漢諾塔的移動。

所以結果非常簡單，就是按照移動規則向一個方向移動金片：

如3階漢諾塔的移動：A→C,A→B,C→B,A→C,B→A,B→C,A→C

(9)漢諾塔演算法的流程圖擴展閱讀來源：網路-漢諾塔-演算法介紹

J. 漢諾塔遞歸演算法是什麼

漢諾塔問題實際上就是要將柱子A上由小到大排列的圓環按照相同的大小順序移動到柱子C，之間的過程可以使用柱子B。

其遞歸的歸納思想是這樣的：

（1）首先，當只有一個盤子的時候只需要將A上的1號盤子移動到C上就行了

（2）當有2個盤子在A上的時候，需要將A上的1號盤子（由上往下數）移動到B上，再將A上的2號盤子移動到C上，之後將B上的1號盤子移動到C上

（3）當有3個盤子在A上的時候，需要將A上的1號和2號盤子移動到B上（需要藉助C），之後將A上的3號盤子移動到C上，再將B上的盤子移動到C上（需要藉助A）

（...）以此類推

（N）當有N個盤子在A上的時候，需要將A上的N-1個盤子移動到B上（需要藉助C），之後將A上的第N個盤子移動到C上，再將B上的盤子移動到C上（需要藉助A）

起源

漢諾塔（又稱河內塔）問題是源於印度一個古老傳說的益智玩具。大梵天創造世界的時候做了三根金剛石柱子，在一根柱子上從下往上按照大小順序摞著64片黃金圓盤。

大梵天命令婆羅門把圓盤從下面開始按大小順序重新擺放在另一根柱子上。並且規定，在小圓盤上不能放大圓盤，在三根柱子之間一次只能移動一個圓盤。