The teacher points to the blackboard (Fig. 4) and says: "So here is the problem:
- There are three towers: A, B and C.
- There are n disks. The number n is constant while working the puzzle.
- All disks are different in size.
- The disks are initially stacked on tower A increasing in size from the top to the bottom.
- The goal of the puzzle is to transfer all of the disks from tower A to tower C.
- One disk at a time can be moved from the top of a tower either to an empty tower or to a tower with a larger disk on the top.
So your task is to write a program that calculates the smallest
number of disk moves necessary to move all the disks from tower A to C."
Charlie: "This is incredibly boring—everybody knows that this can be
solved using a simple recursion.I deny to code something as simple as
this!"
The teacher sighs: "Well, Charlie, let‘s think about something for
you to do: For you there is a fourth tower D. Calculate the smallest
number of disk moves to move all the disks from tower A to tower D using
all four towers."
Charlie looks irritated: "Urgh. . . Well, I don‘t know an optimal algorithm for four towers. . . "
Problem
So the real problem is that problem solving does not belong to the
things Charlie is good at. Actually, the only thing Charlie is really
good at is "sitting next to someone who can do the job". And now guess
what — exactly! It is you who is sitting next to Charlie, and he is
already glaring at you.
Luckily, you know that the following algorithm works for n <= 12:
At first k >= 1 disks on tower A are fixed and the remaining n-k
disks are moved from tower A to tower B using the algorithm for four
towers.Then the remaining k disks from tower A are moved to tower D
using the algorithm for three towers. At last the n - k disks from tower
B are moved to tower D again using the algorithm for four towers (and
thereby not moving any of the k disks already on tower D). Do this for
all k 2 ∈{1, .... , n} and find the k with the minimal number of moves.
So for n = 3 and k = 2 you would first move 1 (3-2) disk from tower A
to tower B using the algorithm for four towers (one move). Then you
would move the remaining two disks from tower A to tower D using the
algorithm for three towers (three moves). And the last step would be to
move the disk from tower B to tower D using again the algorithm for four
towers (another move). Thus the solution for n = 3 and k = 2 is 5
moves. To be sure that this really is the best solution for n = 3 you
need to check the other possible values 1 and 3 for k. (But, by the way,
5 is optimal. . . )
Input
There is no input.
Output
For
each n (1 <= n <= 12) print a single line containing the minimum
number of moves to solve the problem for four towers and n disks.
Sample Input
No input.
Sample Output
REFER TO OUTPUT.
题意：
本题大意是求n个盘子四座塔的hanoi问题的最少步数。输出n为1～12个盘子时各自的答案。
Solution：
首先考虑n个盘子3座塔的最少步数。设d[n]表示n个盘子的最少步数，则易得递推方程：d[n]=d[n-1]*2+1，意思是把前n-1个盘子从A柱移到B柱，然后把第n个盘子移到C柱，最后把前n-1个盘子移到C柱。
那么回到本题，设f[n]表示n个盘子4座塔的最少步数。则易得递推方程：f[n]=min{2*f[i]+d[n-i]}（1<=i<n），其中f[1]=1。
上式意思是，先把i个盘子在4塔模式下移到B柱，然后把n-i个盘子在3塔模式下移到D柱，最后把i个盘子在4塔模式下移到D柱。考虑所有可能的i取最小值，就得到了上述式子。
由本题其实可以推及到n个盘子m座塔的最小步数。
代码：
1 #include<bits/stdc++.h>
2 #define ll long long
3 #define il inline
4 #define debug printf("%d %s\n",__LINE__,__FUNCTION__)
5 using namespace std;
6 int d[20],f[20];
7 int main()
8 {
9 for(int i=1;i<=12;i++)d[i]=d[i-1]*2+1;
10 memset(f,0x3f,sizeof(f));
11 for(int i=1;i<=12;i++){
12 if(i==1)f[1]=1;
13 else for(int j=1;j<i;j++)f[i]=min(f[j]*2+d[i-j],f[i]);
14 printf("%d\n",f[i]);
15 }
16 return 0;
17 }
原文地址：https://www.cnblogs.com/five20/p/8514682.html