poj 3601 Tower of Hanoi

Tower of Hanoi

Time Limit: 1000MS   Memory Limit: 131072K
Total Submissions: 1853   Accepted: 635

Description

The Tower of Hanoi is a puzzle consisting of three pegs and a number of disks of different sizes which can slide onto any peg. The puzzle starts with the disks neatly stacked in order of size on one peg, the smallest at the top, thus making a conical shape. The objective of the puzzle is to move the entire stack to another peg, obeying the following rules:

  • Only one disk may be moved at a time.
  • Each move consists of taking the upper disk from one of the pegs and sliding it onto another peg, on top of the other disks that may already be present on that peg.
  • No disk may be placed on top of a smaller disk.

For n disks, it is a well-known result that the optimal solution takes 2n − 1 moves.

To complicate the puzzle a little, we allow multiple disks to be of the same size. Moreover, equisized disks are mutually distinguishable. Their ordering at the beginning should be preserved at the end, though it may be disturbed during the process of solving the puzzle.

Given the number of disks of each size, compute the number of moves that the optimal solution takes.

Input

The input contains multiple test cases. Each test case consists of two lines. The first line contains two integers n and m (1 ≤ n ≤ 100, 1 ≤ m ≤ 106). The second lines contains n integers a1a2, …, an (1 ≤ a1a2, …, an ≤ 105). For each 1 ≤ i ≤ n, there are ai disks of size i. The input ends where EOF is met.

Output

For each test case, print the answer modulo m on a separate line.

Sample Input

1 1000
2
5 1000
1 1 1 1 1
5 1000
2 2 2 2 2
5 1000
1 2 1 2 1

Sample Output

3
31
123
41

Source

PKU Campus 2008 (POJ Founder Monthly Contest – 2008.05.10), xfxyjwf

分析:

学习网址:http://blog.csdn.net/acm18810549519/article/details/10155281

动态规划

题意:汉诺塔问题,不过其中加了一个条件,就是盘子可以有相同的

可以发现,当移动第i 种盘子时&& num[i]>=2得到的是逆序的,但是题目要求不能改变顺序,所以必须处理

1.先考虑不按顺序的情况为 dp1[i]=dp1[i-1]*2+num[i]  ,num[i]为相同盘子的个数

公式得来:如果从A到C轴,借助B轴,i种盘子,要先把i - 1种移动到 B, 需要dp1[i - 1],然后把第i种移动到C,需要num[i],然后再把i - 1种从B移动到C,需要dp1[i - 1]
所以得到dp1[i]=dp1[i-1]*2+num[i] .

2.考虑按顺序的情况为 dp2[i]=2*dp1[i-1]+2*num[i]+dp2[i-1]

公式得来:把num[1] - 1个移动到辅助轴,这时这num[1] - 1个盘子的顺序颠倒了,然后把第num[1]中最后一个移动到目标轴,然后把辅助轴上的移动回来,再次颠倒,恢复顺序,得到dp2[1] = 2 * (num[1] - 1) +1。
对于dp2[i],
如果x[i] == 1,那么第i种就不需要考虑顺序(只有一种),所以dp2[i] = dp1[i]
否则,第i种要调动2次,保证顺序不变。
还是从A到C轴,借助B轴,i种盘子
把i - 1种不考虑顺序移到C,需要dp1[i - 1].
把第i种从A移动到B,需要num[i](颠倒顺序),
把i - 1种不考虑顺序移到A(腾出C),需要dp1[i - 1].
把第i种从B移动到C,需要num[i](顺序恢复)
把i - 1种考虑顺序移到C,需要dp2[i - 1].
所以有dp2[i] = 2 * dp1[i - 1] +2 * num[i] +dp2[i - 1]
最后答案是dp2[n].

 1 //起始条件:dp1[1]=num[1];dp2[1]=2*num[1]-1
 2 //num[i]==1:dp2[i]=2*dp1[i-1]+1
 3 //num[i]>=2:dp2[i]=dp1[i]+num[i]+dp1[i]+num[i]+dp2[i]=2*dp1[i-1]+2*num[i]+dp2[i-1]
 4 #include<cstdio>
 5 #include<cmath>
 6 #include<cstring>
 7 #include<iostream>
 8 using namespace std;
 9 int num[105],dp1[105],dp2[105];
10 int main(){
11     int n,m;
12     while(cin>>n>>m){
13         int i=1;
14         for(;i<=n;i++){
15             cin>>num[i];
16         }
17         dp1[1]=num[1]%m;
18         dp2[1]=(2*(num[1]-1)+1)%m;
19         for(i=2;i<=n;i++){
20             dp1[i]=(2*dp1[i-1]+num[i])%m;
21             if(num[i]==1){
22                 dp2[i]=dp1[i];
23             }
24             else{
25                 dp2[i]=(2*dp1[i-1]+2*num[i]+dp2[i-1])%m;
26             }
27         }
28         cout<<dp2[n]<<endl;
29     }
30     return 0;
31 }
时间: 2024-10-12 11:57:48

poj 3601 Tower of Hanoi的相关文章

One usage of recurison: the tower of Hanoi

