杭电 汉诺塔问题总结

看了一下杭电的各种汉诺塔问题,遇到些奇奇葩葩的小问题,也有很多很好的思想,比如最后一题,来来回回的颠倒很有意思。总结一下;

Pro.ID 1207 :http://acm.hdu.edu.cn/showproblem.php?pid=1207

意思是给把原始的汉诺塔问题中的3根柱子改为4根。做了半天各种WA。查了一下,有一篇文章详细讲了一下,还做出了递归公式以及数学公式:

地址如下:http://www.cnblogs.com/fanzhidongyzby/archive/2012/07/28/2613173.html.

代码如下:

#include<cstdio>
#include<cmath>
#include<algorithm>
//F(n)=min(2*F(n-r)+2^r-1),(1≤r≤n)
using namespace std;
int main()
{
    int n,m;
    long long Min,f[65];
    f[1]=1;
    f[2]=3;
    for(int i=3;i<=65;i++)
    {
        Min=99999999;
        for(int j=1;j<i;j++)
            Min=min(2*f[j]+pow(2.0,i-j)-1,Min*1.0);
        f[i]=Min;
    }
    while(~scanf("%d",&n))
        printf("%lld\n",f[n]);
    return 0;
}

按照公式写就是了,写的时候需要注意一下精度问题。2^r可以写为1<<r,不过因为数字常数1默认是32位,所以如果要使用位移的话,一定要先声明一个longlong类型的变量来进行位移,否则 就会出现溢出错误,这个我纠结了一阵子,感觉没错,一提交就WA,然后试了试64发现果然是负数。

哎,基础还是不扎实啊。

用pow函数因为返回的是一个double类型,min函数里比较也是用double来做的,只是在最后赋值的时候取int型就可以,所以不会出错。

Pro.ID  1995 汉诺塔V

http://acm.hdu.edu.cn/showproblem.php?pid=1995

这个是普通的汉诺塔,最优的步数是2^n-1,只不过问的第i个盘子移动的次数。依然是用递归,在纸上画画就能出来。

注意了,第i盘子,不用考虑底下的盘子,只用看之上的经过一个柱子到达目的地。即F[n]=2*f[n-1]

代码:

#include<iostream>

using namespace std;

int
main()
{
    __int64 s[61] = {0, 1};
    int n, i, t, m;

    for(i = 2; i < 61; i++)
        s[i] = s[i - 1] * 2;

    cin >> t;
    while(t--)
    {
        cin >> n >> m;

        cout << s[n - m + 1] << endl;
    }
}

Pro.ID 汉诺塔VI

http://acm.hdu.edu.cn/showproblem.php?pid=1996

是问所有步骤,注意不是最优的,是全部(当然不包括错误的步骤)

每一个盘子可以放到3根柱子的任意一个,所以是3^n。比如正确的是直接从a->c,现在可以a->b然后在b->c,就是多了2种。每一个都多了2种,所以是3^n。

代码:

#include<iostream>
#include<math.h>
#include<stdio.h>
using namespace std;
int main()
{
    __int64 t,n,i;
    __int64 sum,a[100]={3,};
    while(cin>>t)
    while(t--)
    {
        cin>>n;
        for(i=1;i<n;i++)
        a[i]=a[i-1]*3;
        cout<<a[n-1]<<endl;
    }
    return 0;
}

Pro.ID 1997 汉诺塔VII

http://acm.hdu.edu.cn/showproblem.php?pid=1997

题目是说,给定某一时刻的三个柱子上的盘子,问这个是不是符合最优解过程中某一时刻的状态。

思想是:

对一个含有n个盘子,从A柱移动到C柱借助B柱的汉诺塔,第n个盘子移动到C柱过程是这样子的:首先将其余的n-1个盘子移动到B柱,然后第n个盘子直接移动到C柱。在这过程中,第n个盘子只出现在A柱和C柱两个柱子上,也即第n个盘子不可能出现在B柱上。因此对于当前移动的盘子,只需检查其所在的柱子是否符合这个要求,如果出现在B柱上,则显然进入了错误移动中。这是本题求解思想精髓所在。

具体的内容请参考这篇博客:http://blog.csdn.net/z690933166/article/details/8605261

