汉诺塔问题学习报告

汉诺塔问题学习报告

一.基本汉诺塔的最少移动步数求解

  • (如解析和参考有错误或可以精进之处,欢迎批评指正。)

法国数学家爱德华·卢卡斯曾编写过一个印度的古老传说:在世界中心贝拿勒斯(在印度北部)的圣庙里,一块黄铜板上插着三根宝石针。印度教的主神梵天在创造世界的时候,在其中一根针上从下到上地穿好了由大到小的64片金片,这就是所谓的汉诺塔。不论白天黑夜,总有一个僧侣在按照下面的法则移动这些金片:一次只移动一片,不管在哪根针上,小片必须在大片上面。僧侣们预言,当所有的金片都从梵天穿好的那根针上移到另外一根针上时,世界就将在一声霹雳中消灭,而梵塔、庙宇和众生也都将同归于尽。
不管这个传说的可信度有多大,如果考虑一下把64片金片,由一根针上移到另一根针上,并且始终保持上小下大的顺序。这需要多少次移动呢?
(来源 百度百科)

这就是最基本的汉诺塔问题。

一个未移动过的汉诺塔模型。例题1:现在有一个N层的汉诺塔,要解决这个汉诺塔问题,至少要移动多少步? (难度1)

汉诺塔的特点就在于小的只能放在大的上面,这也是解题的关键。
设a[N]表示解决N层汉诺塔的最少步数,每一层表示为a,b,c,…。
显然a[1]=1。
解决2层的时候,先把a放在B柱以腾出C柱,然后把b放在C柱,再把a放到C柱。因此a[2]=3。
那么怎么求解a[3]呢?我们依照a[2]的思路来考虑:为了完成任务,我们需要把c放到C柱,在此之前a、b应该已经放在B柱(否则不可能使c被拿出来),然后再把a、b叠在C柱。移动a、b的过程中完全可以忽略c的影响,因此解法就变为:先使a、b组成的2层汉诺塔ab叠在B柱,再把c放在C柱,最后把ab放在C柱。因此a[3]=a[2]+1+a[2]=2 * a[2]+1。
综上所述,对于一个N层的汉诺塔,先在B柱完成一个(N-1)层的汉诺塔,然后把n放在C柱,最后在B柱完成一个(N-1)层的汉诺塔,a[N]=2 * a[N-1]+1。(核心结论1)
这样一来,基本汉诺塔求解的递推式已经得出,剩下的就不是难事了。
核心代码:

int a[101],n;
scanf("%d",&n);
a[0] = 0;
for(i = 1;i <= n;i++){
	a[i] = 2 * a[i - 1] + 1;
}
printf("%d",a[n]);

(注意:递推法不要忘记给起始条件)

除此之外,根据算出的结果,还可以发现a[N]=2^N-1(使用的时候可能需要配合快速幂)。这样就得出了一种汉诺塔步数问题的结果式。

因此我们可以知道,要想毁灭世界(我相信他们做这个的目的不是为了毁灭世界而只是为了忽悠人),需要操作汉诺塔2^64-1次。假设这群僧侣能做到每时每刻都有人在操作它,而且手速快到2秒中就能操作一次、耐心到即使一直在操作也不会搞错,也需要上万亿年。这是什么概念,假设僧侣从这一刻开始操作,那么即使到了太阳毁灭的那一天(这应该才是真的世界末日),他们也才刚操作完5%。

和基本的汉诺塔直接相关的还有双塔问题(无非就是原式的基础上全部乘2)。但是值得思考的是下面这个问题:

思考题:小明同学已经学会了汉诺塔怎样操作最快,现在他买了两套汉诺塔,一套为白色,一套为黑色。他把这两套汉诺塔各取出N层大小完全相同的部分,如下图所示摆放。若同样大小的层可以互相堆叠,且堆叠时不必考虑颜色差别,该汉诺塔最快需要多少步才能完成,此时颜色是否与原来的分布完全一致?(难度2)
思考题
很显然,颜色与原来的分布是不一致的,因为如果不考虑颜色,完全可以直接把不同色的同样大小的两层看作一层,就是双塔问题;但是如果考虑颜色,且希望在整个操作过程中都严格要求同色不能叠加,其实就是一个2N层的单塔;如果过程中不作要求,最下方的一层也肯定要分成黑白两色操作。篇幅有限,具体的最少步数在此就不作说明了。

