汉诺塔系列专题(逐步理解递推递归)
2016-03-28 15:34
471 查看
最裸的汉诺塔:
第一步:把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个盘子中。
而我们可以利用这种思想不断递推/递归也行,直到正好等于把某些盘子移动到目的柱。
hdu2511
下面的题目比上一个更加进了一步
输入n,m问n个盘子,第m步移动的是哪个盘子,而且输出从哪个盘子移动到哪个盘子(比上一题进了一步)
大家想想。如果m步正好是k个盘子移动到目的柱,那么这时候肯定把1号盘由所在柱,移动k个盘所在的目的柱。1的所在柱就是我们递归函数中的所在柱,那么目的柱呢?大家想想我最开始讲的最裸的三部,要移动n个盘就把n-1个盘移动到B,那对于n-1个盘来说,中间B盘是目的柱,C是中间柱,那么对于n-2个盘来说目的柱是C柱,中间柱石B柱,那么判断k个盘的目的柱是哪个直接判断他与n的差的奇偶性即可。
hdu2184
接下来咱们再进一步,第m步的时候输出三个柱子上的盘子的编号
如果直接看这题是不是会被吓到,但是有前面题目的积累,这题也只是进了一步而已。eg:4个盘子,第5步,3个盘子移到目的柱,则需要7步,2个盘子移到目的柱需要3步,
则这里可以判定第4个盘子肯定在原来的柱子上不动,那第3个盘子会移到中间柱上。写个递归函数是不是很方便呢?如何保存每个柱子上的盘子号呢?由于递归的性质,会大的盘子先确定,柱子上编号较小的盘子可能是在下一层递归中确定。输出是先输出大的再输出小的,先进先出,不就是队列么。
hdu1995
问题把n个盘子移到目的柱,问第k个盘子在这过程中一共移动了多少次。
看上去很复杂的样子,但仔细想一想,第n个盘子只需要1次,第n-1个盘子只需要移动2次,你可以这么递归下去,当然有感觉的也可以直接找到规律,不说了,上代码
hdu1996
问n个盘子,移动到目的柱的过程中(不考虑最优的情况)会产生序列的总数,low题,每个哦案子不就可以在三个柱子上么,3的阶层就行了
上面两题算是休息,现在来看看更加深入,更加有趣的汉诺塔,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
我们做一些改变了规则的汉诺塔
hdu2064盘子不能直接从A到C,只能先由B在到C。
学会着递推公式,找不到的话,可以先模拟少数几个盘子
n-1个盘子先要移到C,n移到B,n-1个盘子移到A,n移到C,n-1个盘子移到C
hdu2077
规则在hdu2064的基础上再变一下,最大的盘可以放在小的盘子的上面(最上面)
跟上题结合一下,n-1用上题的规则移到B,n移到B,再移到C,再把n-1个移到C
hdu1207
规则又做了一次改变,这次有了四根柱子,这题的难点在于惯性思维(惯性思维害死人啊!!!),大家都用递推来做,其实是里面柔和了dp。大家自己感受下来自世界的深深的恶意。
第一步:把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 <<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 <<endl; } return 0; }
相关文章推荐
- IP地址转换函数
- UIView动画(过渡效果)的学习笔记
- 易景地球对大数据的支持
- j2ee servlet listener
- Ubuntu检测磁盘是否挂载
- 无法打开包括文件:'atlrx.h'的解决办法
- ElasticSearch 2 (38) - 信息聚合系列之结束与思考
- linux的物理内存与线性地址空间布局--1
- SM Java实现
- 虚拟机隔离
- 在 iTunes Store 中支付未付余款
- android中URI简介
- 使用 jsPlumb 绘制拓扑图 —— 异步载入与绘制的实现
- openwrt+ndp+ndppd+radvd+dhcpv6,ipv6穿透配置指南
- iframe和frameset的使用
- 备忘录模式(Memento)
- 字符转转十六进制,再转十进制
- vector用法入门
- 时钟周期、振荡周期、机器周期、CPU周期、状态周期、指令周期、总线周期、任务周期简单介绍。
- 批量删除table或view