代码就不贴了,上边这个博客里写的很详细。

Pro.ID 2064 汉诺塔III

http://acm.hdu.edu.cn/showproblem.php?pid=2064

还是递推:num[i]=3*num[i-1]+2;

不解释了,代码如下:

#include<iostream> 
#include<cstdio>  
#include<cstring> 
#include<cmath>    
using namespace std;      
unsigned long long num[36];
int main()
{              
    num[1]=2;
    num[2]=8;
    for(int i=3;i<=35;i++)
        num[i]=3*num[i-1]+2;
    int n;
    while(~scanf("%d",&n))
        cout<<num[n]<<endl;
    return 0;
}

Pro.ID 2077 汉诺塔IV(参考了
zz_zigzag的博客)

http://acm.hdu.edu.cn/showproblem.php?pid=2077

好无聊啊,把上边的规则给改了,只是最大的可以放上边。其实感觉这个题目跟之前那个1027题目有点想通之处,在1027中说的是4根柱子,所以通用的这3个步骤其实并非最优解:

(1)       1柱借助3…M柱子将n-(M-2)个盘子移动到2柱上。

(2)       M-2个通过3…M-1柱简单的移动到M柱上【2*(M-2)-1步骤】。

(3)       2柱借助13…M-1柱子将n-(M-2)个盘子移动到M柱上。

如果有n个盘子,则需要前n-1个挪到中间的盘子上,然后最大的盘子挪到最右面,需要两步,把前(n-1)个盘子从左边挪到中间是和从中间挪到右边需要相同的次数。而a数组中存放的就是那个前n-1个盘子挪动到相同位置需要的次数。结果即为a[i-1]*2+2。

所以我直接想成了是f[n]=2*f[n-1]+2,结果错了。【因为是需要n-1个盘子前进一步】

而求a数组需要用到递推。公式为第i个为前n-1个移动次数的三倍加一,简化到两个盘子,小的先移动两次到最右边,大的移到中间,然后小的在移回中间,小的移动了三次,而大的移动了一次,就使他们全部挪动了一个位置

所以代码如下:

#include<stdio.h>
int a[20]={0,1};
 
int main()
{
    int i,T;
    for(i=2;i<21;i++)
    {
        a[i]=3*a[i-1]+1; 
    }
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&i);
        printf("%d\n",2*a[i-1]+2);
    }
    return 0;
}

Pro.ID 2175 汉诺塔IX

http://acm.hdu.edu.cn/showproblem.php?pid=2175

普通汉诺塔,问在最优步骤中的第i步是哪一个盘子,跟1995那个题目刚好相反。不过这个有点像数论题。

这样想,假设是4个盘子,考虑第三个,在第4步的时候将3盘从A移动到C【设目的地是B】,此时1,2盘在B上,设时间为T,然后将1,2盘移动到C上,(需要3步)再把4盘移动到B上,此时的格局为4盘在B上,1,2,3,在C上,距T过去了1+3=4步,那么3号盘什么时候再动呢?把1,2移走,3就可以放到B上了,移走1,2需要花费3个步骤,因此距T4+3+1也就是第8步,总体是第12步时,3号盘子会再次移动。现在看明白了吧,就是基数倍的2^(i-1)时,i号盘子会移动。

代码如下:

#include<iostream>
using namespace std;
int main()
{
    __int64 a[65];
    a[1]=1;
    __int64 i,n,r;
    __int64 m;
    for(i=2;i<=63;i++)
        a[i]=2*a[i-1];
    while(~scanf("%I64d%I64d",&n,&m),n+m)
    {
        for(i=1;i<=n;i++)
        {
            r=m/a[i];
            if(r%2==1&&m%a[i]==0)
                printf("%I64d\n",i);
        }
    }
    return 0;
}

Pro.ID 2184 汉诺塔VIII

感觉这个题目非常的好,挺有意思的,问普通汉诺塔,N个盘子,在最优解的第M步时,每个柱子上的盘子的状态。

想了半天,也没什么思路,但有一点是绝对可以确定的,就是一般解简单汉诺塔过程的问题都是使用递归,可以得到全部过程,但是当N稍微到10以上的时候必然递归很慢,所以直接递归模拟必然是错误的,但是根据上一题目,第i个步移动哪一个盘子中确定的,第K个盘子在  奇数*2^(K-1)时移动可以得到些思想,必然是根据步数来确定盘子。

