Title：汉诺塔问题的递归实现

十载的玉溪网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。全网营销推广的优势是能够根据用户设备显示端的尺寸不同，自动调整玉溪建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联建站从事“玉溪网站设计”,“玉溪网站推广”以来，每个客户项目都认真落实执行。

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

一、汉诺塔（基本）

汉诺塔问题是典型的分治算法问题，首先我们来讨论最基本的汉诺塔问题。假设有n个圆盘，三根柱子，a，b，c，需要把n个盘子（从下往上按照大小顺序摞着）从a柱移动到c柱，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

1.1 打印路径

采用分治法，分而治之，把大问题化解成小问题。故可以把n个盘子看成n-1个盘子，和第n个盘子，首先我们需要把n-1个盘子移动到b柱子上，然后把第n个盘子移动到c柱子上，最后把n-1个盘子移动到c柱子上，这样就用最少的移动次数完成了任务。

c++实现：

#include 
using namespace std;
void move(int n, char a, char b){
    cout<"< 0) {
        hanoi(n - 1, a, c, b);// 把n-1个盘子移动到c柱子上
        move(n, a, b);  // 把a移动到b
        hanoi(n - 1, c, b, a);  // 把第n-1个盘子从c柱子移动到b柱子上
    }
}
int main()
{
    int n;
    while(cin>>n){
        char a='a',b='b',c='c';
        hanoi(n,a,c,b);   //把n个盘子从a柱子移动到c柱子
    }
    return 0;
}

以上程序显示全部步骤的移动方法。

1.2 计算移动次数

如果要计算一共移动了多少次，找出规律即可。

假设移动n个盘子需要移动f(n)次，所以把n-1个盘子移动到b柱子上，需要移动f(n-1)次，然后把第n个盘子移动到c柱子上，需要移动1次，最后把n-1个盘子移动到c柱子上，需要移动f(n-1)次，综上所述，一共移动了

f(n) = 2 f(n-1) + 1

而：

 f(1) = 1;

 f(2) = 2*1+ 1;

 f(3) = 2(2*1+ 1)+ 1;

 .......

 f(n) = 2^n -1

C++实现：

