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

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柱借助1，3…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