但是想了老半天也不太清楚那个递归改怎么写,好像每一次判断都要做除法到是可以确定某一个盘子,但是如何确定所有的盘子呢?纠结啊

查了半天,找到了一个大神的代码。

地址在:http://blog.lchx.me/index.php/hdu-2184-%E6%B1%89%E8%AF%BA%E5%A1%94viii/

讲的非常的详细,我把思路以及代码粘过来大家分享一下:

/*

定义数组a,其中a[i]表示完成一次i层汉诺塔移动的次数。
指针o,p,q分别表示三个位置。
起始状态为n层都在o上,要往q方向移动。
然后分成两种情况:
1、
m<=a[n-1];
此时,第n层没机会移动,那么就相当于o上的n-1层往p上移动。
使其状态和起始状态一致,我们要交换p和q。
2、
m>a[n-1];
此时,先进行到下面状态,上面n-1层移动到p位置,第n层移动到q位置,消耗了a[n-1]+1次移动。
接下来就变成p上的n-1层往q上移动,只要交换o,p,令m=m-a[n-1]-1即可。

通过上述操作,都可以得到第n层的位置,并且问题变成n-1层都在o上,要往q方向移动。
*/
#include<cstdio>
#include<algorithm>
#include<iostream>
using namespace std;
int main()
{
	unsigned __int64 m,a[64];
	int row[3][66];
	a[1]=1;
	a[0]=0;
	for(int i=2;i<=63;i++)
		a[i]=a[i-1]*2+1;
	int t;
	scanf("%d",&t);
	while(t--)
	{
		int n;
		scanf("%d %I64u",&n,&m);
		int *start,*mid,*end;
		start=row[0];
		mid=row[1];
		end=row[2];
		*start=*mid=*end=1;
		while(n)
		{
			n--;
			if(m<=a[n])
			{
				*(start+*start)=n+1;//从第二个位置开始记录盘子
				(*start)++;//第一个位置表示的是这个柱子一共有多少个盘子
				swap(end,mid);
			}
			else
			{
				*(end+*end)=n+1;
				(*end)++;
				swap(start,mid);
				m-=(a[n]+1);
			}		
		}
		for(int i=0;i<3;i++)
		{
			printf("%d",row[i][0]-1);
			for(int j=1;j<row[i][0];j++)
				printf(" %d",row[i][j]);
			printf("\n");
		}
	}
	return 0;
}

Pro.ID 汉诺塔 X

http://acm.hdu.edu.cn/showproblem.php?pid=2511

进一步加强条件,在求第m步时是哪个盘子动,怎么动。

必然递归啊。把上上个题目修改就可以了。具体的就不多说了,在注释里有详细解释

#include<iostream>
using namespace std;
 __int64 a[65];
void solve(int n,__int64 m,int start,int end)
{
	int third=6-start-end;//得到第3跟柱子
	__int64 mid=a[n];
	if(m==mid) //如果是当前盘子移动,直接从start-->end
	{
		printf("%d %d %d\n",n,start,end);
		return ;
	}
	if(m<mid)//当前盘子无法移动,必然是上边的某个盘子动,并且移动一定是到third号柱子上,递归求解
		solve(n-1,m,start,third);
	else//需要先移动当期盘子下部的盘子(参考2184题目)
		solve(n-1,m-mid,third,end);
}
		
int main()
{
    __int64 m;
    a[1]=1;
	int n;
    for(int i=2;i<=63;i++)
        a[i]=2*a[i-1];
	int t;
	while(~scanf("%d",&t))
	{
		while(t--)
		{
			scanf("%d%I64d",&n,&m);
			solve(n,m,1,3);
		}
	
	}
	return 0;
}

最后一个Pro.ID  2587:很O_O的汉诺塔

http://acm.hdu.edu.cn/showproblem.php?pid=2587

真心是跪了,

感谢hr_whisper的详细讲解,这里已经写的很清楚了:http://blog.csdn.net/murmured/article/details/9943947

    原文作者: 汉诺塔问题
    原文地址: https://blog.csdn.net/xueerfei008/article/details/9904681
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