二阶魔方

最新推荐文章于 2022-03-19 15:43:16 发布
最新推荐文章于 2022-03-19 15:43:16 发布
阅读量239 收藏 2
点赞数
原文链接：http://www.cnblogs.com/just-waiting/archive/2011/12/06/2277595.html
版权

    博客开通第一天，写个随笔纪念一下：

    今天介绍二阶魔方的求解方法：

     问题很简单，给二阶魔方的任意状态，求解一个二阶魔方还原的方法，如下为还原后的情况：

        
         很显然把魔方上每个位置先标个号：

        

         然后建立个旋转关系很简单！

         旋转操作包括：前方顺时针，前方逆时针，上方顺时，上逆时，右顺时，右逆时；

         （不用左、下、后是因为相对性）。

         输入：按1~24填颜色。（这里还是按 hdu3459 的输入方式）

         . . WO . . . .
         . . WO . . . .
         BBOYGGWR
         BBOYGGWR
         . . YR . . . .
         . . Y R . . . .
　　    输出：一种转法。

         X Y Z 分别为按X、Y、Z轴顺时旋转的一步操作。

   

       具体只要按部双向宽搜，还是很容易的，注意 写好类与具体操作的函数就很好办了。

       本人考证过，二阶总状态数在百万级，所以双向宽搜效果已经很好了！非常快非常快！！

       之所以可以双向因为在后面左下方的那个角在我们的操作中是不变的，所以根据它可以推出各个面的终态颜色。当然，每个人有自己的写法，一下是我写的，比较繁琐也很臃肿= =，以后会努力写的精炼！

       #include <iostream>
#include <cstdio>
#include <map>
#include <queue>
using namespace std;

int F[24]={9,10,12,11,3,13,22,8,4,15,21,6};
int U[24]={1,2,4,3,18,14,10,6,17,13,9,5};
int R[24]={13,14,16,15,2,19,22,10,4,17,24,12};


struct node
{
char s[26];
bool from;
__int64 change()
{
__int64 x=0;
for(int i=1;i<25;i++)
{
x=x*6+s[i];
}
return x;
}
void change(__int64 x)
{
for(int i=24;i>0;i--)
{
s[i]=x%6;
x/=6;
}
}
};




struct state
{
__int64 pre;
int how;bool from;
};



node Fcloroude(node po)
{
int tmp;
for(int i=0;i<12;i+=4)
{
tmp=po.s[F[i+3]];
for(int j=3;j>0;j--)
{
po.s[F[j+i]]=po.s[F[i+j-1]];
}
po.s[F[i]]=tmp;
}
return po;
}
node Ucloroude(node po)
{
int tmp;
for(int i=0;i<12;i+=4)
{
tmp=po.s[U[i+3]];
for(int j=3;j>0;j--)
{
po.s[U[j+i]]=po.s[U[i+j-1]];
}
po.s[U[i]]=tmp;
}
return po;
}
node Rcloroude(node po)
{
int tmp;
for(int i=0;i<12;i+=4)
{
tmp=po.s[R[i+3]];
for(int j=3;j>0;j--)
{
po.s[R[j+i]]=po.s[R[i+j-1]];
}
po.s[R[i]]=tmp;
}
return po;
}
node Funcloroude(node po)
{
int tmp;
for(int i=0;i<12;i+=4)
{
tmp=po.s[F[i]];
for(int j=0;j<3;j++)
{
po.s[F[j+i]]=po.s[F[i+j+1]];
}
po.s[F[i+3]]=tmp;
}
return po;
}
node Uuncloroude(node po)
{
int tmp;
for(int i=0;i<12;i+=4)
{
tmp=po.s[U[i]];
for(int j=0;j<3;j++)
{
po.s[U[j+i]]=po.s[U[i+j+1]];
}
po.s[U[i+3]]=tmp;
}
return po;
}
node Runcloroude(node po)
{
int tmp;
for(int i=0;i<12;i+=4)
{
tmp=po.s[R[i]];
for(int j=0;j<3;j++)
{
po.s[R[j+i]]=po.s[R[i+j+1]];
}
po.s[R[i+3]]=tmp;
}
return po;
}

node roudeit(node po,int i)
{
switch(i)
{
case 3:return Fcloroude(po);
case 4:return Ucloroude(po);
case 5:return Rcloroude(po);
case 0:return Funcloroude(po);
case 1:return Uuncloroude(po);
case 2:return Runcloroude(po);
}
}



map<__int64,state>search1;
int stack[200],top;

//int NUM;

