程序博客网 > pc端前端数据渲染

汉诺塔问题的递归实现（扩展）

来源：互联网 发布：pc端前端数据渲染 编辑：程序博客网 时间：2024/06/05 11:28

汉诺塔问题的递归实现

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


1.汉诺塔（基本）


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

解决办法;

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


c++实现：

[cpp] view plaincopy
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. void move(int n, char a, char b){  
  5.     cout<<a<<"->"<<b<<endl;  
  6. }   
  7.   
  8. void hanoi(int n, char a, char b, char c){//把n个盘子从a柱子移动到b柱子   
  9.     if(n > 0) {  
  10.         hanoi(n - 1, a, c, b);// 把n-1个盘子移动到c柱子上  
  11.         move(n, a, b);  // 把a移动到b   
  12.         hanoi(n - 1, c, b, a);  // 把第n-1个盘子从c柱子移动到b柱子上  
  13.     }  
  14. }  
  15.   
  16. int main()  
  17. {  
  18.     int n;  
  19.     while(cin>>n){  
  20.         char a='a',b='b',c='c';  
  21.         hanoi(n,a,c,b);   //把n个盘子从a柱子移动到c柱子   
  22.     }  
  23.     return 0;  
  24. }  


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

计算移动次数：

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

假设移动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++实现：

[cpp] view plaincopy
  1. //基本汉诺塔移动次数，可以算小于64的所有盘子数   
  2. #include <iostream>  
  3. using namespace std;  
  4. int main()  
  5. {  
  6.     int n;  
  7.     while(cin>>n){  
  8.         if(n>63||n<1) {  
  9.             cout<<"ERROR"<<endl;  
  10.             continue;  
  11.         }   
  12.         __int64 sum = 1;  
  13.         for(int i=1;i<=n;i++)  
  14.             sum*=2;  
  15.         cout<<sum-1<<endl;  
  16.     }   
  17.     return 0;  
  18. }  


2.汉诺塔（必须通过中间的柱子）


假设有n个圆盘，三根柱子，a，b，c，需要把n个盘子（上从下往上按照大小顺序摞着）从a柱移动到c柱，不允许直接从最左(右)边移到最右(左)边(每次移动一定是移到中间杆或从中间移出)，也不允许大盘放到下盘的上面。

参考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++实现：

[cpp] view plaincopy
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. void move(int n, char a, char b){  
  5.     cout<<a<<"->"<<b<<endl;  
  6. }   
  7.   
  8. void hanoi(int n, char a, char c, char b){  
  9.     if(n > 0) {  
  10.         hanoi(n - 1, a, c, b);  
  11.         move(n, a, b);  
  12.         hanoi(n - 1, c, a, b);  
  13.         move(n, b, c);  
  14.         hanoi(n - 1, a, c, b);  
  15.     }  
  16. }  
  17.   
  18. int main()  
  19. {  
  20.     char a='a',b='b',c='c';  
  21.     hanoi(3,a,c,b);  
  22.     return 0;  
  23. }  


计算移动次数：

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

假设移动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++实现：

[cpp] view plaincopy
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. int main()  
  5. {  
  6.     int n;  
  7.     __int64 f[36];  
  8.     f[1]=2;  
  9.     for(int i=2;i<=35;i++) f[i]=3*f[i-1]+2;  
  10.     while(cin>>n){  
  11.         if(n>56||n<1){  
  12.             cout<<"ERROR!"<<endl;  
  13.             continue;  
  14.         }   
  15.         cout<<f[n]<<endl;  
  16.     }   
  17.     return 0;  
  18. }  



3汉诺塔（必须通过中间的柱子，允许最大的放在最上面）


假设有n个圆盘，三根柱子，a，b，c，需要把n个盘子（上从下往上按照大小顺序摞着）从a柱移动到c柱，不允许直接从最左(右)边移到最右(左)边(每次移动一定是移到中间杆或从中间移出)，也不允许大盘放到小盘的上面。如果我们允许最大的盘子放到最上面会怎么样呢？（只允许最大的放在最上面）当然最后需要的结果是盘子从小到大排在最右边。

