HDU 5250 三阶魔方（很有意思的模拟题）

最新推荐文章于 2021-11-16 10:51:05 发布
最新推荐文章于 2021-11-16 10:51:05 发布
阅读量2.2k 收藏 6
点赞数
分类专栏： 水题库 CodeFoeces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Martin20150405/article/details/51892529
版权

三阶魔方

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 123    Accepted Submission(s): 57

Problem Description
给定三阶魔方的基本操作：



现给出一个由基本操作组合成的操作序列，求问：对一个初状态（六个面都是拼好的）的魔方进行多少次连续的序列操作后，魔方会恢复到初状态。
 

Input
第一行为T，表示输入数据组数。

下面T行，每行给出一个合法的操作序列字符串，每行不超过100个字符。
 

Output
对第i组数据，输出

Case #i:

然后输出一个整数，表示答案。若魔方不会恢复则输出-1。
 

Sample Input 
  
  

   
   3
R2
R'R'U2
RU
 

Sample Output 
  
  

   
   Case #1:
2
Case #2:
6
Case #3:
105
 

Source
2015年百度之星程序设计大赛 - 初赛(1)
 

Recommend
hujie
 



题意：

给定一个操作序列，问执行多少次操作以后，魔方会恢复原状，如果不能则输出-1


思路：

很明显对于同一个操作执行多次肯定是可以还原的。
考虑魔方上的某一个面的一个点（标号为1），如果执行一次操作以后还在原来的位置，那么不管执行几次都在原来的位置。
如果不在原来的位置，例如1到了2的位置，2到了6的位置，6到了1的位置，那么执行三次操作以后就可以复原这三个点（相当于转了一圈）。

具体的做法是，我们可以执行一遍这个操作，找出所有的环，求出所有环长度的最小公倍数即可（想一想是不是很有道理呢）

为了简化编码，我们可以把U2变成UU，U‘变成UUU，这样只要编写6种操作就可以了。

怎么执行操作呢，每一个操作我们都要记录魔方当前的状态，如果使用3x3x3的坐标记录点的位置，那么将无法保存颜色信息（在哪一面），因此可以用3x3x6的数组保存6个面，在执行一个操作时（例如R），会涉及到5个面，即右，上、后、下、前，R顺时针旋转90度，其他的面每个只有3个数字会改变

代码写的比较长，个人感觉这样直观一些 


#include <bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
const int INF=0x3f3f3f3f;
const int maxn=3e3+50;
const int Mod=1e9+7;
typedef long long ll;

using namespace std;


const int W=3;
int maze[6][W][W];

int hashId[100];
bool vis[100];

string get(char c,char t)
{
    string ret="";
    if (t=='2') return ret+c+c;
    if (t=='\'') return ret+c+c+c;
}
string expandCommand(string &s)
{

    string ret="";
    int sz=s.size();
    for (int i=0;i<sz;){
        if(i==sz-1 || (isalpha(s[i]) && isalpha(s[i+1]))) {
            ret+=s[i];
            i++;
        }
        else {
            ret+=get(s[i],s[i+1]);
            i+=2;
        }
    }
    return ret;
}

//0 1 2 3 4 5
//U D L R F B
void rotateClockwise(int face[W][W])
{
    int tmp[W][W];
    for (int i=0;i<W;i++)
        for(int j=0;j<W;j++){
            tmp[i][j]=face[W-j-1][i];
        }
    for (int i=0;i<W;i++){
        for(int j=0;j<W;j++){
         //   printf("%d ",tmp[i][j]);
            face[i][j]=tmp[i][j];
        }
       // puts("");
    }
}

void swapClockwise( int &s1,int &s2,int &s3,
            int &s4,int &s5,int &s6,
            int &s7,int &s8,int &s9,
            int &s10,int &s11,int &s12){
    int tmp[13];
    tmp[1]=s1; tmp[2]=s2; tmp[3]=s3;
    tmp[4]=s4; tmp[5]=s5; tmp[6]=s6;
    tmp[7]=s7; tmp[8]=s8; tmp[9]=s9;
    tmp[10]=s10; tmp[11]=s11; tmp[12]=s12;

    s1=tmp[10]; s2=tmp[11]; s3=tmp[12];
    s4=tmp[1]; s5=tmp[2]; s6=tmp[3];
    s7=tmp[4]; s8=tmp[5]; s9=tmp[6];
    s10=tmp[7]; s11=tmp[8]; s12=tmp[9];
}