void bfs(node sta,node end)
{
map<__int64,state>::iterator it;
node pp,pp2;
__int64 tmppre,t1,t2,y;

queue<node>q;
q.push(sta);
q.push(end);

search1.clear();
state tmp;

tmp.pre=-1;tmp.how=-1;tmp.from=0;
search1.insert(pair<__int64,state>(sta.change(),tmp));
tmp.from=1;
search1.insert(pair<__int64,state>(end.change(),tmp));

//NUM=0;
while(!q.empty())
{
//NUM++;
pp=q.front();
q.pop();
tmppre=pp.change();
//cout<<"abx"<<endl;
//for(int i=1;i<25;i++) cout<<pp.s[i];cout<<endl;

if(pp.from)
{
for(int i=3;i<6;i++)
{
pp2=roudeit(pp,i);
y=pp2.change();
it=search1.find(y);
if(it==search1.end())
{
q.push(pp2);
tmp.pre=tmppre;
tmp.how=i;
tmp.from=pp2.from;
search1.insert(pair<__int64,state>(y,tmp));
}
else
{
if(it->second.from!=pp.from)
{
top=0;
t1=y;
while(it->second.pre!=-1)
{
stack[++top]=it->second.how;
t1=it->second.pre;
it=search1.find(t1);
}

while(top>0)
{
switch(stack[top--])
{
case 0:printf("Z");break;
case 1:printf("Y");break;
case 2:printf("X");break;
}
}

stack[++top]=i;
t2=pp.change();
it=search1.find(t2);

while(it->second.pre!=-1)
{
stack[++top]=it->second.how;
t2=it->second.pre;
it=search1.find(t2);
}

for(int j=1;j<=top;j++)
{
switch(stack[j])
{
case 3:printf("Z");break;
case 4:printf("Y");break;
case 5:printf("X");break;
}
}
//cout<<"a"<<endl;
return;
}

}
}
}
else
{
for(int i=0;i<3;i++)
{
pp2=roudeit(pp,i);
y=pp2.change();
it=search1.find(y);
if(it==search1.end())
{
q.push(pp2);
tmp.pre=tmppre;
tmp.how=i;
tmp.from=pp2.from;
search1.insert(pair<__int64,state>(y,tmp));
}
else
{
if(it->second.from!=pp.from)
{
top=0;
t2=y;
stack[++top]=i;
it=search1.find(pp.change());
while(it->second.pre!=-1)
{
stack[++top]=it->second.how;
t1=it->second.pre;
it=search1.find(t1);
}
while(top>0)
{
switch(stack[top--])
{
case 0:printf("Z");break;
case 1:printf("Y");break;
case 2:printf("X");break;
}
}
//t2=pp2.change();
it=search1.find(t2);
while(it->second.pre!=-1)
{
stack[++top]=it->second.how;
t2=it->second.pre;
it=search1.find(t2);
}
for(int j=1;j<=top;j++)
{
switch(stack[j])
{
case 3:printf("Z");break;
case 4:printf("Y");break;
case 5:printf("X");break;
}
}
//cout<<"b"<<endl;
return;
}

}
}
}
}
}



char map0[10][10];
int map1[10][10]={{0,0,1,2},{0,0,3,4},{5,6,9,10,13,14,17,18},{7,8,11,12,15,16,19,20},{0,0,21,22},{0,0,23,24}};
int numit(char w)
{
switch(w)
{
case 'G':return 0;
case 'Y':return 1;
case 'B':return 2;
case 'W':return 3;
case 'R':return 4;
case 'O':return 5;
}
}

int fd(int a,int b,int c,int d,int e)
{
if(a==c)
{
if(b==d) return e;
if(b==e) return d;
}
else if(a==d)
{
if(b==c) return e;
if(b==e) return c;
}
else if(a==e)
{
if(b==c) return d;
if(b==d) return c;
}
return -1;
}

int w[8][3]={{1,5,18},{3,6,9},{8,11,21},{4,10,13},{12,15,22},{2,14,17},{16,19,24},{7,20,23}};

