HDU1043 Eight[bfs]

A - Eight

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

Submit  Status

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

要做预处理,不然会超时.

注意 因为是从1 2 3 4 5 6 7 8 x 这个情况开始打的表, 记得x是的移动是相反的 

用康拓展开来计算hash值,然后用数组去保存结果

记得保存路径的时候 先是dir的在前然后再加上已经走了的路径 因为是从终点走回去起点.

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<string>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<vector>
using namespace std;
const int N=4e5;
int dir[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
int fac[]={1,1,2,6,24,120,720,5040,40320,362880};
const int aim=46233;
bool mark[N];
string ans[N];
char dis[]="dlur";//注意反过来...   从12345678x开始的  所以向下是向上 向左是向右
struct node
{
    int num[10];
    int x,ha;
    string path;
};
int Cantor(int num[])// 用康拓展开计算hash值
{
    int sum=0;
    for (int i=0 ; i<9 ; i++)
    {
        int cnt=0;
        for (int j=i+1; j<9 ; j++)
            if (num[i]>num[j])
                cnt++;
        sum+=cnt*fac[9-i-1];
    }
    return sum;
}
queue<node>q;
void bfs(node start)
{
    while (!q.empty())
        q.pop();
    node later;
    q.push(start);
    while (!q.empty())
    {
        start=q.front();
        q.pop();
        int x=start.x/3;
        int y=start.x%3;
        for (int i=0 ; i<4 ; i++)
        {
            int nx=x+dir[i][0];
            int ny=y+dir[i][1];
            if (nx<0 || nx>=3 || ny<0 || ny>=3)
                continue;
            later=start;
            later.x=nx*3+ny;
            later.num[start.x]=later.num[later.x];
            later.num[later.x]=0;
            later.ha=Cantor(later.num);
            if (!mark[later.ha])
            {
                mark[later.ha]=1;
                later.path=dis[i]+later.path;
                ans[later.ha]=later.path;
                q.push(later);
            }
        }
    }
}
int main()
{
    //printf("%d\n",Cantor(num)); //答案的哈希值 1,2,3,4,5,6,7,8,0
    char ch;
    memset(mark,0,sizeof(mark));
    node now;
    for (int i=0 ; i<8 ; i++)
        now.num[i]=i+1;
    now.num[8]=0;
    now.x=8;
    now.path="";
    ans[aim]=now.path;
    mark[aim]=1;
    bfs(now);
    while (cin>>ch)//scanf一直输入会出现错误...
    {
        if (ch=='x')
            now.num[0]=0;
        else
            now.num[0]=ch-'0';
        for (int i=1 ; i<9 ; i++)
        {
            cin>>ch;
            if (ch=='x')
                now.num[i]=0;
            else
                now.num[i]=ch-'0';
        }
        now.ha=Cantor(now.num);
        if (mark[now.ha])
            cout<<ans[now.ha]<<endl;
        else
            printf("unsolvable\n");
    }
    return 0;
}