inline int getR(int x){
    x--;
    return x/3;
}
inline int getC(int x){
    x--;
    return x%3;
}
void excute(string &s)
{

    int cnt=1;
    for (int i=0;i<6;i++){
        for(int j=0;j<W;j++)
            for (int k=0;k<W;k++)
                maze[i][j][k]=cnt++;
    }
    int sz=s.size();
    for (int i=0;i<sz;i++){
     //   printf("%d %c\n",i,s[i]);
        if (s[i]=='U'){
            //0 1 2 3 4 5
            //U D L R F B

            rotateClockwise(maze[0]);
            swapClockwise(
                maze[5][getR(3)][getC(3)],
                maze[5][getR(2)][getC(2)],
                maze[5][getR(1)][getC(1)],

                maze[3][getR(3)][getC(3)],
                maze[3][getR(2)][getC(2)],
                maze[3][getR(1)][getC(1)],

                maze[4][getR(3)][getC(3)],
                maze[4][getR(2)][getC(2)],
                maze[4][getR(1)][getC(1)],

                maze[2][getR(3)][getC(3)],
                maze[2][getR(2)][getC(2)],
                maze[2][getR(1)][getC(1)]

                );
        }else if (s[i]=='D'){
            //0 1 2 3 4 5
            //U D L R F B
            rotateClockwise(maze[1]);
            swapClockwise(
                maze[4][getR(7)][getC(7)],
                maze[4][getR(8)][getC(8)],
                maze[4][getR(9)][getC(9)],

                maze[3][getR(7)][getC(7)],
                maze[3][getR(8)][getC(8)],
                maze[3][getR(9)][getC(9)],

                maze[5][getR(7)][getC(7)],
                maze[5][getR(8)][getC(8)],
                maze[5][getR(9)][getC(9)],

                maze[2][getR(7)][getC(7)],
                maze[2][getR(8)][getC(8)],
                maze[2][getR(9)][getC(9)]
                );
        }else if (s[i]=='L'){
            //0 1 2 3 4 5
            //U D L R F B
            rotateClockwise(maze[2]);
            swapClockwise(
                maze[0][getR(1)][getC(1)],
                maze[0][getR(4)][getC(4)],
                maze[0][getR(7)][getC(7)],

                maze[4][getR(1)][getC(1)],
                maze[4][getR(4)][getC(4)],
                maze[4][getR(7)][getC(7)],

                maze[1][getR(1)][getC(1)],
                maze[1][getR(4)][getC(4)],
                maze[1][getR(7)][getC(7)],

                maze[5][getR(9)][getC(9)],
                maze[5][getR(6)][getC(6)],
                maze[5][getR(3)][getC(3)]
                );

        }else if (s[i]=='R'){
            //0 1 2 3 4 5
            //U D L R F B
            rotateClockwise(maze[3]);
            swapClockwise(
                maze[0][getR(9)][getC(9)],
                maze[0][getR(6)][getC(6)],
                maze[0][getR(3)][getC(3)],

                maze[5][getR(1)][getC(1)],
                maze[5][getR(4)][getC(4)],
                maze[5][getR(7)][getC(7)],

                maze[1][getR(9)][getC(9)],
                maze[1][getR(6)][getC(6)],
                maze[1][getR(3)][getC(3)],

                maze[4][getR(9)][getC(9)],
                maze[4][getR(6)][getC(6)],
                maze[4][getR(3)][getC(3)]
                );
        }else if (s[i]=='F'){
            //0 1 2 3 4 5
            //U D L R F B
            rotateClockwise(maze[4]);
            swapClockwise(
                maze[0][getR(7)][getC(7)],
                maze[0][getR(8)][getC(8)],
                maze[0][getR(9)][getC(9)],

                maze[3][getR(1)][getC(1)],
                maze[3][getR(4)][getC(4)],
                maze[3][getR(7)][getC(7)],

                maze[1][getR(3)][getC(3)],
                maze[1][getR(2)][getC(2)],
                maze[1][getR(1)][getC(1)],

                maze[2][getR(9)][getC(9)],
                maze[2][getR(6)][getC(6)],
                maze[2][getR(3)][getC(3)]
                );
        }else if (s[i]=='B'){
            //0 1 2 3 4 5
            //U D L R F B
            rotateClockwise(maze[5]);
            swapClockwise(
                maze[0][getR(3)][getC(3)],
                maze[0][getR(2)][getC(2)],
                maze[0][getR(1)][getC(1)],

                maze[2][getR(1)][getC(1)],
                maze[2][getR(4)][getC(4)],
                maze[2][getR(7)][getC(7)],

                maze[1][getR(7)][getC(7)],
                maze[1][getR(8)][getC(8)],
                maze[1][getR(9)][getC(9)],

                maze[3][getR(9)][getC(9)],
                maze[3][getR(6)][getC(6)],
                maze[3][getR(3)][getC(3)]
                );
        }
    }
    return;
}