二.汉诺塔操作的模拟

汉诺塔模拟的难度是大幅高于求解的难度的,为了模拟这一过程,既需要我们明白汉诺塔问题求解的根本方法,也需要我们熟练地掌握递归(显然后者更难一些)。

例题2:现在有一个N层的汉诺塔,单数层为白色,双数层为黑色。现在要将这个汉诺塔移动到B柱上,且操作过程中不允许相同颜色的层叠在一起。试模拟这个汉诺塔的操作过程,并在最后输出总操作步数。(难度3)
例题2
首先需要说明的是,这题的颜色纯粹是一个干扰项,因为即使没有这个限制在操作的时候也是一样的(原因下面会解释到)。
根据我们得出的核心结论,解决各种汉诺塔问题的关键就在于第N层这个分界点。 同样来思考这个模拟,我们肯定要保证最终n从A移动到B,而为此,我们需要在此之前把所有n上面的这(N-1)个层全部移到C柱去,但是为了把n-1移到C柱去,还得保证n-2要移到B柱去……如上,一个前半部分的递归方案就基本成型了。后半部分同理,(N-1)个层全部都在C柱,为了使n-1到B柱,又需要使n-2到A柱……这个过程在上半部分回溯的时候就可以得到解决。
核心代码如下:

int count;
void Move(int n, char a, char b){
    count++;
    printf("%d %c %c\n",n,a,b);
}
void Hanoi(int n, char a,char b,char c){//注解
    if(n == 1) Move(n,a,c);
    else{
    	Hanoi(n - 1,a,c,b);
    	Move(n,a,c);
		Hanoi(n - 1,b,a,c);
    }
}
int main(){
    int n;
    scanf("%d",&n);
    Hanoi(n,'A','B','C');
    printf("%d",count); 
    return 0;
}

(注:a相当于起点,b相当于终点,c相当于中转)

解决了这一问题,再来看下面这个问题:

例题3:(P1242 新汉诺塔)(难度5)
例题3
此题又是一个模拟,这题由于不像例题2初始和结果那么有规律,所以有很多东西需要我们运用刚才的经验。
根据上一道题的经验(又或者说是没有根据),我们最终的目的是把每一层放到他该去的地方,而且在此之前要腾出给他的空间。因此我们应该从大到小循环进入递归,直到每一层都归位为止。
同时我们要注意到这道题的无规律性,所有盘在移动过程当中的操作确确实实需要我们手动模拟,因此要即时地改变每一个盘的所在位置。
核心代码如下:

struct yjx{
	int from,to;
}a[101];//记每一层所在位置为from,目的地为to
int n,sum;
void hanoi(int x,int y){//把x移动到y位置去
	if(a[x].from == y) return;//已到达的不必再排
	else{
		int i;
		for(i = x - 1;i >= 1;i--) hanoi(i,6 - (a[x].from + y));//注解1
		printf("move %d from %c to %c\n",x,a[x].from - 1 + 'A',y - 1 + 'A');//注解2
		a[x].from = y;
		sum++;
	}
}
int main(){
	......//输入部分略过
	for(i = n;i >= 1;i--) hanoi(i,a[i].to);
	printf("%d",sum);
	return 0;
}//此题很容易混淆x和i、a[x].from和x,要多加注意

(注1:这里的6-(a[x].from + y)其实求的是某个盘的当前位置和目的地以外的那个柱,因为三个柱的和是6)
(注2:这里的一番操作是要把1、2、3转化为A、B、C)

