精华内容
下载资源
问答
  • 二阶魔方

    2020-01-10 19:51:20
    魔方总览https://blog.csdn.net/nameofcsdn/article/details/103866632 ... 一,二阶魔方: 二,二阶魔方与三阶魔方的关系: 可以理解为,二阶魔方就是三阶魔方的八个角块。 三阶魔方的层先法:做好...

    魔方总览https://blog.csdn.net/nameofcsdn/article/details/103866632

    三阶魔方https://blog.csdn.net/nameofcsdn/article/details/103885148

     

    一,二阶魔方:

       

     

    二,二阶魔方与三阶魔方的关系:

    可以理解为,二阶魔方就是三阶魔方的八个角块。

    三阶魔方的层先法:做好底层十字、调整底面角块、复原中层棱块、做好顶面十字、顶角归位、调整顶角位置、调整顶棱位置。

    二阶魔方的层先法:调整底面角块、顶角归位、调整顶角位置

    二阶魔方只有3步,而且这3步和三阶魔方的对应3步一模一样。

    https://pan.baidu.com/s/1-K2zmPS-_0r0BnFhtX2irQ

    当然,二阶魔方和三阶魔方一样,除了层先法还有更快的高阶方法,以及盲拧公式。

     

    三,二阶魔方的定位

    偶数阶魔方和奇数阶魔方的差别在于,奇数阶魔方的中心块是固定的,整个魔方六个面的颜色也就固定了。

    而偶数阶魔方没有中心块,六个面能确定吗?

    对于二阶魔方,还是形成了共识的,以任意一个角块为基准,都可以确定另外七个角块的位置,即确定了整个魔方

     

    四,二阶魔方的盲拧

    二阶魔方的盲拧一共需要2个公式,是从三阶魔方的3个公式演变来的。

    用层先法复原魔方一共分七步,分别为:做好底层十字、调整底面角块、复原中层棱块、做好顶面十字、顶角归位、调整顶角位置、调整顶棱位置。

    这里需要顶角归位的小鱼1、小鱼2,还有调整顶角位置的公式(姑且叫做换角公式)

    我在研究三阶魔方的时候就研究过小鱼1和小鱼2的关系,对一个复原的魔方用小鱼1,只要再用一次小鱼2就可以直接完成顶角归位、调整顶角位置这两步,只需要进行第七步即可复原。

    而对于二阶魔方,没有棱,用小鱼1再用小鱼2直接就是复原的。

    用小鱼1:(拍摄角度即为拿魔方的角度,为了看得清楚,镜头稍微往右偏了一点)

        

    如果把整个魔方转个方向:

    在这个方向再用小鱼2的话就直接复原了。

    但是如果整个魔方转到另外一个方向:

    在这个方向使用小鱼2就会变成:

    这里,我们就得到了二阶魔方盲拧的第一个公式:

    小鱼1+整个魔方转90度+小鱼2 = 把2个相邻的角快原地转动(一个顺时针一个逆时针),另外6个角快不动

    至于换角公式:

       

    把上面一层逆时针旋转90度,即U'

    (这里为了看得清楚,镜头往左偏移了一点)

    这里,我们就得到了二阶魔方盲拧的第二个公式:

    换角公式+U' = 相邻的2个角快交换位置

    利用这2个公式,即可盲拧二阶魔方。

    展开全文
  • 二阶魔方还原教程

    万次阅读 2016-11-13 11:46:48
    目录 第一步 底面 ...科学计算证明,一个随意打乱的二阶魔方,即使是最复杂的状态,仍可以在14步之内(180°旋转的情况当作两步的前提下)就可以还原。也就是说,如果我们知道每一种打乱状态的排...

    目录

    第一步 底面

    第二步 顶面(OLL)

    第三步 整体换角(XLL)


    一般常见的二阶魔方还原方法是根据三阶的还原方法再加以简化改良而成。因为二阶可以理解为三阶的8个角块,所以可以这样说:只要会还原三阶,就一定会还原二阶。

    科学计算证明,一个随意打乱的二阶魔方,即使是最复杂的状态,仍可以在14步之内(180°旋转的情况当作两步的前提下)就可以还原。也就是说,如果我们知道每一种打乱状态的排列组合情形的最短路径,那么我们最多只需14步就可以还原一个二阶。

    但是,我们人类不可能像电脑一样每次都寻找出最少步骤来还原魔方,所以我们需要一些比较容易观察且操作方便的方法来还原。二阶除了可以用三阶的方法还原,主流还原方法有色先法和面先法。这里介绍的是相对比较简单而且速度较快的面先法。

    二阶快速法无论是初学者还是已经学过一段时间的朋友,都可以很轻松的上手,甚至可以在四天内Sub10秒。它的原理很简单,无非是先两面,然后直接调整上下两层的角块,完成。

    重点:在完成底面和顶面的时候均不需要考虑是否要对齐颜色!只需要完成两面先!这就是这种解法快速的关键!

    过程: 第一步:底面 ---> 第二步:顶面(OLL) ---> 第三步:整体换角(XLL)  

    第一步 底面

    这一步里十五秒的观察很重要,尽量在十五秒内把第一面的完成步聚想好,争取在在两秒内完成一面.  

    第二步 顶面(OLL)

    二阶的OLL并不是很多有如下几种,公式都很顺手:

    第三步 整体换角(XLL)

    这一步里,观察的速度是最重要的,这里不象三阶,只需判断一层,需要同时判断上下两层,不过这一步的时候PLL只有三大种情况,非常好判断,主要是观察相邻的色块。

    上下两层的对角换

    判断技巧: 整个魔方分为上下两层。然后上下两层均无相同色在一起者。

    上层前两邻角 下层对角

    判断技巧: 整个魔方分上下两层。只有上面一层有两个相同的色拼在一起 如果是下面一层拼在了一起就立刻把整个魔方翻个180度。

    上下层均只换前面的两邻角

    判断技巧: 整个魔方分两层。两层都有两个相同色拼在一起。 

    当然,也许你很运气,(或者是很没运气)在完成两面的时候已经有一面完成,那么还有两种PLL情况: 

    好了,现在你手上的二阶已经还原了。多练习就能轻松进10。  

    展开全文
  • 二阶魔方教程

    2013-12-13 11:12:40
    二阶魔方 教程exe可执行程序教程 很全
  • 二阶魔方上帝之数

    2019-04-23 12:47:45
    python在群论上的应用,用python计算二阶魔方的上帝之数,求每一步还原情况的算法。
  • 二阶魔方的最少步打乱 Apare_xzc 2020.2.20 13:17 前言:  博主xzc是一个魔方爱好者,三阶sub 25s。虽然水平不高,但是对魔方十分热爱。博主对二阶魔方编码,然后通过bfs得到了二阶魔方的全部状态。 下面是得到的...
  • 模拟:二阶魔方问题

    2020-04-24 22:37:10
    Vjudge:二阶魔方一次还原模拟

    题面:

    一个二阶魔方,是一个2×2×2的一个立方体组。立方体由八个角组成。
    魔方的每一块都用三维坐标(h, k, l)标记,其中h, k, l∈{0,1}。六个面的每一个都有四个小面,每个小面都有一个正整数。
    对于每一步,可以选择一个特定的面,并把此面顺时针或逆时针转90度。
    请你判断,是否可以在一个步骤还原这个魔方(每个面没有异色)

    输入的第一行包含一个整数N(N≤30),这是测试用例的数量。

    对于每个测试用例,
    第 1~4 个数描述魔方的顶面,这是常见的2×2面,由(0,0,1),(0,1,1),(1,0,1),(1,1,1)标记。四个整数对应于上述部分。

    第 5~8 个数描述前面,即(1,0,1),(1,1,1),(1,0,0),(1,1,0)的公共面。四个整数
    与上述各部分相对应。

    第 9~12 个数描述底面,即(1,0,0),(1,1,0),(0,0,0),(0,1,0)的公共面。四个整数与上述各部分相对应。

    第 13~16 个数描述背面,即(0,0,0),(0,1,0),(0,0,1),(0,1),(0,1,1)的公共面。四个整数与上述各部分相对应。

    第 17~20 个数描述左面,即(0,0,0),(0,0,1),(1,0,0),(1,0,1)的公共面。给出四个整数与上述各部分相对应。

    第 21~24 个数描述了右面,即(0,1,1),(0,1,0),(1,1,1),(1,1,0)的公共面。给出四个整数与上述各部分相对应。

    换句话说,每个测试用例包含24个整数a、b、c到x。你可以展开表面以获得平面图如下:
    在这里插入图片描述
    对于每个测试用例,魔方如果可以至多 “只转一步” 恢复,输出YES,则输出NO。

    sample input:
    4
    1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4 5 5 5 5 6 6 6 6
    6 6 6 6 1 1 1 1 2 2 2 2 3 3 3 3 5 5 5 5 4 4 4 4
    1 4 1 4 2 1 2 1 3 2 3 2 4 3 4 3 5 5 5 5 6 6 6 6
    1 3 1 3 2 4 2 4 3 1 3 1 4 2 4 2 5 5 5 5 6 6 6 6

    sample output:
    YES
    YES
    YES
    NO

    思路:

    • 首先,这道题不要被给定的那一堆坐标迷惑到了,其实他只是告诉你面的顺序罢了。
    • 在输入的时候记录一下已完成的面数,如果能够在最多一步内完成魔方的复原,则已经是完成的面的面数只能是两面或者六面。如果不符合可以直接输出NO
    • 如果已经完成了六面,那么一定是正确的,直接输出YES即可
    • 如果完成了两面,那么我们就开始进行一次判断,一共有24个面,所以可以用一个具有24个元素的数组进行记录
    • 可以根据给定的图示做一个小正方体,观察进行一次旋转有可能是那四个数字处于同一面。通过flag来记录是否符合同一颜色的,满足则置为1。
    #include<stdio.h>
    #include<iostream>
    #include<cstring>
    using namespace std;
    int g[25];
    bool met[8];
    int main()
    {
        int N,cnt;
        bool flag;
        scanf("%d",&N);
        while(N--)
        {
            cnt = 0;
            memset(met,false,sizeof(met));
            for(int i=1;i<25;i++)
            cin>>g[i];
            if(g[1]==g[2]&&g[2]==g[3]&&g[3]==g[4])
            {
                ++cnt;
                met[0] = 1;
            }
            if(g[5]==g[6]&&g[6]==g[7]&&g[7]==g[8])
            {
                ++cnt;
                met[1] = 1;
            }
            if(g[9]==g[10]&&g[10]==g[11]&&g[11]==g[12])
            {
                ++cnt;
                met[2] = 1;
            }
            if(g[13]==g[14]&&g[14]==g[15]&&g[15]==g[16])
            {
                ++cnt;
                met[3] = 1;
            }
            if(g[17]==g[18]&&g[18]==g[19]&&g[19]==g[20])
            {
                ++cnt;
                met[4] = 1;
            }
            if(g[21]==g[22]&&g[22]==g[23]&&g[23]==g[24])
            {
                ++cnt;
                met[5] = 1;
            }
            if(cnt==6) cout<<"YES"<<endl;
            else if(cnt==2)
            {
                flag = 0;
                if(met[0]&&met[2])
                {
                    if(g[13]==g[14]&&g[13]==g[21]&&g[13]==g[23])
                    {
                        if(g[22]==g[24]&&g[22]==g[5]&&g[22]==g[6])
                            if(g[7]==g[8]&&g[7]==g[18]&&g[7]==g[20])
                                if(g[17]==g[19]&&g[17]==g[15]&&g[17]==g[16])
                                    flag = 1;
                    }
                    else if(g[13]==g[14]&&g[13]==g[18]&&g[13]==g[20])
                    {
                        if(g[17]==g[19]&&g[17]==g[5]&&g[17]==g[6])
                            if(g[7]==g[8]&&g[7]==g[21]&&g[7]==g[23])
                                if(g[22]==g[24]&&g[22]==g[15]&&g[22]==g[16])
                                    flag = 1;
                    }
                }
                else if(met[1] && met[3])
                {
                    if(g[1]==g[2]&&g[1]==g[23]&&g[1]==g[24])
                    {
                        if(g[21]==g[22]&&g[21]==g[9]&&g[21]==g[10])
                            if(g[11]==g[12]&&g[11]==g[19]&&g[11]==g[20])
                                if(g[17]==g[18]&&g[17]==g[3]&&g[17]==g[4])
                                    flag = 1;
                    }
                    else if(g[1]==g[2]&&g[1]==g[19]&&g[1]==g[20])
                    {
                        if(g[17]==g[18]&&g[17]==g[9]&&g[17]==g[10])
                            if(g[11]==g[12]&&g[11]==g[23]&&g[11]==g[24])
                                if(g[21]==g[22]&&g[21]==g[3]&&g[21]==g[4])
                                    flag = 1;
                    }
                }
                else if(met[4] && met[5])
                {
                    if(g[1]==g[3]&&g[1]==g[14]&&g[1]==g[16])
                    {
                        if(g[13]==g[15]&&g[13]==g[10]&&g[13]==g[12])
                            if(g[9]==g[11]&&g[9]==g[6]&&g[9]==g[8])
                                if(g[5]==g[7]&&g[5]==g[2]&&g[5]==g[4])
                                    flag = 1;
                    }
                    else if(g[1]=g[3]&&g[1]==g[6]&&g[1]==g[8])
                    {
                        if(g[5]==g[7]&&g[5]==g[10]&&g[5]==g[12])
                            if(g[9]==g[11]&&g[9]==g[14]&&g[9]==g[16])
                                if(g[13]==g[15]&&g[13]==g[2]&&g[13]==g[4])
                                    flag = 1;
                    }
                }
                if(flag) cout<<"YES"<<endl;
                else cout<<"NO"<<endl;
            }
            else cout<<"NO"<<endl;
        }
        return 0;
    }
    • 在刚开始看到这道题的时候,我思考的方向是,一个二阶魔方,只可能存在八种可能性(假设魔方处于xyz三维坐标系,则存在绕xy轴顺时针逆时针拧动,由于二阶,所以是八种)
    • 然后设定一个用于判断是否当前状态符合魔方复原条件的函数,每次函数处理后都进行判断
    • 思考起来非常容易,但是实现的时候很容易绕进去,最后的代码能通过样例和自己出的数据,但是没法通过VJ,应该是某个数转错了(放出这个很长的蒟蒻代码仅用于帮助了解思路,如果有大神能指出错误不胜感激)
    #include<iostream>
    #include<cstdio>
    using namespace std;
    int count;
    int gezi[25];
    bool whether()//判断能否输出
    {
     count=0;
     for(int i=1;i<25;i=i+4)
     {
      int j=i;
      if(gezi[j]==gezi[j+1]&&gezi[j]==gezi[j+2]&&gezi[j]==gezi[j+3])
       count++;
     }
     if(count==6)
      return true;
     else return false;
    }
    void xshun1()
    {
     int temp1=gezi[1];
     int temp2=gezi[2];
     gezi[1]=gezi[17];
     gezi[2]=gezi[18];
     gezi[17]=gezi[12];
     gezi[18]=gezi[11];
     gezi[11]=gezi[22];
     gezi[12]=gezi[21];
     gezi[21]=temp1;
     gezi[22]=temp2;
    }
    
    void xshun2()
    {
     int temp3=gezi[3];
     int temp4=gezi[4];
     gezi[3]=gezi[19];
     gezi[4]=gezi[20];
     gezi[19]=gezi[10];
     gezi[20]=gezi[9];
     gezi[10]=gezi[23];
     gezi[9]=gezi[24];
     gezi[23]=temp3;
     gezi[24]=temp4;
    }
    void xni1()
    {
     int temp1=gezi[1];
     int temp2=gezi[2];
     gezi[1]=gezi[21];
     gezi[2]=gezi[22];
     gezi[21]=gezi[12];
     gezi[22]=gezi[11];
     gezi[12]=gezi[17];
     gezi[11]=gezi[18];
     gezi[17]=temp1;
     gezi[18]=temp2;
    }
    
    void xni2()
    {
     int temp3=gezi[3];
     int temp4=gezi[4];
     gezi[3]=gezi[23];
     gezi[4]=gezi[24];
     gezi[23]=gezi[10];
     gezi[24]=gezi[9];
     gezi[10]=gezi[19];
     gezi[9]=gezi[20];
     gezi[19]=temp3;
     gezi[20]=temp4; 
    }
    
    void yshun1()
    {
     int temp1=gezi[1];
     int temp3=gezi[3];
     gezi[1]=gezi[13];
     gezi[3]=gezi[15];
     gezi[15]=gezi[11];
     gezi[13]=gezi[9];
     gezi[11]=gezi[7];
     gezi[9]=gezi[5];
     gezi[5]=temp1;
     gezi[7]=temp3;
    }
    
    void yshun2()
    {
     int temp2=gezi[2];
     int temp4=gezi[4];
     gezi[2]=gezi[14];
     gezi[4]=gezi[16];
     gezi[14]=gezi[10];
     gezi[16]=gezi[12];
     gezi[10]=gezi[6];
     gezi[12]=gezi[8];
     gezi[6]=temp2;
     gezi[8]=temp4; 
    }
    
    void yni1()
    {
     int temp1=gezi[1];
     int temp3=gezi[3];
     gezi[1]=gezi[5];
     gezi[3]=gezi[7];
     gezi[5]=gezi[9];
     gezi[7]=gezi[11];
     gezi[9]=gezi[13];
     gezi[11]=gezi[15];
     gezi[13]=temp1;
     gezi[15]=temp3;
    }
    
    void yni2()
    {
     int temp2=gezi[2];
     int temp4=gezi[4];
     gezi[2]=gezi[6];
     gezi[4]=gezi[8];
     gezi[6]=gezi[10];
     gezi[8]=gezi[12];
     gezi[10]=gezi[14];
     gezi[12]=gezi[16];
     gezi[14]=temp2;
     gezi[16]=temp4;
    }
    
    int main()
    {
     int N;
     scanf("%d",&N);
     while(N--)
     {
      for(int i=1;i<25;i++)
      {
       cin>>gezi[i];
      }
      if(whether())//如果现在就稳的一批 
      {
       cout<<"YES"<<endl;
      } 
      else 
      {
       xshun1();
       if(whether())
       {
        cout<<"YES"<<endl;
        continue;
       }
       xshun2();
       if(whether())
       {
        cout<<"YES"<<endl;
        continue;
       }
       xni1();
       if(whether())
       {
        cout<<"YES"<<endl;
        continue;
       }
       xni2();
       if(whether())
       {
        cout<<"YES"<<endl;
        continue;
       }
       yshun1();
       if(whether())
       {
        cout<<"YES"<<endl;
        continue;
       }
       yshun2();
       if(whether())
       {
        cout<<"YES"<<endl;
        continue;
       }   
       yni1();
       if(whether())
       {
        cout<<"YES"<<endl;
        continue;
       }   
       yni2();
       if(whether())
       {
        cout<<"YES"<<endl;
        continue;
       }
       cout<<"NO"<<endl;           
      }
     }
     return 0;
    } 
    展开全文
  • 二阶魔方 三阶魔方还原法

    千次阅读 2018-05-14 09:41:23
    二阶魔方 三阶魔方还原法 二阶魔方归正:1 下面蓝色 不停用 上右下左,直到下面全蓝2 翻动蓝色到上方, 找到左右的上侧 两个相同的颜色固定 ,然后 上右下推 上右下左 下压上 上左下左(如果没有:上右下推 上右下...
    二阶魔方 三阶魔方还原法
     二阶魔方归正:

    1 下面蓝色  不停用 上右下左,直到下面全蓝
    2 翻动蓝色到上方,  找到左右的上侧 两个相同的颜色固定 ,然后  上右下推  上右下左 下压上 上左下左(如果没有:上右下推  上右下左 下压上 上左下左)
    3 蓝色面朝右 红色面朝上,然后 上右下左  对齐绿色
    4 绿色朝上  相同色 朝左,然后  上右下推  上右下左 下压上 上左下左。知道对齐所有面。


    三阶魔方归正:

    1  花:上黄色中心块   对号四圈白色花

    2  底层十字:四圈白色花下延伸的颜色第二层对齐后   然后下翻白色到底部  形成底部白十字。

    3  底角全白: 找侧面白色,顶部对应侧面颜色的块,然后做公式  左手边:左上右下    右手边:右上左下(如没白面,找不对的那个角 左手边一直左手公式  右手边一直右手公式)

    4  中棱归位:找 顶棱无黄色的 对正侧棱中心块颜色,然后看此棱顶部颜色在左 左手公式:左上右下 翻左 右上左下。 在右: 右手公式 右上左下 翻右 左上右下
      (如果 侧棱颜色不对 蓝色朝我 在左 左公式   在右 右公式  挪到顶上去  再开始执行)

    5  顶层十字:面蓝顶黄 左手固定   横一字公式:上右下左 下压上推   拐角公式:压  上左下左  上右下推  单点公式:任意以上做一遍看结构,然后开始

    6 顶全黄:  必须找到 左右小鱼 :面朝黄色 接邻三角为异色, 如无 ,做一次 或者两次左右小鱼 一直找到为止。(上右下右 上右右下)上左下左 上左左下

    7 看是否有  一对眼睛(蓝红三个棱角面是否对着)   一对鱼眼:眼朝左 先一字公式:上右下左 下压上推     再 拐角公式:压  上左下左  上右下推
      没有鱼眼睛:先拐角公式:压 上左下左  上右下推 再 一字公式:上右下左 下压上推

    8 归正的一面放后面  哪边需要挪到前面  就用哪个手的公式:  右手:上右下右  上右右下  (右) 上左下左  上左左下

    左手:上左下左  上左左下  (左) 上右下右  上右右下

    二阶参考http://www.iqiyi.com/w_19rt7zmqs1.html    三阶参考 http://www.mf100.org/beginner.htm   

    展开全文
  • 二阶魔方复原pdf格式支持手把手教你二阶魔方复原
  • 特殊的二阶魔方 时限:1000ms 内存限制:10000K 总时限:3000ms 描述:   魔方大家应该都玩过。现在有一个特殊的二阶魔方,它只有一面是白色,其余五个面全是黑色。玩这个魔方当然也有特殊的规则,玩家只能...
  • 二阶魔方旋转

    2018-09-19 19:38:33
    二阶魔方有6个不同颜色的面,分别是红(Red),橙(Orange),黄(Yellow),白(White),蓝(Blue)和绿色(Green), 每个面都有 4个小正方块拼成 初始状态:魔方已经还原,并且W色朝下,Y色向上,R色在前,O色在后,B色左边...
  • 二阶魔方模拟还原 CUBE PICTURE U U U U L L F F R R B B L L F F R R B B D D D D <0> <1> 根据魔方公式进行处理还原 cube.h main.cpp cube.cpp SETTER AND OPERATION: cube_setter.cpp cube_operation....
  • 用python还原二阶魔方(Rubik‘s Cube)

    千次阅读 2020-03-22 22:38:48
    智能控制课程第一周作业:要求建立搜索算法完成二阶魔方(Rubik’s Cube)从起始状态向指定状态的转换。二阶魔方结构较为简单,对魔方基础要求不高,从来没有接触过的笔者也可以单纯地运用搜索算法解决问题。 参考过的...
  • 头条机试 二阶魔方

    2020-07-11 23:08:03
    二阶魔方每次操作可以将任意一面逆时针或者顺时针旋转90°,如将上面逆时针旋转90°操作如下。 魔方上每一面的优美度就是这个面上4个数字的乘积,而魔方的总优美度就是6个面优美度总和。 现在Nero有一个数字魔方,...
  • 特殊的二阶魔方

    2018-10-17 23:57:57
    现在有一个特殊的二阶魔方,它只有一面是白色,其余五个面全是黑色。玩这个魔方当然也有特殊的规则,玩家只能通过六种方式去改变它,底层向左转一格(称为DL),底层向右转一格(称为DR),右侧向上转一格(称为RU)...
  • 目录[大模拟]东东玩二阶魔方题意d样例样例输入:样例输出:思路总结代码 [大模拟]东东玩二阶魔方 题意d 东东有一个二阶魔方,即2×2×2的一个立方体组。立方体由八个角组成。 魔方的每一块都用三维坐标(h, k, l)标记...
  • xzc的二阶魔方最少步还原 时间限制:1000ms 空间限制:256M 其它说明:Special Judge 题面:         xzc是一个魔方爱好者,他最近在练习二阶魔方全预判,他想得到12步...
  • Week10——二阶魔方

    2020-05-01 10:25:01
    东东有一个二阶魔方,即2×2×2的一个立方体组。立方体由八个角组成。 魔方的每一块都用三维坐标(h, k, l)标记,其中h, k, l∈{0,1}。六个面的每一个都有四个小面,每个小面都有一个正整数。 对于每一步,东东可以...
  • 二阶魔方恢复——c++

    2020-04-25 16:50:00
    东东有一个二阶魔方,即2×2×2的一个立方体组。立方体由八个角组成。 魔方的每一块都用三维坐标(h, k, l)标记,其中h, k, l∈{0,1}。六个面的每一个都有四个小面,每个小面都有一个正整数。 对于每一步,东东可以...
  • 二阶魔方还原 - 4步2公式

    万次阅读 2019-12-23 13:54:26
    三阶魔方的公式记录在 https://blog.csdn.net/Bob__yuan/article/details/86546920,这是只需要记7个公式就可以三阶魔方还原法,本文为二阶魔方“傻瓜还原法”,即不需要另外再记公式,只需要会上述三阶魔方中的2个...
  • 二阶魔方高级玩法公式

    千次阅读 2020-04-02 13:17:26
    这里记录一下,二阶魔方的高级工式 场景公式 底层不动,更换某一棱上角块位置(R' F R F') R U2' R' U R U2' R' 底层不动,互换第二层(R' F R F') R U2' R' U R U2' R' 计费IDPMS生产的产品ID 渠道ID本系统中各省份...
  • 特殊的二阶魔方 时限:1000ms 内存限制:10000K 总时限:3000ms 描述 魔方大家应该都玩过。现在有一个特殊的二阶魔方,它只有一面是白色,其余五个面全是黑色。玩这个魔方当然也有特殊的规则,玩家只能通过六种...
  • C++ HOJ 二阶魔方

    千次阅读 2015-07-09 19:40:17
    OJ 二阶魔方这道题目,是很基础的一个实现,不需要太多思想和算法,实现较为简单,主要问题在于在于函数比较冗长。注意细节,ji能给出正确结论。可以在自定义函数中通过switch ... case 语句实现 魔方旋转。
  • 二阶魔方还原】第十次OJ的总结

    千次阅读 2019-01-05 11:16:49
     二阶魔方是 2x2x2 的立方体结构魔方,它共有 8 块,如下图所示: 图1 二阶魔方示意图  我们可以定义魔方作为一个正六面体的六个面为 F(ront), B(ack), U(p), D(own), L(eft), R(ight)。我们根据先前后后...
  • 对于魔方来说,二阶魔方算是比较简单的,共有8个顶角块,上面四个块,下面四个块:可以分为 前面四个角块:左前上,左前下,右前上,右前下 后面四个角块:左后上,左后下,右后上,右后下 魔方的面有六个,可以分为...
  • /* 二阶魔方旋转 魔方可以对它的6个面自由旋转。 我们来操作一个2阶魔方(如图1所示): 为了描述方便,我们为它建立了坐标系。 各个面的初始状态如下: x轴正向:绿 x轴反向:蓝 y轴正向:红 y轴反向:橙 z...
  • 【今日头条】二阶魔方

    千次阅读 2018-10-08 11:45:35
    二阶魔方又叫小魔方,是2*2*2的立方形结构。每一面都有4个块,共有24个块。每次操作可以将任意一面逆时针或者顺时针旋转90°,如将上面逆时针旋转90°操作如下。 Nero在小魔方上做了一些改动,用数字替换每个块...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 214
精华内容 85
关键字:

二阶魔方