hdu 1043 八数码问题

Eight

Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 10778 Accepted Submission(s):
2873
Special Judge

[align=left]Problem Description[/align]
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.

[align=left]Input[/align]
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

[align=left]Output[/align]
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.

[align=left]Sample Input[/align]

2 3 4 1 5 x 7 6 8

[align=left]Sample Output[/align]

ullddrurdllurdruldr

[align=left]Source[/align]
South
Central USA 1998 (Sepcial Judge Module By JGShining)

[align=left]Recommend[/align]
JGShining | We have carefully selected several
similar problems for you: 1044 1401 1104 1254 1732

康托展开优化，代码自己写的过了，做EIGHTII的时候，发现别人bfs（）很简单，而且map[4][2]写的看不懂。

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cstdlib>
#include<string>
#include<queue>
using namespace std;

struct node
{
bool flag;
char str;
int father;
}hash[363001];
struct st
{
char t[10];
};
queue<st>Q;
int ans[10]={1};

int ktzk(char *c)
{
int i,j,k,sum=0;
for(i=0;i<=8;i++)
{
k=0;
for(j=i+1;j<=8;j++)
if(c[i]>c[j])
k++;
sum=sum+k*ans[8-i];
}
return sum;
}
void bfs()
{
int i,k,num,val;
struct st cur,t;
k=ktzk("123456780");
hash[k].flag=true;
hash[k].str='\0';
hash[k].father=k;

strcpy(t.t,"123456780");
Q.push(t);

while(!Q.empty())
{
cur=Q.front();
Q.pop();
val=ktzk(cur.t);
for(i=0;i<=8;i++)
{
if(cur.t[i]=='0')
{
k=i;
break;
}
}
if(k!=2 && k!=5 && k!=8)//rigth
{
t=cur;
swap(t.t[k],t.t[k+1]);
num=ktzk(t.t);
if(hash[num].flag==false)
{
hash[num].flag=true;
hash[num].str='r';
hash[num].father=val;
Q.push(t);
}
}
if(k!=0 && k!=3 && k!=6)//left
{
t=cur;
swap(t.t[k],t.t[k-1]);
num=ktzk(t.t);
if(hash[num].flag==false)
{
hash[num].flag=true;
hash[num].str='l';
hash[num].father=val;
Q.push(t);
}
}
if(k>=3)//u
{
t=cur;
swap(t.t[k],t.t[k-3]);
num=ktzk(t.t);
if(hash[num].flag==false)
{
hash[num].flag=true;
hash[num].str='u';
hash[num].father=val;
Q.push(t);
}
}
if(k<=5)//D
{
t=cur;
swap(t.t[k],t.t[k+3]);
num=ktzk(t.t);
if(hash[num].flag==false)
{
hash[num].flag=true;
hash[num].str='d';
hash[num].father=val;
Q.push(t);
}
}
}
}
void prepare()
{
int i;
for(i=0;i<=363000;i++)
{
hash[i].flag=false;
}
for(i=1;i<=9;i++) ans[i]=ans[i-1]*i;
bfs();
}
int main()
{
prepare();
char a[50],b[10],c[100];
bool tom[10];
int i,j,k,cur;
while(gets(a))
{
k=strlen(a);
b[9]='\0';
for(i=0,j=0;i<k;i++)
{
if(a[i]=='x' || (a[i]>='1'&&a[i]<='8'))
{
if(a[i]=='x')
b[j]='0';
else b[j]=a[i];
j++;
}
}
memset(tom,false,sizeof(tom));
for(i=0;i<=8;i++)
{
tom[b[i]-'0']=true;
}
for(i=0;i<=8;i++)
{
if(tom[i]==false)
break;
}
if(i<=8){printf("unsolvable\n");continue;}
cur=ktzk(b);
if(hash[cur].flag==false)
{
printf("unsolvable\n");
continue;
}
k=0;
while(hash[cur].father!=cur)
{
c[k]=hash[cur].str;
k++;
cur=hash[cur].father;
}
for(i=0;i<=k-1;i++)
{
if(c[i]=='u')printf("d");
if(c[i]=='d')printf("u");
if(c[i]=='l')printf("r");
if(c[i]=='r')printf("l");
}
printf("\n");
}
return 0;
}