最裸的漢諾塔：
第一步：把n-1個盤子移到B柱
第二步：把第n個柱子移到C柱
第三步：把n-1個盤子移到C盤
第一步和第三步是一樣的，如果只需要求最少的步數，可以不管中間步驟，用遞推直接寫出即可
核心代碼
a[1]=1;
for(int i=2;i<=n;i++)
a[i]=2*a[i-1]+1;
最裸的弄懂當然是遠遠不夠的，現在我們來看一些變形
hdu2175
輸入n，m，問初始有n個盤子，問第m次移動的盤子號
咋看很麻煩，其實也是很簡單的啦！
比如有4個盤子，我要看第4步的盤子。如果我3個盤子都移到目的柱，那一共需要7步，如果把2個盤子都移到目的柱那一共需要3步，所以第4步移動的盤子一定在前3個盤子中。
而我們可以利用這種思想不斷遞推/遞歸也行，直到正好等於把某些盤子移動到目的柱。
#include <iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
typedef long long ll;
ll n,m,a[64],b[64];
void inial()
{
a[1]=1;b[0]=1;b[1]=2;
for(int i=2;i<64;i++)
{
a[i]=a[i-1]*2+1;
if(i<63)
b[i]=a[i]+1;
}
}
int sovle()
{
if(m==a[63])
return 1;
while(m>0)
{
int t=0;
while(t<63)
{
if(m>b[t])
t++;
else
break;
}
if(m==b[t])
return t+1;
m-=b[t-1];
}
}
int main()
{
inial();
while(cin>>n>>m&&n&&m)
{
cout<<sovle()<<endl;
}
return 0;
}hdu2511
下面的題目比上一個更加進了一步
輸入n，m問n個盤子，第m步移動的是哪個盤子，而且輸出從哪個盤子移動到哪個盤子（比上一題進了一步）
大家想想。如果m步正好是k個盤子移動到目的柱，那麼這時候肯定把1號盤由所在柱，移動k個盤所在的目的柱。1的所在柱就是我們遞歸函數中的所在柱，那麼目的柱呢？大家想想我最開始講的最裸的三部，要移動n個盤就把n-1個盤移動到B，那對於n-1個盤來說，中間B盤是目的柱，C是中間柱，那麼對於n-2個盤來說目的柱是C柱，中間柱石B柱，那麼判斷k個盤的目的柱是哪個直接判斷他與n的差的奇偶性即可。
#include <iostream>
#include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
typedef long long ll;
ll a[64],m;
int t,n;
void inal()
{
a[1]=1;
for(int i=2;i<=63;i++)
a[i]=2*a[i-1]+1;
}
void sovle(int s,int t,int z,int n)
{//cout<<"----------- "<<s<<" "<<t<<" "<<z<<" "<<n<<endl;
int k=1;
while(k<64&&m-a[k]>0)
k++;
k--;
m-=a[k];
int d=(n-k)&1;
if(d==1)//1到k在第z上
{
if(m==0)
{
cout<<1<<" "<<s<<" "<<z<<endl;
return;
}
if(m==1)
{
cout<<k+1<<" "<<s<<" "<<t<<endl;
return;
}
m--;
sovle(z,t,s,k);
}
else//1到k在t上
{
if(m==0)
{
cout<<1<<" "<<s<<" "<<t<<endl;
return;
}
if(m==1)
{
cout<<k+1<<" "<<s<<" "<<z<<endl;
return;
}
m--;
sovle(t,z,s,k);
}
}
int main()
{
inal();
scanf("%d",&t);
while(t--)
{
scanf("%d%I64d",&n,&m);
sovle(1,3,2,n);
}
return 0;
}hdu2184
接下來咱們再進一步，第m步的時候輸出三個柱子上的盤子的編號
如果直接看這題是不是會被嚇到，但是有前面題目的積累，這題也只是進了一步而已。eg：4個盤子，第5步，3個盤子移到目的柱，則需要7步，2個盤子移到目的柱需要3步，
則這裏可以判定第4個盤子肯定在原來的柱子上不動，那第3個盤子會移到中間柱上。寫個遞歸函數是不是很方便呢？如何保存每個柱子上的盤子號呢？由於遞歸的性質，會大的盤子先確定，柱子上編號較小的盤子可能是在下一層遞歸中確定。輸出是先輸出大的再輸出小的，先進先出，不就是隊列麼。
#include <iostream>
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
typedef long long ll;
ll a[64],m;
int t,n,len[4];
queue<int> qu[4];
void inal()
{
a[1]=1;
for(int i=2;i<=63;i++)
a[i]=2*a[i-1]+1;
}
void sovle(int s,int t,int z,int n)
{
int k=1;
while(k<64&&m-a[k]>0)
k++;
k--;
for(int i=n;i>k+1;i--)
{
len[s]++;
qu[s].push(i);
}
m-=a[k];
int d=(n-k)&1;
if(d==0)
swap(z,t);
if(m==0)
{
for(int i=k;i>=1;i--)
{
len[z]++;
qu[z].push(i);
}
len[s]++;
qu[s].push(k+1);
return;
}
len[t]++;
qu[t].push(k+1);
if(m==1)
{
for(int i=k;i>=1;i--)
{
len[z]++;
qu[z].push(i);
}
return;
}
m--;
sovle(z,t,s,k);
}
int main()
{
inal();
scanf("%d",&t);
while(t--)
{
memset(len,0,sizeof(len));
scanf("%d%I64d",&n,&m);
sovle(1,3,2,n);
for(int i=1;i<=3;i++)
{
printf("%d ",len[i]);
printf("%d",qu[i].front());
qu[i].pop();
while(!qu[i].empty())
{
printf(" %d",qu[i].front());
qu[i].pop();
}
printf("\n");
}
}
return 0;
}hdu1995
問題把n個盤子移到目的柱，問第k個盤子在這過程中一共移動了多少次。
看上去很複雜的樣子，但仔細想一想，第n個盤子只需要1次，第n-1個盤子只需要移動2次，你可以這麼遞歸下去，當然有感覺的也可以直接找到規律，不說了，上代碼
#include <iostream> #include<stdio.h> #include<math.h> #include<algorithm> using namespace std; typedef long long ll; int t,n,k; int main() { scanf("%d",&t); while(t--) { scanf("%d%d",&n,&k); ll ans=pow(2,n-k); printf("%I64d\n",ans); } return 0; }
hdu1996
問n個盤子，移動到目的柱的過程中（不考慮最優的情況）會產生序列的總數，low題，每個哦案子不就可以在三個柱子上麼，3的階層就行了
#include <iostream>
#include<stdio.h>
#include<algorithm>
#include<math.h>
using namespace std;
typedef long long ll;
ll a[31];
void inial()
{
a[0]=1;
for(int i=1;i<=30;i++)
a[i]=3*a[i-1];
}
int main()
{
inial();
int t,k;
scanf("%d",&t);
while(t--)
{
scanf("%d",&k);
printf("%I64d\n",a[k]);
}
return 0;
}上面兩題算是休息，現在來看看更加深入，更加有趣的漢諾塔，hdu1997，自己看題意啊
這題是不是一看到就把人嚇到了，對於這種問題，肯定是遞歸的啦！現在的問題是遞歸什麼，如果你要遞歸每一步，肯定會爆掉。我們要弄清楚我們可以確定什麼，由於最裸的公式，我們可以確定，n在A或C，如果n確定了，那麼我們需要考慮n-1。如果n在A，那還處於最裸的公式中的第一步，那麼n-1只有在A或B，目的柱是B，起點是A，中間點是C。如果n到C，那一定經歷過了第一步，那麼n-1要麼在C要麼在B，起點是B，中間點是A，目的點是C
#include <iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
const int M=70;
int t,n,len[4],a[4][M],no[4],f=-1;
void input()
{
scanf("%d",&n);
for(int i=0;i<3;i++)
{
scanf("%d",&len[i]);
for(int j=0;j<len[i];j++)
scanf("%d",&a[i][j]);
}
}
void dfs(int A,int B,int C,int n)
{
if(f!=-1)
return;
if(n==0)
{
f=1;
return;
}
if(a[A][no[A]]==n)
{
no[A]++;//cout<<n<<" ------- "<<A<<endl;
dfs(A,C,B,n-1);
}
else
if(a[C][no[C]]==n)
{
no[C]++;//cout<<n<<" ------- "<<C<<endl;
dfs(B,A,C,n-1);
}
else
{
f=0;
return;
}
}
int main()
{
scanf("%d",&t);
while(t--)
{
input();
no[0]=no[1]=no[2]=0;
f=-1;
dfs(0,1,2,n);//cout<<f<<endl;
if(f)
puts("true");
else
puts("false");
}
return 0;
}我們做一些改變了規則的漢諾塔
hdu2064盤子不能直接從A到C，只能先由B在到C。
學會着遞推公式，找不到的話，可以先模擬少數幾個盤子
n-1個盤子先要移到C，n移到B，n-1個盤子移到A，n移到C，n-1個盤子移到C
#include<iostream>
#include<stdio.h>
using namespace std;
typedef long long ll;
ll f[37];
void Inial()
{
f[1]=2;
for(int i=2;i<36;i++)
f[i]=3*f[i-1]+2;
}
int main()
{
Inial();
int n;
while(scanf("%d",&n)!=EOF)
{
cout<<f[n]<<endl;
}
return 0;
}hdu2077
規則在hdu2064的基礎上再變一下，最大的盤可以放在小的盤子的上面（最上面）
跟上題結合一下，n-1用上題的規則移到B，n移到B，再移到C，再把n-1個移到C
#include<iostream>
#include<stdio.h>
using namespace std;
typedef long long ll;
ll a[37],b[37];
void Inial()
{
a[1]=2;
b[1]=1;
for(int i=2;i<=20;i++)
{
a[i]=3*a[i-1]+2;
}
for(int i=2;i<=20;i++)
{
b[i]=b[i-1]+a[i-1]+1;
}
}
int main()
{
Inial();
int n,m;cin>>n;
for(int i=0;i<n;i++)
{
cin>>m;
cout<<b[m-1]*2+2<<endl;
}
return 0;
}hdu1207
規則又做了一次改變，這次有了四根柱子，這題的難點在於慣性思維（慣性思維害死人啊！！！），大家都用遞推來做，其實是裏面柔和了dp。大家自己感受下來自世界的深深的惡意。
#include <iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
double a[65],b[65];
void inial()
{
b[1]=1;
for(int i=2;i<65;i++)
b[i]=2*b[i-1]+1;
a[1]=1;
a[2]=3;
for(int i=3;i<=64;i++)
{
a[i]=b[i];
for(int j=1;j<i;j++)
{
a[i]=min(2*a[j]+b[i-j],a[i]);
}
}
}
int main()
{
int n;
inial();
while(scanf("%d",&n)!=EOF)
{
cout<<a[n]<<endl;
}
return 0;
}