void getHash(){
    int cnt=1;
    for (int i=0;i<6;i++){
        for(int j=0;j<W;j++)
            for (int k=0;k<W;k++){
                hashId[cnt++]=maze[i][j][k];
              //  printf("%d %d\n",cnt-1,hashId[cnt-1]);
            }
    }
}


ll gcd(ll a,ll b){
    return (b==0)? a:gcd(b,a%b);
}

int getCycle(vector<int> &v){
    mem(vis,0);
    for (int i=1;i<=36;i++){
        if (vis[i]) continue;
        int cnt=1,pos=i;
        vis[pos]=1;
        while(hashId[pos]!=i){
           // printf("pos:%d hashId:%d %d\n",pos,hashId[pos],i);
         //   getchar();
            pos=hashId[pos];
            vis[pos]=1;
            cnt++;
        }
     //   cout<<cnt<<'\n';
        v.push_back(cnt);
    }
}

ll LCM(vector<int> &v){
    ll ret=1;
    int sz=v.size();
    for (int i=0;i<sz;i++){
        ret=ret/gcd(ret,(ll)v[i])*v[i];
    }
    return ret;
}
int main()
{
    #ifndef ONLINE_JUDGE
        freopen("in.txt","r",stdin);
    #endif
    int n,T;
    string str;
    scanf("%d",&T);
    for (int cs=1;cs<=T;cs++){
        printf("Case #%d:\n",cs);
        cin>>str;
        string command=expandCommand(str);
       // cout<<command<<'\n';
        excute(command);
        getHash();
        vector<int> cycle;
        getCycle(cycle);
        printf("%lld\n",LCM(cycle));
    }
    return 0;
}