参考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++实现：

[cpp] view plaincopy
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. void move(int n, char a, char b){  
  5.     cout<<a<<"->"<<b<<endl;  
  6. }   
  7.   
  8. void hanoi(int n, char a, char c, char b){  
  9.     if(n > 0) {  
  10.         hanoi(n - 1, a, c, b);  
  11.         move(n, a, b);  
  12.         hanoi(n - 1, c, a, b);  
  13.         move(n, b, c);  
  14.         hanoi(n - 1, a, c, b);  
  15.     }  
  16. }  
  17.   
  18. void Hanoi_(int n, char a, char c, char b){  
  19.     if(n > 0) {  
  20.         hanoi(n - 2, a, c, b);  
  21.         if(n > 1)   
  22.         move(n - 1, a, b);  
  23.         move(n, a, b);  
  24.         hanoi(n - 2, c, a, b);  
  25.         move(n, b, c);  
  26.         if(n > 1)   
  27.         move(n - 1, b, c);  
  28.         hanoi(n - 2, a, c, b);  
  29.     }  
  30. }  
  31.   
  32. int main()  
  33. {  
  34.     int n;  
  35.     while(cin>>n) {  
  36.         char a='a',b='b',c='c';  
  37.         Hanoi_(n,a,c,b);  
  38.     }  
  39.     return 0;  
  40. }  

计算移动次数：

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

假设移动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++实现;

[cpp] view plaincopy
  1. #include <iostream>  
  2. using namespace std;  
  3. int main()  
  4. {  
  5.     int T;  
  6.     cin>>T;   
  7.     while(T--){  
  8.         int n;   
  9.         cin>>n;   
  10.         if(n>51||n<1) {  
  11.             cout<<"ERROR"<<endl;  
  12.             continue;  
  13.         }   
  14.         __int64 sum = 1;  
  15.         for(int i=1;i<=n-1;i++)  
  16.             sum*=3;  
  17.         cout<<1+sum<<endl;  
  18.     }   
  19.     return 0;  
  20. }  


4.汉诺塔（加一根柱子）


 假设有n个圆盘，三根柱子，a，b，c，需要把n个盘子（上从下往上按照大小顺序摞着）从a柱移动到c柱，再找来了一根一模一样的柱子d，通过这个柱子来更快的把所有的盘子移到第三个柱子上。

参考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++实现：

[cpp] view plaincopy
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. int main()  
  5. {  
  6.     int n;  
  7.     double a[65],b[65];  //数组a代表没加第四个柱子的结果，数组b代表加了第四个柱子的结果   
  8.     a[1]=1;  
  9.     for(int i=2;i<=64;i++) a[i]=2*a[i-1]+1;  
  10.     b[1]=1;  
  11.     b[2]=3;  
  12.     for(int i=3;i<=64;i++){  
  13.         double min=a[i],flag;  
  14.         for(int j=1;j<i;j++){  
  15.             flag=2*b[j]+a[i-j]; //j个移动到第四个柱子，然后把剩下的i-j个在第四个不能用的情况下移到第三个柱子上   
  16.             if(min>flag) min=flag;  
  17.         }  
  18.         b[i]=min;  
  19.     }  
  20.     while(cin>>n){  
  21.         if(n>64||n<1){  
  22.             cout<<"ERROR!"<<endl;  
  23.             continue;  
  24.         }   
  25.         cout<<b[n]<<endl;  
  26.     }   
  27.     return 0;  
  28. }  


此时利用上面的算法，我们就可以模拟出移动的步骤了，

模拟移动步骤的C++实现：