就在我们愉快地AC(对多数人来说应该也是AK)比赛之后,把这道题交回到洛谷上冲业绩的时候,我们却发现这只能得到90分,打开最后一个点,给出了一个看起来相当人畜无害的输入文件:
在这里插入图片描述
这个的结果显然应该是五步,但是程序结果如下:
在这里插入图片描述
为什么?
(注意:以下完全属于本人分析,因此可能存在大量极其复杂反人类的内容,难以接受不建议阅读)
根据我们的程序,我们总是在为更大的让出位置,只有完全腾出位置才会继续向更小的考虑,程序当中就是先把1、2两层堆到了B柱,完全腾出C柱后才继续向A柱操作。但事实上这没必要,其实最快的方案应该是3给12腾出A柱,让1、2先在A柱操作完,然后把3移到C柱。
分析一下可以知道,之所以最快的方案比我们的代码还快,是因为我们的代码当中总是移动小的,使大的先到目的地以防止讨论大小;但这恰恰意味着,大的限制了小的到达目的地,使得小的总要先全部移到非目的地的柱才能进行下去。
在此之前,我们试验了一下,对于我们90分的代码,如果把输入数据中3的初始位置就设成B柱,结果是4步,也就是最少步数。因此我们不必推翻过去的代码,只要适当的插入操作,使得这个特殊的操作强行先于接下来的部分就可以了。
首先我们明确,如果这个盘本身可以以原方式操作,那么就不必再进行特殊操作(毕竟特殊操作是插入的,错误的插入会导致强行多了一步完全没用的操作)。因此就需要严密的讨论。
这里我们不妨举出反例:什么时候我们不能无视大小直接移动这个盘?
首先既然我们要求可以无视大小,那么就得保证它是最上面的一个 (强行操作也是要符合基本法的) 。因此如果它不是,就不能特殊操作。
其次,我们腾出空间是因为后面的盘可以直接到达目的地,如果压根没有哪一个盘到达它所在的位置,就不必腾出这个空间,不能特殊操作。
另外,由于我们要把这个盘放到一个中转柱,如果这个盘比中转柱上的任意一个盘大,那就不能特殊操作;如果下面确实有比它大的,如果这些盘已经到了目的地,我们的特殊操作就没有影响,可以操作;如果没有到的话,以后还是要移走让下面的大盘去目的地,也没有影响,也可以操作。
考虑到这三点,就已经算是比较全面的了。综合一下,可以得出以下的结论:
要想进行这个特殊操作,要保证我们要移动的盘所在的柱没有任何的盘挡在上面,而且我们要移到的中转柱上原来的盘都比它大(全称);除此之外,要保证盘所在的位置是还未到达的至少一个盘的目的地(存在)。
因此特判如下:

void hanoi(int x,int y){
	if(a[x].from == y) return;
	else{
		int i;
		lipu = 0,telipu = 1;
		for(i = n;i >= 1;i--){
			if(a[i].from == 6 - (a[x].from + y) && i != x && a[i].from != a[i].to || a[i].from == a[x].from && i < x || a[i].to == 6 - (a[x].from + y) && a[x].to != a[x].from){
				lipu = 1;//前两条
				break;
			}
		}
		if(lipu == 0){
			for(i = n;i >= 1;i--){
				if(a[x].from == a[i].to && x != i && a[i].from != a[i].to){
					telipu = 0;//第三条
					break;
				}
			}
		}
		......//特判条件:lipu和telipu都为0

这个时候我们就已经战胜了洛谷并拿到了AC。

只是我们还是要思考一下:
为了使得总移动数尽可能少,要使得1到n-1这一堆的移动次数尽可能的少。因此如果有条件可以先移动大盘到目的地,这样有可能使n-1堆少移动一次,节省很多操作;但是如果操作大盘的过程中n-1层反复操作多组,操作就会变多。这一过程很难特判,因此我们尝试分类比较,先按照从大到小的基本思想操作,再按照优先移大的思想操作,比较一下究竟哪一种操作少,然后单独输出这一种的操作过程就可以了。
核心代码如下:

struct yjx{
	int from,to;
}a[3][101];
int n,sum,ans[3];
bool go;
void hanoi(int w,int x,int y){//注解1
	if(a[w][x].from == y) return;
	else{
		int i;
		for(i = x - 1;i >= 1;i--){
			if(a[w][i].from != 6 - (a[w][x].from + y)) hanoi(w,i,6 - (a[w][x].from + y));
		}
		if(go == 1) printf("move %d from %c to %c\n",x,a[w][x].from - 1 + 'A',y - 1 + 'A');
		a[w][x].from = y;
		sum++;
	}
}
int main(){
	for(i = n;i >= 1;i--) hanoi(1,i,a[1][i].to);
	ans[1] = sum;
	sum = 0;
	for(i = n;i >= 1;i--){
		if(a[2][i].from != a[2][i].to){
			hanoi(2,i,6 - (a[2][i].from + a[2][i].to));
			break;//只需要操作一次
		}
	}
	for(i = n;i >= 1;i--) hanoi(2,i,a[2][i].to);
	ans[2] = sum;
	go = 1;
	if(ans[1] <= ans[2]){
		for(i = n;i >= 1;i--) hanoi(0,i,a[0][i].to);
	}
	if(ans[1] > ans[2]){
		for(i = n;i >= 1;i--){
			if(a[0][i].from != a[0][i].to){
				hanoi(0,i,6 - (a[0][i].from + a[0][i].to));
				break;
			}
		}
		for(i = n;i >= 1;i--) hanoi(0,i,a[0][i].to);
	}
	printf("%d",min(ans[1],ans[2]));
	return 0;
}

(注1:这里多了一个w,是用来记录代表的是方法1,方法2还是答案。因为我们要操作三次,每次都是从初始状态开始操作,因此需要一个二维数组,省去初始化的麻烦)
这道题给了我们一个启发:
一个汉诺塔问题有时可以拆分成多个塔的操作,为了使一个汉诺塔整体操作步数尽可能少,要使其层数最多的那一部分操作次数尽可能少。(核心结论2)

三.汉诺塔变形问题

这部分在6.24日进行了一次更新,填上了之前留下的坑,同时加了一些新的东西。
洛谷上也就剩下一道汉诺塔的黑题我没做,所以此帖基本完结撒花了。

例题4(奇怪的汉诺塔):
小华现在有一个奇怪的汉诺塔,这个汉诺塔有4个柱子。现在小华有一个N层的汉诺塔,试计算出解决这个汉诺塔问题需要的最少步数。
(难度3.5)
这道题相比刚才那些费脑筋的递归还是要简单一些的。现在我们面对的是一个四柱问题,但是如果我在某一柱上放下M个,剩下的(N-M)个就构成了一个三柱问题。记res[i]为四柱的最少步数,res1[i]为三柱的最少步数(这一数组应该已经提前准备好值),有递推式为:

res[i] = 2 * res[j] + res1[i - j]

这样问题就得到解决了。

现在考虑一下,这个问题能否扩展到m个柱?
很显然,m只有不小于3的时候问题才是有意义的。根据三柱变四柱的经验,对于m个柱,理论上可以拆成m柱和(m-1)柱的问题,(m-1)柱又能再拆,直到只剩下三个柱。这样复杂度理论上应该是O((m-2)n^2),三柱属于特殊情况,是O(n)。不过只作为一个思考题,实际上估计不会考。(当然,正确性还有待验证)

最后做一道更难一些的题目:
例题5 汉诺塔(洛谷P4285)
这题先把题审一遍,大概有这么几个特点:
1 移动规则有优先度区分;
2 刚刚移动过的不能再移动。
首先1肯定是这题的难度所在。
而通过2我们能发现一个问题:现在有ABC三个柱,刚才移动过的盘占一个柱,而剩下两个柱的盘子大小又不一样。因此在任何一个状态下,都只可能有一个起点。所以说在这个优先度区分当中,起点的先后顺序完全无意义(也就是说,Ax - Bx - Cx和Ax - Cx - Bx完全一样),所以我们只需要考虑第二位。
首先,我们明显能看出来,AB-BC和AB-BA是不同的两种情况。还是通过整体法研究,
一种是把(n-1)个盘子放到B,然后把n放到C,然后把(n-1)个从B移到C。
另一种则是先把(n-1)个盘子放到B,然后把n放到C,之后把(n-1)个放回A,再把C放到B,最后把(n-1)个放到B。
很显然,对于这两种情况,一种的递推式是a1[n] = a1[n - 1] * 2 + 1,另一种则是a2[n] = a2[n - 1] * 3 + 2.
这里我们还发现,AB-BA型会与AB-BC型产生区别,那么这种规律也适用于第三组吗?
假设是适用的,不妨称前一种为逆序,后一种为顺序,那么AB-BA接的下一位理论上是什么都无所谓,毕竟CA和CB都不能构成逆序。但是AB-BC-CB和AB-BC-CA就不同了,前者是一个逆序,后者则是一个顺序。
为了验证这一组是否有区别,刚才的整体法恐怕不能解决(毕竟我们刚才用整体法就没看出区别),所以我们具体分析一下。
按照我们的定义,前者是前顺序后逆序,后者全部是顺序,那么理论上就应该是a1[]和a2[]的组合。
有了这个心理准备,通过n=3的问题进行了一波模拟。可以发现,这个区别发生在3在B柱而12在C柱的时候。如果是后者,那么1直接到A,最终会在B柱结束,和a1完全相同;而前者的1会到B,导致3移动到A,1再移动到C,这之后才能组合到B位置,比后者多了两步。
在最后一个盘子移动之前,这两者的移动规律并没有区别。区别就在于12,不考虑3,我们发现,前者的移动规律和a2相同。也就是说,两个顺序的组合,结果就是a1;而先顺序后逆序,是新的一个结果,记作a3。
对这个单独分析,如果再加上4,4移动到C,然后1移动到C,2移动到A,1再次回到2。不用再模拟下去了,这时候显然已经是a2的走法了。因此对于第三种情况,前半段是a3,后半段是a2,即a3[n]=a2[n]+a3[n]+1,我们一开始的猜测是合理的。
再加上最开始的推论,我们只需再讨论以AC开头的方式,就完全足以覆盖所有的情况了。这样此题就解决了。
总结一下,这道题是一道非常有难度的汉诺塔问题,我们既要利用汉诺塔整体性分类,还要通过模拟等方式研究更细的操作规律,分析得出最终结论。这就需要我们能够熟练的运用各种方式进行递推式的分析,相当考验思维和基本功底,是一道非常有趣的题目。
完整代码如下:

仅供参考,如有更好的写法和思路,欢迎在评论区分享。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
long long res[4][41];
void pre(){
	int i,j;
	for(i = 1;i <= 3;i++){
		res[i][1] = 1;
		if(i == 1){
			for(j = 2;j <= 40;j++) res[i][j] = res[i][j - 1] * 2 + 1;
		}
		if(i == 2){
			for(j = 2;j <= 40;j++) res[i][j] = res[i][j - 1] * 3 + 2;
		}
		if(i == 3){
			for(j = 2;j <= 40;j++) res[i][j] = res[i - 1][j - 1] + res[i][j - 1] + 1;
		}
	}
}
int s1[4][3];
int main(){
	int n,i,op,temp1,temp2;
	char s[7][3];
	scanf("%d",&n);
	pre();
	for(i = 1;i <= 6;i++){
		scanf("%s",s[i]);
		s1[s[i][0] - 'A' + 1][s[i][1] - 'A' + 1] = i;
	}
	//for(i = 1;i <= 3;i++) printf("%d/%d ",s1[i][1],s1[i][2]);
	if(s1[1][2] < s1[1][3]){//AB > AC
		if(s1[2][1] < s1[2][3]){//BA > BC
			op = 2;
		}
		else{
			if(s1[3][2] < s1[3][1]){//CB > CA
				op = 3;
			}
			else op = 1;
		}
	}
	else{//AC > AB
		if(s1[3][1] < s1[3][2]){//CA > CB
			op = 2;
		}
		else{
			if(s1[2][3] < s1[2][1]){//BC > BA
				op = 3;
			}
			else op = 1;
		}
	}
	printf("%lld\n",res[op][n]);
	return 0;
}

总而言之,汉诺塔问题是一个前后规律性强而又能千变万化的题型,对我们的递归和递推以至于数学逻辑能力都是不小的考验,要善于化总体为部分、化复杂为简单。
Thank you for reading!

  • 10
    点赞
  • 8
    收藏
  • 打赏
    打赏
  • 10
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:1024 设计师:我叫白小胖 返回首页
评论 10

打赏作者

Hanoist

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值