Statements: This blog was written by me, but most of content  is quoted from book[Data Structure with Java Hubbard] [Description] we have seen important examples of functions that are more naturally defined and more easily understood by using recursi

尺取法 POJ 3601 Subsequence

题目传送门 1 /* 2 题意:求连续子序列的和不小于s的长度的最小值 3 尺取法:对数组保存一组下标(起点,终点),使用两端点得到答案 4 1. 记录前i项的总和,求[i, p)长度的最小值,用二分找到sum[p] - s[i] >= s的p 5 2. 除了O (nlogn)的方法,还可以在O (n)实现,[i, j)的区间求和,移动两端点,更新最小值,真的像尺取虫在爬:) 6 */ 7 #include <cstdio> 8 #include <algorithm> 9

POJ 1920 Towers of Hanoi

OJ题目:click here~~ 题目分析:三根柱子 , n个圆盘 .给一个汉诺塔的状态,求将所有盘挪到一个柱子上的最少步数,并给出是最后在哪个柱子上. 从给定状态到目标状态很复杂,但是从目标状态到给定的状态就很容易想了.将一个柱子上i个盘,挪到另一个柱子上,需要pow(2,i) - 1步. 显然,最后在的那个柱子,一定是所给状态下最大盘所在的柱子.接下来考虑第二大的盘,需要移动就移动.--详见代码注释. AC_CODE const int mod = 1000000; int p[10000

汉诺塔(Tower of Hanoi)问题的求解——利用栈与递归

汉诺塔(Tower of Hanoi)问题的求解--利用栈与递归 1. 汉诺塔问题的提法 汉诺塔问题是使用递归解决问题的经典范例. 传说婆罗门庙里有一个塔台,台上有3根标号为A.B.C的用钻石做成的柱子,在A柱上放着64个金盘,每一个都比下面的略小一点.把A柱上的金盘全部移到C柱上的那一天就是世界末日. 移动的条件是:一次只能移动一个金盘,移动过程中大金盘不能放在小金盘上面.庙里的僧人一直在移个不停,移动的最少总次数是264?1次,如果每秒移动一次的话,需要500亿年. 2. 求解汉诺塔问题的算

汉诺塔问题(The Tower of Hanoi)的递归算法与非递归算法

非递归算法: 根据圆盘的数量确定柱子的排放顺序: 若n为偶数,按顺时针方向依次摆放 A B C: 若n为奇数,按顺时针方向依次摆放 A C B. 然后进行如下操作: (1)按顺时针方向把圆盘1从现在的柱子移动到下一根柱子,即当n为偶数时,若圆盘1在柱子A,则把它移动到B:若圆盘1在柱子B,则把它移动到C:若圆盘1在柱子C,则把它移动到A. (2)接着,把另外两根柱子上可以移动的圆盘移动到新的柱子上.即把非空柱子上的圆盘移动到空柱子上,当两根柱子都非空时,移动较小的圆盘. (3)反复进行(1)(2

Tower of Hanoi问题

[问题描述] 有A, B, C三个塔座,A上套有n个直径不同的圆 盘,按直径从小到大叠放,形如宝塔,编号1, 2, 3 … n. 要求将n个圆盘从A移到C,叠放顺序不变,移动过程中遵循 下列原则: w每次只能移一个圆盘 w圆盘可在三个塔座上任意移动 w任何时刻,每个塔座上不能将大盘压到小盘上 [解决方法] n=1时,直接把圆盘从A移到C n>1时,先把上面n-1个圆盘从A移到B,然后将n号盘从A移到C,再将n-1个盘从B移到C.即把求解n个圆盘的Hanoi问题转化为求解n-1个圆盘的Hanoi问

汉诺塔 Tower of Hanoi

如果柱子标为A,B,C,要由A搬至C,在只有一个盘子时,就将它直接搬至C:当有两个盘子,就将B作为辅助柱:如果盘数超过2个,将第二个以下的盘子遮起来,就很简单了,每次处理两个盘子,也就是:A->B.A->C.B->C这三个步骤,而被遮起来的部分,其实就由方程的递归处理. 代码如下: #include <stdio.h> void hanoi(int n,char A,char B,char C){ if(n == 1){ printf("Move sheet %d

列表形式的汉诺塔(Tower of Hanoi)Python语言实现

从昨天半下午就开始想这个问题,到现在经过30个小时左右(期间并不思考是非常集中,因为连续思考很累而且可能效果不佳),终于把程序搞定了,第一次思考问题这么久.算是第一个自主思考的程序还是很有成就感的. 代码优势:模块化做的很好,找到了通过写出前4-5次的数学表达,找到了规律并将其化成代码. 代码劣势:规则化欠佳,因python无指针(网上说的,还不确定),没有学到python中类似c语言指针的函数,造成本来一个模块不得不分解为6个模块相互调用.并且函数封装不好,即因为不会类指针方法,所以用函数操作

poj 3601Tower of Hanoi

Tower of Hanoi Time Limit: 1000MS   Memory Limit: 131072K Total Submissions: 1895   Accepted: 646 Description The Tower of Hanoi is a puzzle consisting of three pegs and a number of disks of different sizes which can slide onto any peg. The puzzle st