三阶平面魔方（BFS）

有一个  3×3 的平面魔方，在平面魔方中，每个格子里分别无重复地写上 1 - 9 这 9 个数字。一共有 4 种对平面魔方的操作：

• 选择某一行左移。
• 选择某一行右移。
• 选择某一列上移。
• 选择某一列下移。

初始状态为


123

456

789

比如选择第一行左移，魔方会变成下面这样

231

456

789

现在给出魔方的一个状态，问你能否将魔方复原成初始状态。如果可以，计算最少操作次数。

输入格式

输入三行，每行三个 1 到 9 之间的整数。

输出格式

如果能还原成初始状态，输出最小的操作次数，否则输出 -1。

样例输入

样例输出

将魔方的状态转为数字，然后再用结构体存储，去进行状态变换，然后就是用map来判重并存操作数

 #include <stdio.h>
 #include <string.h>
 #include <iostream>
 #include <string>
 #include <math.h>
 #include <algorithm>
 #include <vector>
 #include <stack>
 #include <queue>
 #include <set>
 #include <map>
 #include <sstream>
 const int INF=0x3f3f3f3f;
 typedef long long LL;
 const int maxn=1e7+;
 using namespace std;

 struct node
 {
     int a[][];
     bool operator < (const node &ts) const //map需要
     {
         for(int i=;i<=;i++)
         {
             for(int j=;j<=;j++)
             {
                 if(a[i][j]<ts.a[i][j])
                     return ;
             }
         }
         return ;
     }
     bool operator == (const node &ts) const //用于出递归
     {
         for(int i=;i<=;i++)
         {
             for(int j=;j<=;j++)
             {
                 if(a[i][j]!=ts.a[i][j])
                     return ;
             }
         }
         return ;
     }
     void print()
     {
         for(int i=;i<=;i++)
         {
             for(int j=;j<=;j++)
             {
                 printf(j==?"%d\n":"%d",a[i][j]);
             }
         }
     }
     int tonum()//返回一个代表魔方状态的int
     {
         int res=;
         for(int i=;i<=;i++)
         {
             for(int j=;j<=;j++)
             {
                 res=res*+a[i][j];
             }
         }
         return res;
     }
 };
 node last;

 node rotate(node u,int num,int op)//获取魔方的下一个状态
 {
     node res=u;
     if(op==-)//右移
     {
         swap(res.a[num][],res.a[num][]);
         swap(res.a[num][],res.a[num][]);
     }
     else if(op==)//左移
     {
         swap(res.a[num][],res.a[num][]);
         swap(res.a[num][],res.a[num][]);
     }
     else if(op==-)//上移
     {
         swap(res.a[][num],res.a[][num]);
         swap(res.a[][num],res.a[][num]);
     }
     else if(op==)//下移
     {
         swap(res.a[][num],res.a[][num]);
         swap(res.a[][num],res.a[][num]);
     }
     return res;
 }

 void BFS(node first)
 {
     queue<node> qe;
     map<int,int> mp;//判断某一状态是否出现过，并且记录操作数
     qe.push(first);
     mp[first.tonum()]=;
     while(!qe.empty())
     {
         node t=qe.front();
         qe.pop();
         int tt=t.tonum();
         if(t==last)
         {
             printf("%d\n",mp[t.tonum()]);
             return ;
         }
         node to;
         for(int i=;i<=;i++)
         {
             to=rotate(t,i,-);
             if(!mp.count(to.tonum()))
             {
                 mp[to.tonum()]=mp[tt]+;
                 qe.push(to);
             }
             to=rotate(t,i,);
             if(!mp.count(to.tonum()))
             {
                 mp[to.tonum()]=mp[tt]+;
                 qe.push(to);
             }
             to=rotate(t,i,-);
             if(!mp.count(to.tonum()))
             {
                 mp[to.tonum()]=mp[tt]+;
                 qe.push(to);
             }
             to=rotate(t,i,);
             if(!mp.count(to.tonum()))
             {
                 mp[to.tonum()]=mp[tt]+;
                 qe.push(to);
             }
         }
     }
     printf("-1\n");//不能成功
 }

 int main()
 {
     #ifdef DEBUG
     freopen("sample.txt","r",stdin);
     #endif

     for(int i=;i<=;i++)
     {
         for(int j=;j<=;j++)
         {
             last.a[i][j]=(i-)*+j;
         }
     }
     node first;
     for(int i=;i<=;i++)
     {
         int n;
         scanf("%d",&n);
         first.a[i][]=n%;
         first.a[i][]=(n/)%;
         first.a[i][]=n/;
     }
     BFS(first);

     return ;
 }

-