汉诺塔问题

即

把a上面的n-1个盘子移动到b

再把最大的一个盘子移动到c

重复以上行为，只不过层数变成了n-1，

把b上面n-2个盘子移到a，再把次大的盘子移到c

然后n-2,n-3,n-4层，直到放回最小的一个盘子。

所以，n层需要移动2的n次方-1 次。

(参数的问题要考虑，太多盘子需要long long 或者__int64)

HDUOJ

#1995 是一个逆推的汉诺塔递归，移动次数是pow(2,n-k)

#1996 是问盘子可能出现的摆放情况 即pow(3,n)

#2064 不能隔着杆子跳，所以相当于（n-1）跳两次到C，最大的跳一次到B，（n-1）跳两次到A，最大的跳一次到C，（n-1）跳两次到C   （2，1，2，1，2） 8次

          一个盘子 需要跳两次

         a[n]=3*a[n-1]+2

# include <iostream>
# include <algorithm>
# include <cmath>
#include<iomanip>
using namespace std;

int main ()
{
	long long h[36];
	h[0]=0;
	h[1]=2;
	for(int i=2;i<36;i++){
		h[i]=3*h[i-1]+2;
	}
	int m;
	while(cin>>m){
		cout<<h[m]<<endl;
	}
    return 0;

}

#2077

# include <iostream>
# include <algorithm>
# include <cmath>
#include<iomanip>
using namespace std;

int main ()
{

	int m;
	cin>>m;
	while(m--){
		int a;
		long long z=2;
		cin>>a;
		if(a==1){
			cout<<z<<endl;
			continue;
		}
		else{
			for(int i=2;i<a;i++){
				z=3*z+2;
			}
		    z=z+2; //允许最大的放在上面，最后一次变的简单，前n-1次不变
			cout<<z<<endl;
		}
		
	}
    return 0;

}

#2175 第m次移动的是那一个盘子？

自己推导一下得出规律

一个盘子                                           1

两个盘子                                     1 （ 2 ） 1

三个盘子                        （1  2  1）   3   （ 1   2  1）

………………

主要是考虑数据类型，凡是能取很大的数的，都需要用unsigned long long 或者unsignd __int64

# include <iostream>
# include <algorithm>
# include <cmath>
#include<iomanip>
using namespace std;

unsigned __int64 l[66];
int main ()
{
	l[1]=1;
	for(int i=2;i<66;i++){
		l[i]=2*l[i-1]+1;
	}
	int n;
	unsigned __int64 m;
	while(cin>>n>>m&&(n||m)){
		unsigned __int64 t=l[n]+1;

		for(int i=n;i>0;i--){
			t=t/2;
			if(t==m){
				cout<<i<<endl;
				break;
			}
			if(m>t){m=m-t;}
			else{m=t-m;}
		}
	}
	return 0;
}