int main()
{
node sta,end;
while(1)
{
for(int i=0;i<6;i++) scanf("%s",map0[i]);
if(map0[0][2]=='.') break;
for(int i=0;i<6;i++)
for(int j=0;j<8;j++)
{
if(map0[i][j]!='.')
{
sta.s[map1[i][j]]=numit(map0[i][j]);
}
}

end.s[5]=sta.s[7];
end.s[21]=sta.s[23];
end.s[17]=sta.s[20];
for(int i=0;i<7;i++)
{
if((end.s[9]=fd(end.s[5],end.s[21],sta.s[w[i][0]],sta.s[w[i][1]],sta.s[w[i][2]]))!=-1)
{
break;
}
}
for(int i=0;i<7;i++)
{
if((end.s[1]=fd(end.s[5],end.s[17],sta.s[w[i][0]],sta.s[w[i][1]],sta.s[w[i][2]]))!=-1)
{
break;
}
}
for(int i=0;i<7;i++)
{
if((end.s[13]=fd(end.s[17],end.s[21],sta.s[w[i][0]],sta.s[w[i][1]],sta.s[w[i][2]]))!=-1)
{
break;
}
}
for(int i=1;i<25;i+=4)
for(int j=1;j<4;j++) end.s[i+j]=end.s[i];
//sta.s[0]=end.s[0]='a';sta.s[25]=end.s[25]=0;
//for(int i=1;i<25;i++) cout<<sta.s[i]<<' ';cout<<endl;
//for(int j=1;j<25;j++) cout<<end.s[j]<<' ';cout<<endl;

sta.from=0;end.from=1;
bfs(sta,end);
printf("\n");
//cout<<NUM<<endl;
}
return 0;
}

 

有建议欢迎指出。

转载于:https://www.cnblogs.com/just-waiting/archive/2011/12/06/2277595.html