[cpp] view plaincopy
  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. void move(int n, char a, char b){  
  5.     cout<<a<<"->"<<b<<endl;  
  6. }   
  7.   
  8.   
  9. void hanoi_basic_3(int n, char a, char b, char c){//把n个盘子从a柱子移动到b柱子   
  10.     if(n > 0) {  
  11.         hanoi_basic_3(n - 1, a, c, b);// 把n-1个盘子移动到b柱子上  
  12.         move(n, a, b);  // 把a移动到b   
  13.         hanoi_basic_3(n - 1, c, b, a);  // 把第n个盘子移动到b柱子上  
  14.     }  
  15. }  
  16.   
  17. void hanoi(int n, char a, char c, char b, char d, int C[]){  
  18.     int j=C[n]; //j个盘子使用四个柱子的移动方式   
  19.     if(n > 0) {  
  20.         hanoi(j, a, d, b, c, C);// 把j个盘子移动到d柱子上  
  21.         hanoi_basic_3(n - j, a, c, b);// 把n-j个盘子移动到c柱子上（使用三个柱子的移动方式）   
  22.         hanoi(j, d, c, a, b, C);    // 把j个盘子移动到c柱子上  
  23.     }  
  24. }  
  25.   
  26. int main()  
  27. {  
  28.     int n,flag_j;     
  29.     double A[65];  //未加第四个柱子时候的移动次数情况   
  30.     A[1]=1;  
  31.     for(int i=2;i<65;i++) A[i]=2*A[i-1]+1;   
  32.     double B[65],flag,min;  
  33.     int C[65]; //把前 c[j]个元素用四个柱子的方法，后i-j 个元素用三个柱子的方法   
  34.     C[1]=0;  
  35.     C[2]=0;  
  36.     for(int i=3;i<=64;i++){  
  37.         min=A[i];  //数组A代表没加第四个柱子的结果次数，数组b代表加了第四个柱子的结果次数   
  38.         B[1]=1;  
  39.         B[2]=3;  
  40.         flag_j=0;  
  41.         for(int j=1;j<i;j++){  
  42.             flag=2*B[j]+A[i-j]; //j个移动到第四个柱子，然后把剩下的i-j个在第四个不能用的情况下移到第三个   
  43.             if(min>flag) {  
  44.                 min=flag;  
  45.                 flag_j=j;  
  46.             }  
  47.         B[i]=min;  
  48.         C[i]=flag_j;   
  49.         }  
  50.     }  
  51.     while(cin>>n){  
  52.         char a='a',b='b',c='c',d='d';  
  53.         hanoi(n,a,c,b,d,C);   //把n个盘子从a柱子移动到c柱子  
  54.     }  
  55.     return 0;  
  56. }  

0 0
pc端前端数据渲染 pc端前端数据渲染
原创粉丝点击
热门IT博客
淘宝 聚划算淘宝 聚划算
船舶设计用什么软件船舶设计用什么软件
打开ip端口
临沂软件培训
数字图像处理算法应用
海康安防 js
瓦尔登湖 知乎 译本
mac date 修改时间
大数据运算系统架构
王夫之的思想主张知乎
淘宝买家信用怎么看
大数据在生活中的应用
minimax regret算法
mac版acrobat x pro
房地产前期大数据
淘宝店花呗开通条件
.shop域名
大数据分析方法与应用
开源中国 cms
pdf阅读器推荐 知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 贱宗首席弟子 逍遥弟子都市行 弟子拜见师尊 弟控 我的姐姐是弟控 我有个弟控的姐姐 我有个弟控姐姐 弟控姐姐 弟控哥哥养成诱受呆萌弟弟 龙tory弟控病娇囚禁 弟控的综漫之旅下载 综漫弟控的哥哥们 女主是病娇弟控而且囚禁 弟控的综漫之旅 天下弟控都去死 秋古 我有个弟控的姐姐 小滨块 斑的弟控之路 都市之我的姐姐是弟控 新网王之平等院弟控 弟鸟胡鸟怎么读 一个弟一个鸟念什么 把逼张开往里捅 张笔画 张字 张的名字 张起名字大全男孩 张姓名字大全男孩 姓张取名 张姓 姓张的男孩名字洋气的 张的繁体字 张性 張 张繁体字 九张牌 张ziyan 张qianyi 张一指 张一碗米线怎么样 张一共有几画 张一碗过桥米线

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里