汉诺塔问题

 

汉诺塔问题是一个经典的问题。汉诺塔（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步。因此在实现并行方式时要考虑这种差别。而不是简单地使每一个并行分支移动相同数量的盘子。