POJ 1077 eight DBFS

和HDU1043一样的题目，这次用DBFS实现。

感觉写的还是不错的，中间一些细节错误了很多次。

具体见代码。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <queue>
#include <set>
#include <vector>
#include <stack>
#include <map>
#include <iomanip>
#define PI acos(-1.0)
#define Max 500005
#define inf 1<<28
#define LL(x) (x<<1)
#define RR(x) (x<<1|1)
#define Rep(i,s,t) for(int i=(s);i<=(t);++i)
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define mp(a,b) make_pair(a,b)

using namespace std;
struct kdq
{
    string op;
    char Map[4][4] ;
    int x ,y ;
    void show()
    {
        Rep(i,0,2)
        {
            Rep(j,0,2)
            cout <<char(Map[i][j] + '0');
            cout <<endl;
        }
        cout <<endl;
    }
} ;
string state[Max] ;

int fac[12] = { 0, 1, 2, 6, 24, 120,720, 5040, 40320, 362880, 3628800} ;
int kangtuo(kdq a)
{
    int ans = 0 ;
    Rep(i,0,8)
    {
        int num = 0 ;
        Rep(j,i + 1 ,8)
        {
            if(a.Map[i / 3][i % 3] > a.Map[j / 3 ][j % 3])
                num ++ ;
        }
        ans += num * (fac[8 - i]) ;
    }
    return ans ;
}
int vis[Max] ;
int mx[4] = {0,0,1,-1} ;
int my[4] = {1,-1,0,0} ;
char opp[4] = {'r' ,'l','d','u'} ;//从起点开始搜索时的交换顺序
char dopp[4] = {'l','r','u','d'} ;//从终点开始搜索时的交换顺序
int inmap(kdq a )
{
    if(a.x >= 0 && a.y <3 && a.x < 3 && a.y >= 0)return 1;
    return 0 ;
}

string bfs(kdq s )
{
    queue<kdq>q ;
    kdq init ;
    init.Map[0][0] = 1 ;
    init.Map[0][1] = 2 ;
    init.Map[0][2] = 3 ;
    init.Map[1][0] = 4 ;
    init.Map[1][1] = 5 ;
    init.Map[1][2] = 6 ;
    init.Map[2][0] = 7 ;
    init.Map[2][1] = 8 ;
    init.Map[2][2] = 9 ;
    init.x = 2 ;
    init.y = 2 ;
    init.op.clear() ;
    q.push(s) ;//起点
    q.push(init) ;//终点
    int ss = kangtuo(s) ;
    vis[ss] = 2 ;//将从起点开始遍历到的点置为2
    ss = kangtuo(init) ;
    vis[ss] = 1 ;//将从终点开始遍历到的点置为1
    while(!q.empty())
    {
        kdq temp = q.front() ;
        q.pop() ;
        int cc = kangtuo(temp) ;
        Rep(i,0,3)
        {
            kdq next = temp ;
            next.x = temp.x + mx[i] ;
            next.y = temp.y + my[i] ;
            if(inmap(next))
            {
                swap(next.Map[next.x][next.y] ,next.Map[temp.x][temp.y]) ;
                int num = kangtuo(next) ;
                if(!vis[num] )//如果未遍历过该点
                {
                    vis[num] = vis[cc] ;
                    if(vis[num] == 1)//如果是终点遍历出来的点
                        next.op += dopp[i] ;
                    else//同理
                        next.op += opp[i] ;
                    state[num] = next.op ;//记录当前的路径
                    q.push(next) ;
                }
                else if(vis[num] != vis[cc])//如果该点被起点和终点都遍历到
                {
                    string c1 ,c2 ;
                    if(vis[num] == 1)
                        c1 = state[num] ,c2 = state[cc] + opp[i];
                    else c1 = state[cc] + dopp[i] ,c2 = state[num] ;
                    reverse(c1.begin() ,c1.end()) ;//注意从终点开始遍历的顺序得取反
                    return c2 + c1 ;//那么返回该点的顺序，即为起点到终点的顺序
                }
            }
        }
    }
    return "unsolvable" ;
}

char a[10000] ;
int main()
{
    while(gets(a))
    {
        int l = strlen(a) ;
        kdq now ;
        int tx = 0 ;
        int numx ,numy ;
        Rep(i,0,l - 1)
        {
            if(a[i] >= '0' && a[i] <= '8')
            {
                now.Map[tx / 3] [tx % 3] = a[i] - '0' ;
                tx ++ ;
            }
            else if(a[i] == 'x')
            {
                now.Map[tx / 3][tx % 3] = 9 ;
                numx = tx / 3 ;
                numy = tx % 3 ;
                tx ++ ;

            }
            if(tx >= 9)break ;
        }
        mem(vis,0) ;
        now.x = numx ;
        now.y = numy ;
        now.op.clear() ;
        printf("%s\n",bfs(now).c_str()) ;
    }
    return 0;
}