蓝桥杯——九宫重排（bfs）

题目：http://lx.lanqiao.cn/problem.page?gpid=T42

分析：这一题可以对应到“迷宫最短路径”问题，是否能到达终点，若能到达最短步数是多少？用bfs,广度搜索解决，用到队列

将‘.’作为移动的对象，每移动一次，map[][]（九宫格图案）状态改变一次，并且把每一次状态（一定要是新的状态）（定义为结构体node,结构体内容包括：map[][]，从最初状态到当前状态移动的步数，‘.’的位置）存入队列que中，每一个map[][]对应一个数值val（将‘.’看做9，从左到右，从上到下抄写）

如：1 2 3
          4 6
       7 5 8  对应的val值为123946758，这个值用来判断当前map[][]是否出现过（判重，出现过就不计入que，相当于不走这一步了，不走已经走过的情况，不免死循环），每一个不一样的值放入set集合容器中（set可以快速的查询，删除，插入）
不断取que里队首元素作为移动的起点，新的状态放入队尾，直到队列为空，最终得出的步数即为最短步数。

代码：

#include<stdio.h>
#include<string.h>
#include<set>
#include<queue>
using namespace std;
int Gval;//目标图案对应的值
int D[4][2]= {-1,0,1,0,0,-1,0,1}; //上下左右
struct node
{
    int x,y;//‘.’坐标
    int step;
    char map[3][3];
};
queue<node> que;
set<int> se;
int Get_value(char map[][3]) //得到九宫格图案对应的值
{
    int val=0;
    for(int i=0; i<3; i++)
    {
        for(int j=0; j<3; j++)
        {
            if(map[i][j]!='.')
            {
                val=val*10+map[i][j]-'0';//用来字符数字转换成整形数字
            }
            else
            {
                val=val*10+9;
            }
        }
    }
    return val;
}
int bfs()
{
    node n,n1;
    char Nmap[3][3];
    int i,j,xx,yy,val;
//如果队列为空,没找到，返回-1
    if(que.empty())
    {
        return -1;
    }
    while(!que.empty())
    {
        n=que.front();//取出队首
        que.pop();
        for( i=0; i<4; i++)
        {
            xx=n.x+D[i][0];
            yy=n.y+D[i][1];
            if(xx<0||xx>2||yy<0||yy>2) //越界
            {
                continue;
            }
            //走动了，形成新的图案，查看是否和以前的重了，如果没重，入队列
            memcpy(Nmap,n.map,sizeof(n.map));
            Nmap[n.x][n.y]=n.map[xx][yy];
            Nmap[xx][yy]='.';//新的map
            val=Get_value(Nmap);
            if(val==Gval) //说明到达了目标状态
            {
                return n.step+1;
            }
            if(se.find(val)==se.end()) //说明set里没有此val，说明与之前的不重复
            {
                se.insert(val);//插入val
                n1.x=xx;
                n1.y=yy;
                n1.step=n.step+1;
                memcpy(n1.map,Nmap,sizeof(Nmap));
                que.push(n1);
            }
        }
    }
}
int main()
{
    node n;
    char str1[15],str2[15],Smap[3][3],Gmap[3][3],ans;
    int len=0,i,j,xx,yy;
    //读入开始状态，并处理
    gets(str1);
    for(i=0; i<3; i++)
    {
        for(j=0; j<3; j++)
        {
            if(str1[len]=='.')
            {
                xx=i;
                yy=j;
            }
            Smap[i][j]=str1[len];
            len++;
        }
    }
    n.x=xx;
    n.y=yy;
    n.step=0;
    memcpy(n.map,Smap,sizeof(Smap));//二维数组复制
    que.push(n);
    se.insert(Get_value(Smap));
    //读入目标状态，并处理
    gets(str2);
    len=0;
    for(i=0; i<3; i++)
    {
        for(j=0; j<3; j++)
        {
            Gmap[i][j]=str2[len++];
        }
    }
    Gval=Get_value(Gmap);//目标状态对应的值
    ans=bfs();
    printf("%d",ans);
    return 0;
}