hdu 1043 Eight (八数码问题)【BFS】+【康拓展开】

<题目链接>

题目大意：
给出一个3×3的矩阵（包含1～8数字和一个字母x），经过一些移动格子上的数后得到连续的1～8，最后一格是x，要求最小移动步数。

解题分析：
本题用BFS来寻找路径，为了降低复杂度，用BFS从最终的目标状态开始处理，将所有搜索到状态以及对应的路径打表记录，然后对于输入的矩阵，直接查表输出答案 即可，本题还有一个难点，就是如何判断记录已经搜索过的状态，如果使用map+string(矩阵看成一维)会超时，所以我们这里用康拓展开式来记录状态。这道题比较玄学的地方在于如果更换dir 中四个方向的顺序，可能会WA，而在题目中没有对输出的字符串做任何限制，不知道这是为什么。

#include<cstdio>
#include<iostream>
#include<queue>
using namespace std;
typedef struct nn
{
    char way;     //记录操作
    int fath;     //记录父节点,用于记录路径
}node1;  

typedef struct nod
{
    int aa[];
    int n;      //n为9在aa中的位置
    int son;    //记录aa的康拓展开式
}node2;  

int dir[][]={{,},{,-},{,},{-,}},fac[];
node1 Node[];//节点  

void set_fac()//计算0到8的阶层
{
    fac[]=;
    for(int i=;i<=;i++)
    fac[i]=fac[i-]*i;
}  

int cantor(int aa[])//康托展开，掌握康拓展开的方法
{
    int ans=;
    for(int i=;i<;i++)
    {
        int k=;
        for(int j=i+;j<;j++)
        if(aa[i]>aa[j])
        k++;
        ans+=k*fac[-i];  //i点以后比aa[i]小的数的个数*((n-i)-1)! 之和
    }
    return ans;
}  

void bfs(int a[])
{
    queue<node2>Q;
    node2 now,next;  

    for(int i=;i<;i++) now.aa[i]=a[i];
    now.n=;now.son=;
    Node[now.son].fath=;        //把最终父节点记为0，也就是本身
    Q.push(now);
    while(!Q.empty())
    {
        now=Q.front(); Q.pop();
        for(int k=;k<;k++)
        {
            next=now;
            int tx=now.n/+dir[k][];
            int ty=now.n%+dir[k][];
            if(ty>=&&tx>=&&ty<&&tx<)
            {
                next.n=tx*+ty;      //得到移动后x的位置
                int tem=next.aa[next.n];    //得到移动后该位置的原数字
                next.aa[next.n]=next.aa[now.n];
                next.aa[now.n]=tem;         //将两个位置上的数字交换
                next.son=cantor(next.aa); 

                if(Node[next.son].fath==-)     //为－1时表示这个点没有访问过，那么放入队列
                {
                    Node[next.son].fath=now.son;   //当前节点的父节点就是上一个节点
                    if(k==)Node[next.son].way='l';//一定要注意了，k=0是向右走，但我们是从终止状态往回搜，所以直接记录相反的方向
                    if(k==)Node[next.son].way='r';
                    if(k==)Node[next.son].way='u';
                    if(k==)Node[next.son].way='d';
                    Q.push(next);
                }
            }
        }
    }
}  

int main()
{
    int i,j,s,ss[],a[];  

    for(i=;i<;i++)//目标状态
        a[i]=i+;                //建立目标一维矩阵，把x看成9  

    for(i=;i<;i++)
    Node[i].fath=-;
    set_fac();     //计算阶层
        bfs(a);    //将从最终状态能够延伸出去的所有状态以及对应路径提前打表记录 

    char str[];
    while(gets(str))
    {
        for(i=,j=;str[i]!='\0';i++)//把字符串变成数子
        {
             if(str[i]=='x')
            ss[j++]=;  //把x变为数子9
            else if(str[i]>=''&&str[i]<='')
            ss[j++]=str[i]-'';
        }
        s=cantor(ss);    //算出初态康托值
       if(Node[s].fath==-) {printf("unsolvable\n");continue;}   //不能变成目标,因为当从起点开始搜索的时候，fath表示搜索到某
       //点时，上一个点的状态，所以，如果s.fath==-1时，表示这个矩阵根本就延伸不出去，不可能达到目标状态

        while(s!=)
        {
            printf("%c",Node[s].way);
            s=Node[s].fath;
        }
        printf("\n");
    }
}

2018-09-06