网易游戏研发工程师笔试题

题目描述小Q最近被邀请去参加了网易最牛大脑的节目，挑战数字魔方的项目。 数字魔方为一个3x3的矩阵，矩阵中的每个数字都是（1…9）中的数字，且数字魔方中的数字可能重复。每4个相邻的数字我们称为1个子魔方，整个数字魔方共有4个子魔方（如下图所示）。每一次操作可以选择对某个子魔方顺时针旋转90度，180度或者270度。每个子魔方可以进行多次操作。 

对子魔方1进行一次操作，顺时针旋转90度，180度，270度后的状态：


项目的挑战任务是，给定数字魔方的一个初始状态，以及一个目标状态，问最少操作多少次可以使得魔方从初始状态改变为目标状态。 小Q求助于你，希望你能告诉他完成任务的最少操作次数是多少，或者任务不可能完成。输入描述:输入的第一行为一个正整数T（T<=20），表示测试数据组数。
接下来有T组数据。每组数据有6行。其中前3行为数字魔方的初始状态，后3行为目标状态。每个数据之后有一个空行。保证魔方中的数字为(1…9)中的数字。输出描述:对于每一组数据，输出一行，包含一个整数，为最少操作次数。如果不能完成目标，则输出-1。示例1输入21 2 34 5 67 8 95 4 16 2 37 8 9 1 2 34 5 67 8 92 5 31 4 67 8 9输出31说明第一个样例为对子魔方1旋转90度，然后对子魔方2旋转90度，再对子魔方1旋转90度。
第二个样例为对子魔方1旋转270度。 
 1.思路：
将魔方状态转换成一组字符串，由于字符串长度为9，其可能出现的状态的总数一定（不会超过9的阶乘），因此采用BFS广度优先搜索，并使用哈希表来存储状态（若使用数组来存储状态，则需要自己实现“改进的康拓展开式”）；res初始化为-1，若得到答案，则break并返回res，若得不到答案，则返回-1.

2.代码：#include <iostream>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <cstring>
#include <unordered_map>
using namespace std;
int movx[4]={0,1,3,4};
int fac[9]={1,1,2,6,24,120,720,5040,40320};
bool vis[362890];
//数组索引直接查找，时间复杂度O(1)，但需要用康拓展开，自己实现映射过程
//哈希表由红黑树实现，其查找时间复杂度为O(logN)
//C++find函数查找，时间复杂度为O(N);

struct node
{
string str;
int step;
};

int str2
4000
int(string str)
{
int cnt[9]={0};
int res=0;
int i,j;
for(i=0;i<9;i++)
cnt[str[i]-'1']++;
for(i=0;i<9;i++)
{
int x=str[i]-'1';
int y=0;
for(j=0;j<x;j++)
y+=cnt[j];
res+=y*fac[8-i];
cnt[x]--;
}
return res;
}
string rorate_str_90(string str,int x)
{
char ch;
int dx=movx[x];
ch=str[dx];
str[dx]=str[dx+3];
str[dx+3]=str[dx+4];
str[dx+4]=str[dx+1];
str[dx+1]=ch;
return str;
}
string rorate_str_180(string str,int x)
{
char ch;
int dx=movx[x];
ch=str[dx];
str[dx]=str[dx+4];
str[dx+4]=ch;
ch=str[dx+1];
str[dx+1]=str[dx+3];
str[dx+3]=ch;
return str;
}
string rorate_str_270(string str,int x)
{
char ch;
int dx=movx[x];
ch=str[dx];
str[dx]=str[dx+1];
str[dx+1]=str[dx+4];
str[dx+4]=str[dx+3];
str[dx+3]=ch;
return str;
}
string calc_str(const vector<int> num)
{
string str="";
for(int i=0;i<9;i++)
str+=('0'+num[i]);
return str;
}
int main()
{
int t,i,tmp;
cin>>t;
while(t--)
{
vector<int> init;
vector<int> res;
string init_str,res_str;
int minx=-1;
unordered_map<string, int> vis2; //初始化哈希表
// memset(vis,0,sizeof(vis));
queue<node> q;
int num;
for(i=0;i<9;i++)
{
cin>>tmp;
init.push_back(tmp);
}
for(i=0;i<9;i++)
{
cin>>tmp;
res.push_back(tmp);
}
init_str=calc_str(init);
res_str=calc_str(res);
node init_node;
init_node.step=0;
init_node.str=init_str;
q.push(init_node);
// vis[str2int(init_node.str)]=true;
while(!q.empty())
{
node tn,nx;
tn=q.front();q.pop();
if(tn.str==res_str)
{
minx=tn.step;
break;
}
for(i=0;i<4;i++)
{
nx.str=rorate_str_90(tn.str,i);
if(vis2.find(nx.str) == vis2.end()) {
vis2[nx.str] = 1;
nx.step = tn.step+1;
q.push(nx);
}
// num=str2int(nx.str);
// if(!vis[num])
// {
// vis[num]=1;
// nx.step=tn.step+1;
// q.push(nx);
// }
nx.str=rorate_str_180(tn.str,i);
if(vis2.find(nx.str) == vis2.end()) {
vis2[nx.str] = 1;
nx.step = tn.step+1;
q.push(nx);
}
// num=str2int(nx.str);
// if(!vis[num])
// {
// vis[num]=1;
// nx.step=tn.step+1;
// q.push(nx);
// }
nx.str=rorate_str_270(tn.str,i);
if(vis2.find(nx.str) == vis2.end()) {
vis2[nx.str] = 1;
nx.step = tn.step+1;
q.push(nx);
}
// num=str2int(nx.str);
// if(!vis[num])
// {
// vis[num]=1;
// nx.step=tn.step+1;
// q.push(nx);
// }
}

}
cout<<minx<<endl;
}
return 0;
}


 3.运行结果：