POJ 1958 Strange Towers of Hanoi

Strange Towers of Hanoi

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 3784		Accepted: 2376

Description

Background 
Charlie Darkbrown sits in another one of those boring Computer Science
lessons: At the moment the teacher just explains the standard Tower of Hanoi
problem, which bores Charlie to death! 
　
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.

Source

TUD Programming Contest 2002, Darmstadt, Germany

【题意】

本题大意是求n个盘子四座塔的hanoi问题的最少步数。输出n为1～12个盘子时各自的答案。

【分析】

汉罗塔改编的一个小问题。

以前经典的汉罗塔问题是三个柱子n个盘，每次选择一个盘子进行移动，小的不能放在大的上面。问你经过多少次操作可以使得将所有的盘子从a柱移动到c柱。

现在只是将题目小改了一下，就是将以前的三个柱子改成了四个。问你移动次数。

我们思考一下关于三个柱子的经典问题，我们的转移方程是：

dp[i] = dp[i-1]*2+1

这个方程是怎么来的呢？

就是我们先将n-1个盘移动到b柱上，代价为dp[i-1],然后将第n个盘移动到c柱，代价为1，然后将b柱上的n-1个盘子移动到c柱上代价是dp[i-1]。所以总代价是dp[i-1]+1+dp[i-1] = dp[i-1]*2+1。

对于题目给出的题目的改版，我们用同样的思想，首先，对于n个盘，我们考虑n-1个盘的子问题。那么我们显然可以得到： 对于n个盘，我们先把n-k个盘在有4个柱子的情况下移动到b柱子，然后对于剩下的k个盘子，显然前面的n-k个盘子占用了b柱子，并且剩下的k个盘子都比前面的n-k个盘子大，所以对于k个盘子来说我们只能使用剩下的3个柱子。也就是说：

f[i] = min(f[i-k]*2+f[k]),k属于[1,i)

　

【代码】

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
int d[20],f[20];
int main(){
	memset(f,0x3f,sizeof f);
	d[1]=1;f[1]=1;
	for(int i=1;i<=12;i++) d[i]=d[i-1]<<1|1;
	for(int i=1;i<=12;i++){
		for(int j=1;j<i;j++){
			f[i]=min(f[i],f[j]*2+d[i-j]);
		}
	}
	for(int i=1;i<=12;i++) printf("%d\n",f[i]);
	return 0;
}