汉诺塔难点,python益智游戏计算Hanno塔难点示例

图片 7
数据库

汉诺塔(又称河内塔)问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子,在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定,在小圆盘上不能放大圆盘,在三根柱子之间一次只能移动一个圆盘。

汉诺塔问题是一个经典的问题。汉诺塔(Hanoi
Tower),又称河内塔,源于印度一个古老传说。大梵天创造世界的时候做了三根金刚石柱子,在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定,任何时候,在小圆盘上都不能放大圆盘,且在三根柱子之间一次只能移动一个圆盘。问应该如何操作?

复制代码 代码如下:

图片 1

times = 0
def test(num,a,b,c):
    globaltimes
    ifnum==1:
       print (a,b)
       times+=1

 

    else:
       test(num-1,a,c,b)
       test(1,a,b,c)
       test(num-1,c,b,a)
      

分析

  

如果是初次接触类似的问题,乍看之下肯定会感觉无从下手。

test(12,”a”,”b”,”c”)
print “经过的步数passing:%d”%times

要把64个圆盘从a柱子移动到c柱子上,第一步应该怎么做?虽然可以肯定,第一步唯一的选择是移动a最上面的那个圆盘,但是应该将其移到b还是c呢?很难确定。因为接下来的第二步、第三步……直到最后一步,看起来都是很难确定的。能立即确定的是最后一步:最后一步的盘子肯定也是a最上面那个圆盘,并且是由a或b移动到c——此前已经将63个圆盘移动到了c上。

您可能感兴趣的文章:

  • 使用python实现递归版汉诺塔示例(汉诺塔递归算法)
  • python实现汉诺塔递归算法经典案例
  • python装饰器与递归算法详解
  • Python基于递归算法实现的走迷宫问题
  • python实现汉诺塔方法汇总
  • Python递归实现汉诺塔算法示例
  • 用Python实现斐波那契(Fibonacci)函数
  • python求斐波那契数列示例分享
  • python实现斐波那契数列的方法示例
  • Python打印斐波拉契数列实例
  • Python基于递归算法实现的汉诺塔与Fibonacci数列示例

也许你会说,管他呢,先随便试着移动一下好了。如果你这么做,你会发现,接下来你会面临越来越多类似的选择,对每一个选择都“试”一下的话,你会偏离正确的道路越来越远,直到你发现你接下来无法进行为止。

如果将这个问题的盘子数量减为10个或更少,就不会有太大的问题了。但盘子数量为64的话,你一共需要移动约1800亿亿步(18,446,744,073,709,551,615),才能最终完成整个过程。这是一个天文数字,没有人能够在有生之年通过手动的方式来完成它。即使借助于计算机,假设计算机每秒能够移动100万步,那么约需要18万亿秒,即58万年。将计算机的速度再提高1000倍,即每秒10亿步,也需要584年才能够完成。注:在我的笔记本电脑上,每秒大约能够移动6~8百万步。

虽然64个盘子超出了人力和现代计算机的能力,但至少对于计算机来说,这不是一个无法完成的任务,因为与我们人类不同,计算机的能力在不断提高。

 

分解问题

 

一股脑地考虑每一步如何移动很困难,我们可以换个思路。先假设除最下面的盘子之外,我们已经成功地将上面的63个盘子移到了b柱,此时只要将最下面的盘子由a移动到c即可。如图:

图片 2

当最大的盘子由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个圆盘,你将至少需要数百年才能看到结果(更可能的结果是由于步数太多,系统没有足够的内存而导致程序奔溃)。

图片 3

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);
      }
}

图片 4

 

在我的笔记本电脑上运行该程序,消耗的时间统计如下:(Intel Core i3
3.2GHz处理器,2.2GHz 3GB内存)

图片 5

正如备注中所显示的,步数是圆盘数量的指数函数,即steps=2^n –
1,运行所需时间也遵从这个规律。

扩展:汉诺塔问题的非递归实现

理论上来说,递归算法都能够改为循环来完成。例如阶乘问题,既可以用递归定义给出,也可以采用下面的方式来定义:

规定0的阶乘为1。对于其他自然数,n的阶乘可以表示为:

n!=1\2*3*…*n*

这种方式实际上就是采用了循环来定义。

然而,并不是所有的递归都能简单直观地改写为循环,例如前面所介绍的斐波那契数列的定义,和本文所讨论的汉诺塔问题。

下面这个帖子介绍了不使用递归而是用循环来解汉诺塔问题的算法。

程序框架

图片 6

hanoi函数

图片 7

TODO

研究如何使用并行算法解决汉诺塔问题。例如,64个盘子,每次成功将一个盘子移动到目标柱子上的过程都是独立的。因此可以分别并行地计算。
不过需要注意的是,成功移动第一个盘子的步数是最多的,占到总步数的1/2;而第二个盘子需要总步数的1/4……最后一个盘子仅需1步。
所以在实现并行方式时要考虑这种差异。而不是简单地使每个并行分支移动相同数量的盘子。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图