三阶平面魔方（BFS）

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

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

初始状态为


123

456

789

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

231

456

789

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

输入格式

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

输出格式

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

样例输入

412
756
389

样例输出

2 

将魔方的状态转为数字，然后再用结构体存储，去进行状态变换，然后就是用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+10;
using namespace std;

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

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

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

int main()
{
    #ifdef DEBUG
    freopen("sample.txt","r",stdin);
    #endif
    
    for(int i=1;i<=3;i++)
    {
        for(int j=1;j<=3;j++)
        {
            last.a[i][j]=(i-1)*3+j;
        }
    }
    node first;
    for(int i=1;i<=3;i++)
    {
        int n;
        scanf("%d",&n);
        first.a[i][3]=n%10;
        first.a[i][2]=(n/10)%10;
        first.a[i][1]=n/100;
    }
    BFS(first);
    
    return 0;
}

-