经典详解
：
如下图所示，从左到右有A、B、C三根柱子，其中A柱子上面有从小叠到大的n个圆盘，现要求将A柱子上的圆盘移到C柱子上去，期间只有一个原则：一次只能移到一个盘子且大盘子不能在小盘子上面，求移动的步骤和移动的次数
移动次数为：2^n - 1
实现算法可以简单分为三个步骤：
（1） 把n-1个盘子由A 移到 B；
（2） 把第n个盘子由 A移到 C；
（3） 把n-1个盘子由B 移到 C；
从这里入手，在加上上面数学问题解法的分析，我们不难发现，移到的步数必定为奇数步：
（1）中间的一步是把最大的一个盘子由A移到C上去；
（2）中间一步之上可以看成把A上n-1个盘子通过借助辅助塔（C塔）移到了B上，
（3）中间一步之下可以看成把B上n-1个盘子通过借助辅助塔（A塔）移到了C上；
java:
package demo;
import java.util.Scanner;
public class TowersOfHanoi {
static int m =0;//标记移动次数
//实现移动的函数
public static void move(int disks,char N,char M)
{
System.out.println("第" + (++m) +" 次移动 : " +" 把 "+ disks+" 号圆盘从 " + N +" ->移到-> " + M);
}
//递归实现汉诺塔的函数
public static void hanoi(int n,char A,char B,char C)
{
if(n == 1)//圆盘只有一个时，只需将其从A塔移到C塔
TowersOfHanoi.move(1, A, C);//将编b号为1的圆盘从A移到C
else
{//否则
hanoi(n - 1, A, C, B);//递归，把A塔上编号1~n-1的圆盘移到B上，以C为辅助塔
TowersOfHanoi.move(n, A, C);//把A塔上编号为n的圆盘移到C上
hanoi(n - 1, B, A, C);//递归，把B塔上编号1~n-1的圆盘移到C上，以A为辅助塔
}
}
public static void main(String[] args) {
Scanner imput = new Scanner(System.in);
char A = 'A';
char B = 'B';
char C = 'C';
System.out.println("******************************************************************************************");
System.out.println("这是汉诺塔问题（把A塔上编号从小号到大号的圆盘从A塔通过B辅助塔移动到C塔上去");
System.out.println("******************************************************************************************");
System.out.print("请输入圆盘的个数：");
int disks = imput.nextInt();
TowersOfHanoi.hanoi(disks, A, B, C);
System.out.println(">>移动了" + m + "次，把A上的圆盘都移动到了C上");
imput.close();
}
}
C
#include <stdio.h>
void hanoi(int i , char A , char B , char C);
void move(int i , char x , char y);
int main(void)
{
int n ;
printf("请输入n的值：");
scanf("%d",&n);
hanoi(n , 'A' , 'B' , 'C');
return 0 ;
}
void hanoi(int i , char A , char B , char C)
{
if(i > 0)
{
hanoi(i - 1 , A , C , B); //函数递归调用
move(i , A , C);
hanoi(i - 1 , B , A , C);
}
}
void move(int i , char x , char y)
{
static int c = 1 ; //局部变量i申明为 static
//在局部变量申明中放入static可以使变量具有静态存储期限而不再是自动存储期限，拥有永久的存储单元，
//所以在整个程序执行期间都会保留变量值，如代码中第33行定义的局部变量 i , 在每次的函数调用时保留该值 ，若不加static则 i 的值在每次调
//用move函数时都会进行初始化
printf("%d: %d from %c ——> %c \n", c++ , i , x , y);
}
C++:
#include <bits/stdc++.h>
int count=0; //用来计步；
void hanoi(int n, char A, char B, char C) //n为盘子的个数，A是最左边柱子，C是最右边柱子，B是中间柱子；
{
if(n==1){
printf("The %d step : %c -> %c\n",++count,A,C); //只有一个盘子，直接从A移动到C；
return;
}
hanoi(n-1, A, C, B); //n-1个盘子，把前n-1个移动到B柱子，最后一个移动到C柱子，再把n-1个从B移动到C；
printf("The %d step : %c -> %c\n",++count,A,C);
hanoi(n-1, B, A, C); //第n个盘子移完后，从B上把n-1个移到C上；
}
int main()
{
int n;
scanf("%d",&n);
hanoi(n, 'A', 'B', 'C');
return 0;
}
扩展见识:
计数法2,3进制解决
Hanoi双塔问题（动态规划，高精度）
楚继光：“防御系统还真有用，修罗王的魔法炮阵的火力果然减弱了，但好像还差一点点啊？”
墨老师：“哦，是吗，那试试双塔防御体系吧。”
如图所示，给定A，B，C三根足够长的细柱，在A柱上放有2n个中间有空的能量圆盘，共有n个不同的尺寸，每个尺寸都有两个相同的圆盘，注意这两个圆盘是不加区分的，图为n=3的情形。现要将这些圆盘移到C柱上，在移动过程中可放在B柱上暂存。每次只能移动一个圆盘，每个柱子的圆盘保持上小下大的顺序。要求输出最少移动次数。
输入
一个正整数，表示A柱上有2n个圆盘。
输出
仅一行，包含一个正整数，为最少移动次数。
样例输入
2
样例输出
6
提示
对于100%数据，1≤n≤200。
思路：
计算n在=1,2,3,4等情况下的结果，可推得p[i]=2p[i-1]+2;p[i-1]=将除底座圆盘以外的所有盘移至b位的次数，2p[i-1]=将除底座圆盘以外的所有盘移至c位的次数,2=将底座圆盘移至c位的次数，
因为n<=200，所以要用高精度求解
解1：
先找出An的通项公式，而两个相同的圆盘移动方法和一个圆盘的移动方法差不多，只要最后再乘二就好了，先考虑每种大小一个圆盘
而显然An=2*An-1+1，就相当于先把上面n-1个圆盘先挪走，再挪最大的，再把n-1个挪到它上面
又因为A1=1，因此有An=2n-1，最后再乘二，An=2(n+1)-2
写的话用高精度，算出2^(n+1)，注意到2的幂的个位数字是2，4，8，6，所有再减二的时候不用考虑退位
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int a[205];
int n,len,newl;
int main()
{
scanf("%d",&n);
a[1]=2;
len=1;
for(int j=1; j<=n; j++)
{
if(a[len]>=5)
newl=len+1;
else newl=len;
for(int i=len; i>=1; i--)
{
a[i]=2*a[i];
if(a[i]>=10)
{
a[i+1]=a[i+1]+1;
a[i]=a[i]-10;
}
}
len=newl;
}
a[1]=a[1]-2;
for(int i=len; i>=1; i--)
printf("%d",a[i]);
return 0;
}
解2：
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <cstdio>
#include <string>
#include <vector>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
#define inf 1000000007
typedef long long ll;
using namespace std;
int s[420];
int main()
{
int n,i,ct,x;
scanf("%d",&n);
s[0]=2;
if(n==1)
printf("%d\n",s[0]);
else
{
ct=1;
n--;
while(n--)
{
x=0;
for(i=0; i<ct; i++)
{
s[i]=s[i]*2+x;
if(i==0)
s[i]+=2;
x=s[i]/10;
s[i]%=10;
}
s[ct]+=x;
if(s[ct])
ct++;
}
for(i=ct-1; i>=0; i--)
printf("%d",s[i]);
printf("\n");
}
return 0;
}
四塔问题
问题描述：在经典汉诺塔的基础上加一个条件，即，如果再加一根柱子（即现在有四根柱子a,b,c,d)，计算将n个盘从第一根柱子(a)全部移到最后一根柱子(d)上所需的最少步数，当然，也不能够出现大的盘子放在小的盘子上面。注：1<=n<=64;
分析：设F[n]为所求的最小步数，显然，当n=1时，F[n]=1;当n=2时，F[n]=3;如同经典汉诺塔一样，我们将移完盘子的任务分为三步：
（1）将x(1<=x<=n)个盘从a柱依靠b,d柱移到c柱，这个过程需要的步数为F[x];
（2）将a柱上剩下的n-x个盘依靠b柱移到d柱（注：此时不能够依靠c柱，因为c柱上的所有盘都比a柱上的盘小）
些时移动方式相当于是一个经典汉诺塔，即这个过程需要的步数为2^(n-x)-1；
（3）将c柱上的x个盘依靠a,b柱移到d柱上，这个过程需要的步数为F[x];
第（3）步结束后任务完成。
故完成任务所需要的总的步数F[n]=F[x]+2(n-x)-1+F[x]=2*F[x]+2(n-x)-1;但这还没有达到要求，题目中要求的是求最少的步数，易知上式，随着x的不同取值，对于同一个n，也会得出不同的F[n]。即实际该问题的答案应该min{2*F[x]+2^(n-x)-1},其中1<=x<=n;在用高级语言实现该算法的过程中，我们可以用循环的方式，遍历x的各个取值，并用一个标记变量min记录x的各个取值中F[n]的最小值。
数值不是很大，int完全可以搞定
#include<stdio.h>
#include<math.h>
#define M 99999999
void main()
{
int i,n,x,min,f[65];
f[1]=1;
f[2]=3;
for(i=3;i<=65;i++)
{
min=M;
for(x=1;x<i;x++)
if(2*f[x]+pow(2,i-x)-1<min)
min=2*f[x]+(int)pow(2,i-x)-1;
f[i]=min;
}
while(~scanf("%d",&n))
printf("%d/n",f[n]);
}
1795
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