Martin20150405
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
HDU题目分类
10-28
杭电OJ的题目分类 杭电OJ的题目分类 杭电OJ的题目分类
HDU之入门模拟
qq_21524797的博客
09-21 315
本篇没有涉及很多算法，主要为一些模拟题，难度不大，具体实现代码可自行练习。 1.简单模拟 模拟题主要考察代码能力，简单模拟不涉及算法，完全只是根据题目描述来进行代码的编写。 HDU3361 ASCII （打印输出） HDU4144KFC -Z+W（最小排队时间） HDU6023Automatic Judge （AC时间） 2.图形输出 图形由若干字符组成...
HDU4801 转魔方、DFS模拟
陈颜的博客
11-16 454
题目 HDU 4801 题解 由于是两阶魔方，左边UP等于右边DOWN，因此共有6种转动方式。直接模拟即可，时间复杂度O(67×12)O(6^7\times 12)O(67×12) 代码 #include <bits/stdc++.h> using namespace std; int mp[][6] = { {-1, -1, 0, 1, -1, -1}, {-1, -1, 2, 3, -1, -1}, {4, 5, 6, 7, 8, 9}, {10, 11,
HDU - 1998 奇数阶魔方
m0_51068403的博客
09-01 89
传送门 文章目录题意：思路： 题意： 给你一个奇数nnn，构造一个nnn阶幻方。 3≤n≤193\le n\le 193≤n≤19 思路： 模板题了，直接构造一个幻方即可。 首先在第一行中间放一个111，之后每次看一下(x,y)(x,y)(x,y)右上角的位置(x−1,y+1)(x-1,y+1)(x−1,y+1)是否已经被放过数了，如果没有下一个数就放过去，否则就放到这个位置的下面(x+1,y)(x+1,y)(x+1,y)即可。 // Problem: C. Magic Odd Square // Cont
HDU 5250 三阶魔方（模拟、置换）
TaoSama's Microcosm
02-12 1906
题意: 给定N≤100的三阶魔方操作序列给定N\le100的三阶魔方操作序列 魔方操作如下图：魔方操作如下图： 求问：对一个初状态（六个面都是拼好的）的魔方进行多少次连续的序列操作后，魔方会恢复到初状态求问：对一个初状态（六个面都是拼好的）的魔方进行多少次连续的序列操作后，魔方会恢复到初状态 分析: 对魔方的每个方块标号之后，每个操作的置换可以手工推出对魔方的每个方块标号
hdu.rar_hdu
09-23
"hdu.rar_hdu"这个压缩包文件很可能是某位程序员整理的他在HDU上解决过的题目代码集合。这些代码通常包含了对各种算法的应用，例如排序、搜索、图论、动态规划等，对于学习算法和准备编程竞赛的初学者来说是一份宝贵...
HDU_2010.rar_hdu 2010_hdu 20_hdu acm20
09-14
"hdu"可能是指杭州电子科技大学（Hangzhou Dianzi University），这所学校经常举办ACM编程竞赛，并有自己的在线判题系统——HDU Online Judge，供参赛者提交代码并测试解决方案。 【压缩包子文件的文件名称列表】中...
hdu.zip_ACM_hdu
09-20
在ACM(国际大学生程序设计竞赛)中，数据结构与算法是至关重要的组成部分，而"杭电"(杭州电子科技大学)的在线判题系统HDU提供了许多这类问题供参赛者练习。"hdu.zip_ACM_hdu"这个压缩包很可能是包含了一道或若干道...
hdu1020.rar_hdu1020
09-20
HDU 1020，又被称为"猜数字"，是一个经典的在线算法竞赛题目，源自中国杭州电子科技大学（Hangzhou Dianzi University）的在线评测系统HDU ACM/ICPC。这个题目要求参赛者编写一个程序，模拟一个猜数字的游戏过程，...
杭电操作系统实验 HDU操作系统实验.zip
最新发布
06-06
杭电操作系统实验 HDU操作系统实验.zip杭电操作系统实验 HDU操作系统实验.zip杭电操作系统实验 HDU操作系统实验.zip杭电操作系统实验 HDU操作系统实验.zip杭电操作系统实验 HDU操作系统实验.zip杭电操作系统实验 HDU...
HDU4520:小Q系列故事——最佳裁判
ACM！荣耀之路！
03-24 1287
Problem Description 　　过去的2012年对小Ｑ来说是很悲催的一年，失恋了12次，每次都要郁闷1个来月。 　　好在小Q是个体育迷，在最痛苦的时候，他常常用观看各种体育节目来麻醉自己，比如伦敦奥运会期间，小Q就常常在周末邀上一群单身同事聚在自己的蜗居，一边畅饮啤酒，一边吹牛。 　　小Q最喜欢看的是跳水，主要原因也是因为这个项目有中国人参加，而且中国队员获胜的几率很大，一般不会
hdu_1034(模拟题)
weixin_30819085的博客
08-10 164
很久没有打模拟题了，再次总结一下模拟题的做法： 仔细分析题意，弄清楚过程 理清楚模拟步骤，严格按照步骤编写代码 添加中间输出测试每步结果 虽然这是一个很简单的水题，但是没有松哥帮忙还是卡了很久，因为没有做好第一步，题目中是老师先吹哨，然后一圈所有同学同事将自己现有糖的一般分给下一个同学，结束后老师将现手里为奇数的糖的同学再多给一颗糖最后判断每个人的糖是否一样，如果一样结束游戏 代码： ...
Halli Galli HDU - 6931（模拟题）
laity__c的博客
07-16 180
Halli Galli HDU - 6931 原题 题意：有4种水果A，B，G，P，有n轮抽牌，k位玩家，每轮依次一位玩家抽取一张带有x个ch水果的牌，回合结束若k位玩家有恰巧5个相同的水果，答案加一！！！ 一开始题意理解没对想了好久！ 题意理解了就是一个循环抽牌在对所有人进行比较的一个模拟！ #include<bits/stdc++.h> using namespace std; int card[10]; char per[10]; int main(){ int t; cin &
2015年百度之星程序设计大赛 - 初赛(1)
ok_again的专栏
05-31 1154
A.5246 超级赛亚ACMer 显然要先排序，然后每次在能达到的最大的时候打平，这样的话就可以最大程度的利用k。 //#pragma comment(linker, "/STACK:1024000000,1024000000") #include #include #include #include #include #include #include #include #include
HDU2549（字符串有趣题）
代码艺术的道与术
12-18 732
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2549 解题思路： 看一眼就直接用字符串做，WA一发。如果小数点后的位数小于n的话，那么应该输出0. 完整代码： #include #include #include #include #include #include #include #include #in
HDU多校联合赛（1007 Magical Forest）模拟题
weixin_34399060的博客
08-12 469
题目： Problem Description There is a forest can be seen as N * M grid. In this forest, there is some magical fruits, These fruits can provide a lot of energy, Each fruit has its location(Xi, Y...
2015年百度之星程序设计大赛 - 初赛(1) 【题解】
poursoul
06-01 3418
1001.超级赛亚ACMer Accepts: 867 Submissions: 5329 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Problem Description 百小度是一个ACMer，也是一个超级赛亚人，每个ACMer都有一个战斗力，包括百小度。
所谓超级赛
HDU练习题分类
weixin_43887873的博客
11-24 268
原文：https://blog.csdn.net/u012938194/article/details/38390391   1001       这个就不用说了吧  1002       简单的大数  1003    
有意思的逻辑思维题（一）（hdu2018，2160，2053）
九日王朝
11-19 4310
母猪的故事 题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=2018 题目描述： 有一头母牛，它每年年初生一头小母牛。每头小母牛从第四个年头开始，每年年初也生一头小母牛。请编程实现在第n年的时候，共有多少头母牛？ 一开始看到这道题时确实是很懵比的，后来知道真想的我才发现原来如此的简单。。。 第一年  A 第二年
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值