汉诺塔问题..txt - 记事本
汉诺塔问题数学解法
汉诺塔问题数学解法汉诺塔问题是一个经典的数学难题，也是计算机科学中的常见算法题目。
在这个问题中，我们需要将三个塔座上的圆盘按照一定规则从一座塔移动到另一座塔，只能每次移动一个圆盘，并且在移动过程中始终保持大圆盘在小圆盘下面。
为了解决汉诺塔问题，我们首先需要了解递归的概念。
递归是一种问题解决方法，其中问题被分解为更小的子问题，直到最小的问题可以直接解决。
在汉诺塔问题中，我们可以使用递归来实现移动圆盘的步骤。
设有三个塔座，分别为A、B、C，并且初始时所有的圆盘都在A 塔上，我们的目标是将所有的圆盘移动到C塔上。
为了方便讨论，我们将最小的圆盘称为第1号圆盘，次小的圆盘称为第2号圆盘，以此类推，最大的圆盘称为第n号圆盘。
解决汉诺塔问题的数学解法如下：1. 当只有一个圆盘时，直接将它从A塔移动到C塔，移动结束。
2. 当有两个或以上的圆盘时，可以按照以下步骤进行移动：(1) 先将上面n-1个圆盘从A塔移动到B塔（借助C塔）。
(2) 将第n号圆盘从A塔移动到C塔。
(3) 最后将n-1个圆盘从B塔移动到C塔（借助A塔）。
通过以上步骤，我们可以将n个圆盘从A塔移动到C塔，完成整个汉诺塔问题的解。
这个数学解法的正确性可以通过递归的思想来解释。
当有n个圆盘时，我们需要借助第三个塔座将前n-1个圆盘移动到B塔上，然后将第n号圆盘移动到C塔上，最后再将n-1个圆盘从B塔移动到C塔上。
这个过程可以看作是一个递归过程，我们首先需要将前n-1个圆盘从A 塔移动到B塔上，然后再将第n号圆盘从A塔移动到C塔上，最后再将n-1个圆盘从B塔移动到C塔上。
通过不断缩小问题规模，我们最终可以将整个汉诺塔问题解决。
总结起来，汉诺塔问题是一个经典的数学难题，解决这个问题可以使用递归的数学解法。
通过将问题分解为更小的子问题，我们可以将n 个圆盘从一座塔移动到另一座塔上。
这个数学解法的正确性可以通过递归的思想来解释。
希望通过以上的介绍，您对汉诺塔问题的数学解法有了更深入的理解。
深入浅出学算法021-汉诺塔问题
深入浅出学算法021-汉诺塔问题汉诺塔问题是一个传统的数学问题，也是一个经典的递归问题。
它是基于以下几个规则：1. 有三根柱子，分别是A、B、C，开始时A柱上有n个从小到大叠放的圆盘。
2. 每次只能移动一个圆盘。
3. 大圆盘不能放在小圆盘上面。
目标是将A柱上的圆盘全部移动到C柱上，可以利用B柱作为辅助。
解决这个问题的一种方法是使用递归。
下面是求解汉诺塔问题的算法步骤：1. 如果只有一个圆盘，直接从A柱移动到C柱。
2. 如果有n个圆盘，可以将问题分解为三个步骤：- 将n-1个圆盘从A柱移动到B柱，可以借助C柱作为辅助。
- 将最大的圆盘从A柱移动到C柱。
- 将n-1个圆盘从B柱移动到C柱，可以借助A柱作为辅助。
递归地应用这个步骤，就可以解决任意数量的圆盘移动问题。
下面是用Python实现汉诺塔问题的代码：```pythondef hanoi(n, A, B, C):if n == 1:print("Move disk", n, "from", A, "to", C)else:hanoi(n-1, A, C, B)print("Move disk", n, "from", A, "to", C)hanoi(n-1, B, A, C)n = int(input("Enter the number of disks: "))hanoi(n, 'A', 'B', 'C')```以上代码中，`hanoi`函数接受四个参数：n表示圆盘的数量，A、B、C分别表示三根柱子的名称。
函数根据递归算法进行移动，并输出每一步的操作。
运行程序，输入圆盘的数量，即可看到详细的移动步骤。
汉诺塔问题
盐城工学院C++课程设计二级学院:信息学院班级:姓名:学号:指导老师:1．报告简介1．1 汉诺塔问题简介在印度，有这么一个古老的传说：在世界中心贝拿勒斯（在印度北部）的圣庙里，一块黄铜板上插着三根宝石针。
印度教的主神梵天在创造世界的时候，在其中一根针上从下到上地穿好了由大到小的64片金片，这就是所谓的汉诺塔（如下图）。
不论白天黑夜，总有一个僧侣在按照下面的法则移动这些金片：一次只移动一片，不管在哪根针上，小片必在大片上面。
当所有的金片都从梵天穿好的那根针上移到另外一根针上时，世界就将在一声霹雳中消灭，梵塔、庙宇和众生都将同归于尽。
故汉诺塔问题又被称为“世界末日问题。
”图1-11．2 问题思想解决为满足题目中盘子的移动问题，必须遵循的条件是：一次仅能移动一个盘，且不允许大盘放在小盘的上面。
设要解决的汉诺塔共有N个圆盘，对A杆上的全部N个圆盘从小到大顺序编号，最小的圆盘为1号，次之为2号，依次类推，则最下面的圆盘的编号为N。
第一步：先将问题简化。
假设A杆上只有一个圆盘，即汉诺塔只有一层N，则只要将1号盘从A杆上移到B杆上即可。
第二步：对于一个有N（N>1）个圆盘的汉诺塔，将N个圆盘分成两部分：“上面的N-1个圆盘”看成一个整体，为了解决N个圆盘的汉诺塔，可以按下面图示的方式进行操作：（1）将A杆上面的N-1个盘子，借助B杆，移到C杆上；图1-2（2）将A杆上剩余的N号盘子移到B杆上；图1-3（3）将C杆上的N-1个盘子，借助A杆，移到B杆上。
图 1-41．3 预期目标运行程序后，首先显示：图 1-5选择 1 后，要求输入盘子的数目，即N输入后，显示递归调用时盘子移动的过程图 1-6继续选择 2 ，要求输入盘子的数目，即P输入后，显示非递归调用时盘子移动过程。
图 1-72．需求分析编写汉诺塔程序用到的知识有：符号常量的定义，循环语句，函数，栈与应用；2．1 符号常量的定义常量就是在程序运行过程中其值不发生变化的量。
汉诺塔算法题
汉诺塔算法题可以这样解答：汉诺塔是一个经典的算法问题，它的目标是把所有的盘子从源柱子移动到目标柱子上，并且在移动过程中要遵守一些规则：不能把比下面的盘子大的盘子放在比它小的盘子上面。
算法的基本思想是使用递归方法，将问题分解为更小的子问题，直到达到基本情况（只有一个盘子或没有盘子），然后将这些子问题的解决方案组合起来得到最终的解决方案。
具体来说，我们可以使用三个柱子来模拟汉诺塔，将问题分解为三个步骤：1. 将源柱子上的所有盘子移动到辅助柱子上（如果辅助柱子不够大，则使用第三步将辅助柱子上的盘子移动到目标柱子上）；2. 将源柱子上的空盘子移动到目标柱子上；3. 将辅助柱子上的所有盘子移动到目标柱子上。
如果用Python来实现汉诺塔算法，可以使用递归的方法：```pythondef hanoi(n, source, helper, target):if n > 0:# 将前n-1个盘子从源柱子移动到辅助柱子hanoi(n-1, source, target, helper)# 将第n个盘子从源柱子移动到目标柱子print(f'Move disk {n} from {source} to {target}')# 将前n-1个盘子从辅助柱子移动到目标柱子hanoi(n-1, helper, source, target)# 测试代码hanoi(3, 'A', 'B', 'C') # 将3个盘子从A柱子移动到C柱子，使用B柱子作为辅助柱子```这段代码中，`hanoi`函数是一个递归函数，它接受四个参数：盘子的数量`n`、源柱子的名称`source`、辅助柱子的名称`helper`、目标柱子的名称`target`。
函数会首先将前`n-1`个盘子从源柱子移动到辅助柱子，然后将第`n`个盘子从源柱子移动到目标柱子，最后再将前`n-1`个盘子从辅助柱子移动到目标柱子。
汉诺塔问题数学解法
汉诺塔问题数学解法汉诺塔问题是一个经典的数学问题，它的解法是基于递归的。
假设有n个圆盘，编号从1到n，初始时都放置在A柱子上，目标是将这些圆盘移动到C柱子上。
移动过程中必须遵守以下规则：每次只能移动一个圆盘；大圆盘不能放在小圆盘上面。
解题步骤如下：1. 如果n=1，则直接将编号为1的圆盘从A柱子移动到C柱子上，移动完毕。
2. 如果n>1，先将n-1个圆盘从A柱子通过C柱子移动到B柱子上。
此时A柱子上只剩下编号为n的圆盘。
3. 将编号为n的圆盘从A柱子移动到C柱子上，移动完毕。
4. 最后将B柱子上的n-1个圆盘通过A柱子移动到C柱子上。
可以看出，将n个圆盘移动到C柱子上的步骤可以分解为以下子问题：1. 将n-1个圆盘从A柱子通过C柱子移动到B柱子上。
2. 将编号为n的圆盘从A柱子移动到C柱子上。
3. 将n-1个圆盘从B柱子通过A柱子移动到C柱子上。
可以使用递归的方法来解决汉诺塔问题。
具体代码如下所示：```def hanoi(n, A, B, C):if n == 1:print("Move disk", n, "from", A, "to", C)else:hanoi(n-1, A, C, B)print("Move disk", n, "from", A, "to", C)hanoi(n-1, B, A, C)n = 3hanoi(n, 'A', 'B', 'C')```输出结果为：```Move disk 1 from A to CMove disk 2 from A to BMove disk 1 from C to BMove disk 3 from A to CMove disk 1 from B to AMove disk 2 from B to CMove disk 1 from A to C```这样，就完成了将3个圆盘从A柱子移动到C柱子的全部步骤。
汉诺塔问题数学解法
汉诺塔问题数学解法
一、建立递归模型
汉诺塔问题是一个经典的递归问题，可以通过建立递归模型来求解。
递归模型的基本思想是将问题分解为更小的子问题，然后通过对子问题的求解来得到原问题的解。
二、定义变量
在汉诺塔问题中，我们可以定义以下变量：
n：表示盘子的数量；
A、B、C：表示三个柱子，其中A柱子是起始柱子，B 柱子是辅助柱子，C柱子是目标柱子；
m：表示当前需要移动的盘子数量。
三、递归关系
汉诺塔问题的递归关系可以表示为：
将m个盘子从A移动到C，需要先将m-1个盘子从A移动到B，然后将最后一个盘子从A移动到C，最后将m-1个盘子从B移动到C。
将m个盘子从A移动到B，需要先将m-1个盘子从A移动到C，然后将最后一个盘子从A移动到B，最后将m-1个盘子从C移动到B。
将m个盘子从B移动到C，需要先将m-1个盘子从B移动到A，然后将最后一个盘子从B移动到C，最后将m-1个盘子从A移动到C。
四、寻找规律
通过观察递归关系，我们可以发现以下规律：
每次移动都需要经过三个柱子，即起始柱子、辅助柱子和目标柱子；
每次移动都需要将n-1个盘子从起始柱子移动到辅助柱子，然后将最后一个盘子从起始柱子移动到目标柱子，最后将n-1个盘子从辅助柱子移动到目标柱子；
每次移动都需要将n-1个盘子从起始柱子移动到辅助柱子，然后将最后一个盘子从起始柱子移动到目标柱子，最后将n-1个盘子从辅助柱子移动到目标柱子。
五、验证解决方案
通过以上规律，我们可以得到汉诺塔问题的解法。
为了验证解法的正确性，我们可以使用递归函数来实现解法，并使用测试数据来验证解法的正确性。
汉诺塔数学题
汉诺塔（又称河内塔）是一个经典的数学问题，起源于一个古老的传说。
问题是这样的：有三根柱子A、B、C，A柱子上从小叠到大地放着n个圆盘。
目标是将这些圆盘按照大小顺序重新摆放在C柱子上，期间只有一个原则：一次只能移动一个圆盘，且大盘子不能在小盘子上面。
解决汉诺塔问题的一个必然步骤是将最大的圆盘移出。
在移动最大圆盘之前，我们需要将其他所有圆盘从A柱子移动到B柱子上，并保持它们的顺序不变。
然后，将最大的圆盘从A柱子移动到C柱子上。
最后，再将B柱子上的所有圆盘按照同样的规则移动到C柱子上。
对于只有一个圆盘的情况，问题很简单，直接将圆盘从A柱子移动到C柱子即可。
对于有两个圆盘的情况，我们可以先将小圆盘移动到B柱子上，然后将大圆盘移动到C柱子上，最后将小圆盘从B柱子移动到C柱子上。
对于有三个或更多圆盘的情况，我们可以使用递归的方法来解决。
假设有n个圆盘需要移动，我们可以先将前n-1个圆盘从A柱子移动到B柱子上，然后将第n个圆盘（也就是最大的圆盘）从A柱子移动到C柱子上，最后将B柱子上的n-1个圆盘移动到C柱子上。
这个过程可以用以下公式表示：H(n) = 2 * H(n-1) + 1其中，H(n)表示移动n个圆盘所需的最少步骤数。
这个公式说明，移动n个圆盘所需的步骤数是移动n-1个圆盘所需步骤数的两倍加1。
通过递归调用这个函数，我们可以计算出移动任意数量圆盘所需的最少步骤数。
例如，移动4个圆盘需要15步，移动5个圆盘需要31步，以此类推。
需要注意的是，虽然汉诺塔问题看起来很简单，但实际上它的复杂度是指数级的。
对于较大的n值，移动圆盘所需的步骤数会迅速增长，变得非常庞大。
因此，在实际应用中，我们可能需要考虑使用其他方法来解决类似的问题。
汉诺塔问题
第3 时汉诺塔问题首先介绍下汉洛塔问题，就是说有三根杆分别标记为A、B、C，在在A杆自下而上、由大到小按顺序放置n个盘。
目标是把A杆上的盘全部移到C杆上，并依旧保持顺序叠好。
移动的规则：每次只能移动一个盘子，并且在移动过程中三根杆上始终保持大盘在下，小盘在上，操作过程中盘子可以至于A、B、C任一杆上。
来分析一下如果有N个盘子当n=1即只有一个盘子，那么直接将1号盘子移动到c杆上即可；当n=2即a杆上有两个盘子，则需要分为三步，1移到B,2移到C,1移到C 当n=1和n=2的时候，我们可以很轻易的完成移动。
那么当n=n的时候，就把n个盘子分为两个部分，第一个部分就是顶上的n-1个小盘，第二部分是最底下的大盘，分成两个部分之后，我们就把塔看作两个盘子，那么只要三步就可以完成移动。
第一步要把n-1个盘子移动到B杆上，那么如何把着n-1个盘子移动到B杆上呢，当A移动到C时B作为中介杆，现在要把A 上的N-1盘移动到B 杆了，那么就应该交换杆的作用，C杆变成了中介杆，A杆变成了原始干B变成了目标杆，通过交换杆的作用，完成将A上n-1个盘子移动到B杆上的目的,在代码上来看就是直接交换B和C的位置,完成了把n-1个盘子移动到B杆上,第二步就是把a上最底下的N号盘子移动到C杆上。
最后一部就是把B杆上的N-1个盘子移动到C 上，这时就可以借助A杆，把Aa杆看作中介杆，B为原始杆，C为目标杆。
就可以完成移动。
在代码上就是B放在函数第一位，A放在第二位，C放在最后位，于是通过简单的3步就可以完成这个题，递归方法的思路就相对于简单些，接下来分析下他的时间复杂度，他的时间函数为：当n=1时，时间函数为1，当汉诺塔规模为n时，时间函数为T(n)，这里调用汉诺塔函数规模为n-1他的时间复杂度为T(n-1)这里时一个输出函数语句他的时间函数为1，他的时间也复杂度为T(n-1)下面也是一个汉诺塔函数规模也为n-1，s所以他的时间函数为两倍的T(n-1)+1解决方式•首先将n 片金片从小到大依次编号为0 号、1 号、……、n-1 号假设有一个4 层高的汉诺塔，设初始值为0000按"8"、"4"、"2"、"1" 称呼二进制的各位"8"位、"4"位、"2"位、"1"位依次对应3 号金片、2 号金片、1号金片、0 号金片开始累加，每次加10000(2) -> 0001(2)"1"位由0 变1，则将0 号金片右移，即将0 号金片由A 塔移至B塔除了DFS，还有BFS，从概念上讲，两者只是在扩展时的方向不同，DFS向深扩张，而BFS向广扩张。
【算法】汉诺塔问题
【算法】汉诺塔问题汉诺塔问题是⼀个经典的问题。
汉诺塔（Hanoi Tower），⼜称河内塔，源于印度⼀个古⽼传说。
⼤梵天创造世界的时候做了三根⾦刚⽯柱⼦，在⼀根柱⼦上从下往上按照⼤⼩顺序摞着64⽚黄⾦圆盘。
⼤梵天命令婆罗门把圆盘从下⾯开始按⼤⼩顺序重新摆放在另⼀根柱⼦上。
并且规定，任何时候，在⼩圆盘上都不能放⼤圆盘，且在三根柱⼦之间⼀次只能移动⼀个圆盘。
问应该如何操作？当只有⼀个盘⼦时这是最简单的情况：只需将1号盘⼦从X塔移动到Z塔就OK于是我们可以写出如下的函数，来模拟完成这个过程。
假设盘⼦是⽤1，2，3...按照⼤⼩编码代表的，⽽塔则是⽤⼀个字符char表⽰的。
//将编号为 number 的盘⼦从 from 塔座移到 to 塔座void move(int number , char from , char to){std::cout<<"move dish "<<number<<": "<<from<<"--->"<<to<<std::endl;}有两个盘⼦时有2个盘⼦，⽬标是：将X塔上的盘⼦借助Y移动到Z盘⼦上。
特别的，为了好描述，我把X塔叫做源塔，因为盘⼦起初在这个塔上，把Y塔叫做辅助塔，因为Y塔只是起个过渡作⽤。
把Z盘叫做⽬标塔，最后所以的盘⼦都在这个塔上。
我们可以写出伪代码move(1,X,Y);move(2,X,Z);move(1,Y,Z);有三个盘⼦时在盘⼦数⼤于2的时候，⽆论有多少个盘⼦，我们眼⾥只有2个盘⼦：即最底层的最⼤的盘⼦，和它上⾯的所有盘⼦组和形成的⼀个盘，我们可以把它看做是2.5号盘。
这样考虑的好处是：⽆论有多少盘⼦，都可以⽤2个盘⼦的思路去做。
简化了思路。
因此，步骤是：1、将2.5号盘借助Z塔移动到Y塔上。
注意，处理这步操作时，X是源塔，Z是辅助塔，Y是⽬标塔2、将3盘移动到Z塔上，3、将2.5盘借助X塔移动到Z塔上。
汉诺塔问题
汉诺塔问题
汉诺塔问题是使用递归解决问题的经典范例。
汉诺（Hanoi）塔问题：古代有一个梵塔，塔内有三个座A、B、C，A座上有64个盘子，盘子大小不等，大的在下，小的在上（如图）。
有一个和尚想把这64个盘子从A座移到B座，但每次只能允许移动一个盘子，并且在移动过程中，3个座上的盘子始终保持大盘在下，小盘在上。
在移动过程中可以利用B座，要求打印移动的步骤。
如果只有一个盘子，则不需要利用B座，直接将盘子从A移动到C。
•如果有2个盘子，可以先将盘子1上的盘子2移动到B；将盘子1移动到c；将盘子2移动到c。
这说明了：可以借助B将2个盘子从A移动到C，当然，也可以借助C将2个盘子从A移动到B。
•如果有3个盘子，那么根据2个盘子的结论，可以借助c将盘子1上的两个盘子从A移动到B；将盘子1从A移动到C，A变成空座；借助A座，将B上的两个盘子移动到C。
这说明：可以借助一个空座，将3个盘子从一个座移动到另一个。
•如果有4个盘子，那么首先借助空座C，将盘子1上的三个盘子从A移动到B；将盘子1移动到C，A变成空座；借助空座A，将B座上的三个盘子移动到C。
代码如下：。
汉诺塔问题
汉诺塔问题[又称河内塔]是印度的一个古老的传说。
据传开天辟地之神勃拉玛在一个庙里留下了三根金刚石的棒，第一根上面套着64个圆的金片，最大的一个在底下，其余一个比一个小，依次叠上去，庙里的众僧不倦地把它们一个个地从这根棒搬到另一根棒上，规定可利用中间的一根棒作为帮助，但每次只能搬一个，而且大的不能放在小的上面。
就是这看似简单的问题，却困扰了人们千年以上。
后来，这个传说就演变为汉诺塔游戏，玩法如下:1.有三根杆子A,B,C。
A杆上有若干碟子2.每次移动一块碟子,小的只能叠在大的上面3.把所有碟子从A杆全部移到C杆上经过研究发现，三圆盘的汉诺塔问题很好破解，就是按照移动规则向一个方向移动金片：如3阶汉诺塔的移动：A→C,A→B,C→B,A→C,B→A,B→C,A→C但每当增加一阶，移动的次数却会以倍数增加，因此每当圆盘增加到一定数量时，常人只能望而却步。
而我们程序员却可以借助于计算机的运算性能，轻而易举地解决这一问题，汉诺塔问题也作为程序设计中的经典递归问题而存在下来。
但是，实践和理论往往却有天壤之别，我们虽然可以运算出汉诺塔的结果，但是却未必能动手完成这一结果。
不信？我这里给出了一个简单的汉诺塔实现，有兴趣的可以自己码盘子看看。
HannoiWindow类的主要工功能是实现程序的窗口化。
用的是BordLayout布局，采用了菜单、按钮、面板等组件，菜单主要包括选择级别，盘子个数，设置大小等功能，它分别调用了塔的名字TowerName（A，B，C）、设置盘子的个数SetAmountOfDisc以及大小、这个游戏可以选择的级别menuGrade（初、中、高），按钮的功能包括重新开始（renew）和自动演示（autoButton）以及播放、暂停、演示、关闭等。
Disc类的主要功能是建立一个类disc，然后通过调用盘子的设置数量、获取数量以及点的设置数量、获取数量来实现这个程序的功能。
汉诺塔问题
汉诺塔百科名片汉诺塔初始状态汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。
上帝创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上安大小顺序摞着64片黄金圆盘。
上帝命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。
并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
目录由来汉诺塔与宇宙寿命concreteHAM：汉诺塔问题的程序实现由来汉诺塔与宇宙寿命concreteHAM：汉诺塔问题的程序实现展开编辑本段由来来源汉诺塔是源自印度神话里的玩具。
上帝创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按大小顺序摞着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时，f(64)= 2^64-1=18446744073709551615假如每秒钟一次，共需多长时间呢？一个平年365天有31536000 秒，闰年366天有31622400秒，平均每年31556952秒，计算一下，18446744073709551615/31556952=584554049253.855年这表明移完这些金片需要5845亿年以上，而地球存在至今不过45亿年，太阳系的预期寿命据说也就是数百亿年。
汉诺塔问题（递归、栈）
汉诺塔问题（递归、栈）修改⼀下汉诺塔的游戏规则，现在不能直接从左边⾛到右边，也不能直接右边⾛到左边。
⽅法⼀：递归实现现在分析⼀下，⽐如左边有1~n，那么移动最后⼀个的情况，就是：1.1-n-1从左边移动到右边2.n从左边移动到中间3.1-n-1从右边移动到左边4.n从中间移动到右边5.1-n-1从左边移动到右边那么，假如我有这样⼀个f(range,from,to)那么我需要求解的就是f(n,lrft,right),原⼦情况就是从只有⼀个数的时候，直接左边中间右边即可。
1public static int process(int num, String from, String to) {2if (num == 1) {3 System.out.println("move 1 from " + from +" to middle");4 System.out.println("move 1 from middle to " + to);5return 2;6 }7else {8int p1 = process(num - 1, from, to);9 System.out.println("move "+ num + " from " + from +" to middle");10int p2 = process(num - 1, to, from);11 System.out.println("move "+ num + " from middle to " + to);12int p3 = process(num - 1, from, to);13return p1 + p2 + p3 +2;14 }15 }View Code⽅法⼆：使⽤栈来实现这样思考，⼀共有的动作⼀共就四种：L2M M2L M2R R2M在任何⼀个时刻，要想最少移动次数，并且满⾜⼩压⼤原则，则只有⼀种情况能够得到满⾜。
汉诺塔问题
@Gxjun
• •
•
• • • • • • • •
•
汉诺塔IV 还 记得汉诺塔III吗？他的规则是这样的：不允许直接从最左(右)边移到最右(左) 边(每次移动一定是移到中间杆或从中间移出)，也不允许大盘放到小盘的上 面。 xhd在想如果我们允许最大的盘子放到最上面会怎么样呢？（只允许最大的放 在最上面）当然最后需要的结果是盘子从小到大排在最右边。 Input 输入数据的第一行是一个数据T，表示有T组数据。 每组数据有一个正整数n(1 <= n <= 20)，表示有n个盘子。 Output 对于每组输入数据，最少需要的摆放次数。 Sample Input 2 1 10 Sample Output 2 19684 Author xhd Source ACM程序设计期末考试_热身赛(感谢 xhd & 8600)
• 出生在世界上真是愧对于大家。
Thanks
汉罗塔1
经典的汉诺塔问题经常作为一个递归的经典例题存在。可能有人并不知道汉 诺塔问题的典故。汉诺塔来源于印度传说的一个故事，上帝创造世界时作了三根 金刚石柱 子，在一根柱子上从下往上按大小顺序摞着64片黄金圆盘。上帝命令婆 罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆 盘上不能放 大圆盘，在三根柱子之间一回只能移动一个圆盘。有预言说，这件事 完成时宇宙会在一瞬间闪电式毁灭。也有人相信婆罗门至今仍在一刻不停地搬动 着圆盘。恩，当 然这个传说并不可信，如今汉诺塔更多的是作为一个玩具存在。 Gardon就收到了一个汉诺塔玩具作为生日礼物。 Gardon是个怕麻烦的人 （恩，就是爱偷懒的人），很显然将64个圆盘逐一 搬动直到所有的盘子都到达第三个柱子上很困难，所以Gardon决定作个小弊，他 又找来了一根一模一样的 柱子，通过这个柱子来更快的把所有的盘子移到第三个 柱子上。下面的问题就是：当Gardon在一次游戏中使用了N个盘子时，他需要多 少次移动才能把他们都 移到第三个柱子上？很显然，在没有第四个柱子时，问题 的解是2^N-1，但现在有了这个柱子的帮助，又该是多少呢？
汉诺塔问题
递归的概念
一个过程(或函数)直接或间接调用自己本身,这种过程(或函 数)叫递归过程(或函数).
递归算法
递归过程一般通过函数或子过程来实现。递归方法：在函 数或子过程的内部，直接或者间接地调用自己的算法。
递归算法简析
递归是计算机科学的一个重要概念,递归的方法是程序设计 中有效的方法,采用递归编写 递归能使程序变得简洁和清晰.
汉诺塔问题
汉诺塔问题
：
传说上帝创造世界的时候做了三根金 刚石柱子，在一根柱子上从下往上安 大小顺序摞着64片黄金圆盘。上帝命 令婆罗门把圆盘从下面开始按大 小顺 序重新摆放在另一根柱子上。并且规 定，在小圆盘上不能放大圆盘，在三 根柱子之间一次只能移动一个圆盘。
规律
金属 1 片数 移动 1 次数 2 3 3 7 4 15 …… …… …… …… n 2^n-1 Nhomakorabea规律
•Ⅰ •Ⅱ •Ⅲ
先移动上面n-1个金盘到C柱
将第n片金盘移到B柱
将自柱上的1个金盘移到C柱上
猜想
程序语言
C语言实现 1.n为A塔初始盘子个数； 2.A塔上盘子从上到下、从小到大编号依次为1，2，3…； 3.Hania0方法采用递归算法，实现盘子移动的最佳方案。 算法： void Hanoi(int n, char a, char b, char c) { if(n==1) //只有一个盘子，直接移动 printf("move %c to %c\n", a, c); else { Hanoi(n-1, a, c, b); //将n-1个盘子从a柱移动到b柱 printf("move %c to %c\n", a, c); //将最后一个盘子从a 柱移动到c柱 Hanoi(n-1, b, a, c); //将n-1个盘子从b柱移动到c柱 } }时间复杂度下限是O(2n)
汉诺塔问题
汉诺塔百科名片汉诺塔初始状态汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。
上帝创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上安大小顺序摞着64片黄金圆盘。
上帝命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。
并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
目录由来汉诺塔与宇宙寿命concreteHAM：汉诺塔问题的程序实现由来汉诺塔与宇宙寿命concreteHAM：汉诺塔问题的程序实现展开编辑本段由来来源汉诺塔是源自印度神话里的玩具。
上帝创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按大小顺序摞着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时，f(64)= 2^64-1=18446744073709551615假如每秒钟一次，共需多长时间呢？一个平年365天有31536000 秒，闰年366天有31622400秒，平均每年31556952秒，计算一下，18446744073709551615/31556952=584554049253.855年这表明移完这些金片需要5845亿年以上，而地球存在至今不过45亿年，太阳系的预期寿命据说也就是数百亿年。