ary44429
关注
字节跳动2018笔试附加题，二阶数字魔方
Notteaquail的博客
08-17 581
魔方的旋转方式大致可分为三个（顺时针可以通过对应逆时针旋转三次实现），右面（Y）逆时针，后面（X）逆时针，上面（Z）逆时针，封装成三个函数，分析发现，所有的旋转可以归结为一圈八个块的位置轮转（函数zheng）和一个侧面四个小块的位置轮换（函数ce）。 不超过5次的操作，可以通过一个类似深度优先遍历操作实现（这里会有很多重复，暂时没有优化） 代码如下，最后只通过了10%测试用例，找不大问题在哪，...
2阶魔方自动旋转拼凑
weixin_69070454的博客
04-24 269
2阶魔方
牛客网 字节跳动算法题-二阶魔方最大优美度
weixin_43766033的博客
09-16 341
描述 二阶魔方又叫小魔方，是222的立方形结构。每一面都有4个块，共有24个块。每次操作可以将任意一面逆时针或者顺时针旋转90°，如将上面逆时针旋转90°操作如下。 Nero在小魔方上做了一些改动，用数字替换每个块上面的颜色，称之为数字魔方。魔方上每一面的优美度就是这个面上4个数字的乘积，而魔方的总优美度就是6个面优美度总和。 现在Nero有一个数字魔方，他想知道这个魔方在操作不超过5次的前提下能达到的最大优美度是多少。 魔方展开后每一块的序号如下图： 输入描述： 输入一行包含24个数字，按序号顺序给出
【项目实践】二阶魔方搜索算法
Explore_Zhou
03-19 2261
课程《智能控制基础》课后作业要求编写一个二阶魔方搜素求解的算法，由于本人的代码水平真的不行，只能“面向互联网编程”，前前后后找了不少资料，也确实学习到一点东西，记录一下。
【C++】二阶魔方还原算法
03-19
在本文中，我们将深入探讨如何使用C++编程语言和广度优先搜索（BFS）算法来解决二阶魔方的还原问题。二阶魔方，相比于三阶魔方，其结构更为简单，但依然需要一定的策略和算法来完成复原。 首先，我们需要理解魔方的...
二阶魔方还原C++代码实现
07-25
二阶魔方还原C++代码实现 本资源为C++语言实现的二阶魔方还原算法，通过对魔方状态的变换和搜索来实现还原。该算法使用了面向对象编程的思想，定义了一个Cube类，包含了魔方状态、目标状态、搜索队列、搜索栈、哈希...
二阶魔方_massagek9c_二阶魔方BFS_二阶魔方_
10-03
二阶魔方是一种简化版的魔方，相对于标准的三阶魔方，它只有两层，因此更加小巧，也相对容易复原。本教程主要关注的是如何利用广度优先搜索（BFS）算法来解决二阶魔方的复原问题。 广度优先搜索是一种在图或树中...
二阶魔方的最少步打乱 Apare_xzc
01-06
二阶魔方的最少步打乱 Apare_xzc 2020.2.20 13:17 前言：  博主xzc是一个魔方爱好者，三阶sub 25s。虽然水平不高，但是对魔方十分热爱。博主对二阶魔方编码，然后通过bfs得到了二阶魔方的全部状态。 下面是得到的...
【二阶魔方还原】第十次OJ的总结
SOAR
01-05 2432
问题描述     二阶魔方是 2x2x2 的立方体结构魔方，它共有 8 块，如下图所示： 图1  二阶魔方示意图     我们可以定义魔方作为一个正六面体的六个面为 F(ront), B(ack), U(p), D(own), L(eft), R(ight)。我们根据先前后后，先上后下，先左后右的方法，依次给魔方的每一个方块编号，块编号的方式如下表所示： 表1  二阶魔方块编号表 ...
二阶魔方旋转
licong0716的专栏
05-18 1095
魔方可以对它的6个面自由旋转。 我们来操作一个2阶魔方（如图1所示）： 为了描述方便，我们为它建立了坐标系。 各个面的初始状态如下： x轴正向：绿 x轴反向：蓝 y轴正向：红 y轴反向：橙 z轴正向：白 z轴反向：黄 假设我们规定，只能对该魔方进行3种操作。分别标记为： x 表示在x轴正向做顺时针旋转 y 表示在y轴正向做顺时针旋转 z 表示在z轴正向
二阶魔方的还原
一步一脚印
07-22 4876
吐槽一下360图书馆，拷贝一下都要登陆真的难受。下次可以研究爬虫去爬它了。 第一步：完成一面以此当作底面,假如我们先转红色一面(注意:第一层四个侧面的颜色也要一致)就像下面的样子 第二步,完成顶面颜色把魔方颠倒过来,红色作底面 现在我们只看魔方顶面,会有以下7种情形(假设顶面是橙色,除底面和它相邻的四个侧面的颜色,剩下的一种颜色是顶面颜色),然后对照相应的公式,转一次
7种分析问题的思维方法
java、c++、机器学习方向King
03-18 2846
SWOT分析法 它是用来确定企业自身的竞争优势、竞争劣势、机会和威胁，从而将公司的战略与公司内部资源、外部环境有机地结合起来的一种科学的分析方法。对于优势和弱势是内部环境的分析，机会和威胁是对于外部环境的分析。这个模型可以用于多种方面，任何和商品，贸易，竞争有关系的都适用，而人也是一种商品。这个模型可以帮助你理清现状。 5w2h分析法 它广泛用于企业管理和技术活动
二维数组魔方
iu_81的专栏
05-03 5527
#include iostream>using namespace std;#define n 16void main() ...{     int a[n][n]=...{0};     int b,c,d,e,f;     printf("请输入魔方阵的阶数：");     scanf("%d",&b);     e=b/2;     d=0;     for(c=1;cb*b;c++) 
Red and Black
weixin_44162158的博客
09-19 218
There is a rectangular room, covered with square tiles. Each tile is colored either red or black. A man is standing on a black tile. From a tile, he can move to one of four adjacent tiles. But he can't move on red tiles, he can move only on black tiles. W.
蓝桥杯之二阶魔方旋转（第二种方法）
sword_anyone的博客
05-14 1198
魔方可以对它的6个面自由旋转。我们来操作一个2阶魔方（如图1所示） 为了描述方便，我们为它建立了坐标系。各个面的初始状态如下： x轴正向：绿 x轴反向：蓝 y轴正向：红 y轴反向：橙 z轴正向：白 z轴反向：黄假设我们规定，只能对该魔方进行3种操作。分别标记为： x 表示在x轴正向做顺时针旋转 y 表示在y轴正向做顺时针旋转 z 表示在z轴正向做顺时针旋转基本旋转后的效果如图2,
二阶魔方(2013蓝桥杯模拟)
weixin_30892763的博客
04-06 309
题目 标题：二阶魔方 魔方可以对它的6个面自由旋转。 我们来操作一个2阶魔方（如图1所示） 为了描述方便，我们为它建立了坐标系。 各个面的初始状态如下： x轴正向：绿 x轴反向：蓝 y轴正向：红 y轴反向：橙 z轴正向：白 z轴反向：黄 假设我们规定，只能对该魔方进行3种操作。分别标记为： x 表示在x轴正向做顺时针旋转 y 表示在y轴正向做顺时针旋转 z ...
二阶魔方最少步骤复原
最新发布
09-14
二阶魔方最少步骤复原的方法可以通过引用1和引用3来回答。根据引用1中提到的博主xzc使用编码和bfs算法得到了二阶魔方的全部状态，可以通过这些状态来计算出最少步骤复原的方法。另外，根据引用3中提到的主流还原方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值