HDU1043 Eight(BFS)

　　Eight(South Central USA 1998)

Time Limit:5000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u

Description

The 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 on it, and all packed into a 4 by 4 frame with one tile missing. Let's call the missing tile 'x'; the object of the puzzle is to arrange the tiles so that they are ordered as: 

 1  2  3  4
 5  6  7  8
 9 10 11 12
13 14 15  x

where the only legal operation is to exchange 'x' with one of the tiles with which it shares an edge. As an example, the following sequence of moves solves a slightly scrambled puzzle: 

 1  2  3  4     1  2  3  4     1  2  3  4     1  2  3  4
 5  6  7  8     5  6  7  8     5  6  7  8     5  6  7  8
 9  x 10 12     9 10  x 12     9 10 11 12     9 10 11 12
13 14 11 15    13 14 11 15    13 14  x 15    13 14 15  x
 r->            d->            r->

The letters in the previous row indicate which neighbor of the 'x' tile is swapped with the 'x' tile at each step; legal values are 'r','l','u' and 'd', for right, left, up, and down, respectively. 

Not all puzzles can be solved; in 1870, a man named Sam Loyd was famous for distributing an unsolvable version of the puzzle, and 
frustrating many people. In fact, all you have to do to make a regular puzzle into an unsolvable one is to swap two tiles (not counting the missing 'x' tile, of course). 

In this problem, you will write a program for solving the less well-known 8-puzzle, composed of tiles on a three by three 
arrangement. 

 

Input

You will receive, several descriptions of configuration of the 8 puzzle. One description is just a list of the tiles in their initial positions, with the rows listed from top to bottom, and the tiles listed from left to right within a row, where the tiles are represented by numbers 1 to 8, plus 'x'. For example, this puzzle 

1 2 3 
x 4 6 
7 5 8 

is described by this list: 

1 2 3 x 4 6 7 5 8 

 

Output

You will print to standard output either the word ``unsolvable'', if the puzzle has no solution, or a string consisting entirely of the letters 'r', 'l', 'u' and 'd' that describes a series of moves that produce a solution. The string should include no spaces and start at the beginning of the line. Do not print a blank line between cases. 

 

Sample Input

2 3 4 1 5 x 7 6 8

 

Sample Output

ullddrurdllurdruldr

 

题目简单翻译：

八数码

给你一个八数码：（格式是一个九宫格，x代表空），问怎么操作能达到目标，即：

1 2 3

4 5 6

7 8 x

u代表空格向上交换，d代表空格向下交换，l代表空格向左交换，r代表空格向右交换。

例如：

给你一个八数码：

1 2 3

x 4 6

7 5 8

则把它变成目标需要三步：

1 2 3　　　r　 　1 2 3　　　d　　　1 2 3　　r　　　1 2 3

x 4 6　　--->　　4 x 6　　--->　　4 5 6　　--->　　4 5 6

7 5 8　　　　　　7 5 8　　　　　　7 x 8　　　　　　7 8 x

所以这个样例应该输出：

rdr

如果不能到达目标就输出“unsolvable”.

 

解题思路：广度优先搜索（BFS）

因为是多组数据，我们可以先求出所有情况，然后每次询问的时候直接输出结果就好了。

求出所有结果，我们就可以根据结果，来逆向bfs，直到所有的情况都求到。

 

代码：

#include<cstdio>
#include<string>
#include<queue>
#include<cstring>
using namespace std;
struct node
{
    int t[3][3],x,y,Can;
    int Last_Can,dir;
} St[370000];
int fac[]= {1,1,2,6,24,120,720,5040,40320};
//康托展开的数组
//康托展开就是把一组数据按照字典序排列的那组数据的序号

int vis[370000];
queue<int> Q;
char dr[]="rlud";
int  dx[]= {0,0,1,-1};
int  dy[]= {-1,1,0,0};
//方向数组，与实际的方向相反，因为是逆向操作
int Cantor(int *t)//对一组数据求康拓值
{
    int rev=0;
    for(int i=0; i<9; i++)
    {
        int counted=0;
        for(int j=i+1; j<9; j++)
            if(t[i]>t[j]) counted++;
        rev+=counted*fac[8-i];
    }
    return rev;
}
bool check(int x,int y) //检查这个点是不是在矩形内
{
    return x>=0&&x<3&&y>=0&&y<3;
}
void solve()//bfs求出所有的情况，并储存下来父节点
{
    while(!Q.empty()) Q.pop();
    node st;
    st.x=st.y=2;
    int s[3][3]= {1,2,3,4,5,6,7,8,0};
    int t[9];
    for(int i=0; i<3; i++)
        for(int j=0; j<3; j++)
            t[i*3+j]=s[i][j];
    for(int i=0; i<3; i++)
        for(int j=0; j<3; j++)
            st.t[i][j]=s[i][j];
    int StCan=Cantor(t);
    st.Can=StCan;
    st.Last_Can=-1;
    st.dir=-1;
    memset(vis,0,sizeof vis);
    vis[StCan]=1;
    St[StCan]=st;
    Q.push(StCan);
    int Sum=0;
    while(!Q.empty())
    {
        Sum++;
        int TempCan=Q.front();
        Q.pop();
        for(int i=0; i<4; i++)
        {
            node e=St[TempCan];
            int curx=e.x+dx[i];
            int cury=e.y+dy[i];
            if(check(curx,cury))
            {
                int c=e.t[curx][cury];
                e.t[curx][cury]=e.t[e.x][e.y];
                e.t[e.x][e.y]=c;
                e.x=curx;
                e.y=cury;
                int t[9];
                for(int i=0; i<3; i++)
                    for(int j=0; j<3; j++)
                        t[i*3+j]=e.t[i][j];
                e.Can=Cantor(t);
                e.Last_Can=TempCan;
                e.dir=i;
                if(!vis[e.Can])
                {
                    vis[e.Can]=1;
                    St[e.Can]=e;
                    Q.push(e.Can);
                }
            }
        }
    }
}
int main()
{
    char c[10];
    int t[9],x=0;
    solve();
    while(scanf("%s",c)!=EOF)
    {
        if(c[0]=='x') c[0]='0';
        t[0]=c[0]-'0';
        for(int i=1;i<9;i++)
        {
            scanf("%s",c);
            if(c[0]=='x') c[0]='0';
            t[i]=c[0]-'0';
        }
        int AnsCan=Cantor(t);
        if(vis[AnsCan])
        {
            int p=AnsCan;
            while(St[p].Last_Can+1)
            {
                printf("%c",dr[St[p].dir]);
                p=St[p].Last_Can;
            }
            printf("
");
        }
        else
            printf("unsolvable
");
    }
    return 0;
}