//基本汉诺塔移动次数，可以算小于64的所有盘子数
#include 
using namespace std;
int main()
{
    int n;
    while(cin>>n){
        if(n>63||n<1) {
            cout<<"ERROR"<

二、汉诺塔（必须通过中间的柱子）
假设有n个圆盘，三根柱子，a，b，c，需要把n个盘子（上从下往上按照大小顺序摞着）从a柱移动到c柱，不允许直接从最左(右)边移到最右(左)边(每次移动一定是移到中间杆或从中间移出)，也不允许大盘放到下盘的上面。
2.1 打印路径
参考acm题目：http://acm.hdu.edu.cn/showproblem.php?pid=2064
这道题和之前不同，约束了必须通过中间的柱子才可以，这也难不倒我们，我们只需要在递归的时候改变一下策略就可以完成任务。
解决方法：
依然采用分治法，分而治之，把大问题化解成小问题。最开始在a柱子上有n个盘子，我们可以把n个盘子看成n-1个盘子，和第n个盘子。首先我们需要把n-1个盘子移动到c柱子上（n-1个盘子只能由a移动到c或者由c移动到a，否则就不是最少次数了），然后把第n个盘子移动到b柱子上（不能直接由a移动到c），最后把n-1个盘子移动到c柱子上，这样就用最少的移动次数完成了任务。
c++实现：
#include 
using namespace std;
void move(int n, char a, char b){
    cout<"< 0) {
        hanoi(n - 1, a, c, b);
        move(n, a, b);
        hanoi(n - 1, c, a, b);
        move(n, b, c);
        hanoi(n - 1, a, c, b);
    }
}
int main()
{
    char a='a',b='b',c='c';
    hanoi(3,a,c,b);
    return 0;
}
2.2 计算移动次数
如果要计算一共移动了多少次，找出规律即可。
假设移动n个盘子需要移动f(n)次，所以把n-1个盘子移动到c柱子上，需要移动f(n-1)次，然后把第n个盘子移动到b柱子上，需要移动1次，然后把n-1个盘子移动到a柱子上，需要移动f(n-1)次，第n个盘子移动到c柱子上，需要移动1次，最后把n-1个盘子移动到c柱子上，需要移动f(n-1)次，综上所述，一共移动了
f(n) = 3 f(n-1) + 2
而：
  f(1) = 2;
  f(2) = 3*2+ 2;
  f(3) = 3(3*2+ 2)+ 2;
  .......
  f(n) = 3^n -1
C++实现：
#include 
using namespace std;
int main()
{
    int n;
    __int64 f[36];
    f[1]=2;
    for(int i=2;i<=35;i++) f[i]=3*f[i-1]+2;
    while(cin>>n){
        if(n>56||n<1){
            cout<<"ERROR!"<
三、汉诺塔（必须通过中间的柱子，允许最大的放在最上面）
假设有n个圆盘，三根柱子，a，b，c，需要把n个盘子（上从下往上按照大小顺序摞着）从a柱移动到c柱，不允许直接从最左(右)边移到最右(左)边(每次移动一定是移到中间杆或从中间移出)，也不允许大盘放到小盘的上面。如果我们允许最大的盘子放到最上面会怎么样呢？（只允许最大的放在最上面）当然最后需要的结果是盘子从小到大排在最右边。
3.1 打印路径
参考acm题目：http://acm.hdu.edu.cn/showproblem.php?pid=2077
这道题和之前不同，约束了必须通过中间的柱子才可以，也放宽了对最大盘子的限制，所以肯定比第二种汉诺塔移动次数少，我们也是只需要在递归的时候改变一下策略就可以完成任务。
解决方法：
依然采用分治法，分而治之，把大问题化解成小问题。最开始在a柱子上有n个盘子，我们可以把n个盘子看成n-2个盘子，和第n-1，以及第n个盘子。首先我们需要把n-2个盘子移动到c柱子上（利用第二种类型的算法），然后把第n-1和n个盘子依次移动到b柱子上，再把n-2个盘子移动到a柱子上，再把第n和第n-1个盘子移动到柱子c上，这样就用最少的移动次数完成了任务。
C++实现：
#include 
using namespace std;
void move(int n, char a, char b){
    cout<"< 0) {
        hanoi(n - 1, a, c, b);
        move(n, a, b);
        hanoi(n - 1, c, a, b);
        move(n, b, c);
        hanoi(n - 1, a, c, b);
    }
}
void Hanoi_(int n, char a, char c, char b){
    if(n > 0) {
        hanoi(n - 2, a, c, b);
        if(n > 1)
        move(n - 1, a, b);
        move(n, a, b);
        hanoi(n - 2, c, a, b);
        move(n, b, c);
        if(n > 1)
        move(n - 1, b, c);
        hanoi(n - 2, a, c, b);
    }
}
int main()
{
    int n;
    while(cin>>n) {
        char a='a',b='b',c='c';
        Hanoi_(n,a,c,b);
    }
    return 0;
}
3.2 计算移动次数
如果要计算一共移动了多少次，找出规律即可。
假设移动n个盘子需要移动F(n)次，用第二种算法把n-2个盘子移动到c柱子上（利用第二种类型的算法），需要f(n-2)次，然后把第n-1和n个盘子依次移动到b柱子上，需要2次，再把n-2个盘子移动到c柱子上，再把第n和第n-1个盘子移动到柱子c上，需要2次，综上所述，一共移动了
 f(n) = 3 f(n-2) + 4
而：
  f(n-2) = 3^(n-2)-1
故，f(n)=3^(n-1)+1
C++实现;
#include 
using namespace std;
int main()
{
    int T;
    cin>>T;
    while(T--){
        int n;
        cin>>n;
        if(n>51||n<1) {
            cout<<"ERROR"<
四、汉诺塔（加一根柱子）
假设有n个圆盘，三根柱子，a，b，c，需要把n个盘子（上从下往上按照大小顺序摞着）从a柱移动到c柱，再找来了一根一模一样的柱子d，通过这个柱子来更快的把所有的盘子移到第三个柱子上。
4.1 计算移动次数
参考acm题目：http://acm.hdu.edu.cn/showproblem.php?pid=1207
这道题和之前都有很大的不同，加了一根柱子，意味着有的时候可用3根柱子，有的时候可用4根柱子，当把j个小盘子移动到d盘上时，有四根柱子可用，而当把n-j个盘子从a移动到c时，仅有三根柱子可用。这里我们就要找到j的值，使所有移动的次数和最小。
解决方法：
依然采用分治法。首先把j个盘子移动到d柱子上（通过四个柱子可用的算法），需要B[j]次移动，然后把n-j个盘子移动到c柱子上（通过三个柱子可用的算法），需要A[n-j]次移动，，然后把d中的j个盘子移动到c柱子上，需要B[j]次移动。我们可以用j的大小循环，找到移动次数最小的j。
首先我们先计算移动的次数，核心公式为下面代码中的：flag = 2*B[ j ] + A[ i - j];   //j个盘子移动到第四个柱子，然后把剩下的i-j个在第四个不能用的情况下移到第三个
计算次数的c++实现：
#include 
using namespace std;
int main()
{
    int n;
    double a[65],b[65];  //数组a代表没加第四个柱子的结果，数组b代表加了第四个柱子的结果
    a[1]=1;
    for(int i=2;i<=64;i++) a[i]=2*a[i-1]+1;
    b[1]=1;
    b[2]=3;
    for(int i=3;i<=64;i++){
        double min=a[i],flag;
        for(int j=1;jflag) min=flag;
        }
        b[i]=min;
    }
    while(cin>>n){
        if(n>64||n<1){
            cout<<"ERROR!"<

4.2 打印路径
利用上面的算法，我们可以很容易得出路径
模拟移动步骤的C++实现：
#include 
using namespace std;
void move(int n, char a, char b){
    cout<"< 0) {
        hanoi_basic_3(n - 1, a, c, b);// 把n-1个盘子移动到b柱子上
        move(n, a, b);  // 把a移动到b
        hanoi_basic_3(n - 1, c, b, a);  // 把第n个盘子移动到b柱子上
    }
}
void hanoi(int n, char a, char c, char b, char d, int C[]){
    int j=C[n]; //j个盘子使用四个柱子的移动方式
    if(n > 0) {
        hanoi(j, a, d, b, c, C);// 把j个盘子移动到d柱子上
        hanoi_basic_3(n - j, a, c, b);// 把n-j个盘子移动到c柱子上（使用三个柱子的移动方式）
        hanoi(j, d, c, a, b, C);    // 把j个盘子移动到c柱子上
    }
}
int main()
{
    int n,flag_j;
    double A[65];  //未加第四个柱子时候的移动次数情况
    A[1]=1;
    for(int i=2;i<65;i++) A[i]=2*A[i-1]+1;
    double B[65],flag,min;
    int C[65]; //把前 c[j]个元素用四个柱子的方法，后i-j 个元素用三个柱子的方法
    C[1]=0;
    C[2]=0;
    for(int i=3;i<=64;i++){
        min=A[i];  //数组A代表没加第四个柱子的结果次数，数组b代表加了第四个柱子的结果次数
        B[1]=1;
        B[2]=3;
        flag_j=0;
        for(int j=1;jflag) {
                min=flag;
                flag_j=j;
            }
        B[i]=min;
        C[i]=flag_j;
        }
    }
    while(cin>>n){
        char a='a',b='b',c='c',d='d';
        hanoi(n,a,c,b,d,C);   //把n个盘子从a柱子移动到c柱子
    }
    return 0;
}
@码农同学，版权所有。
            
            
                            

                分享文章：汉诺塔问题的递归实现（扩展）                

                标题链接：http://scyanting.com/article/giphih.html