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

Problem 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

 

 

Source

South Central USA 1998 (Sepcial Judge Module By JGShining)

 

 

Recommend

JGShining   |   We have carefully selected several similar problems for you:   1044  1401  1104  1254  1732

 

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

 

  1 #include<iostream>

  2 #include<stdio.h>

  3 #include<cstring>

  4 #include<cstdlib>

  5 #include<string>

  6 #include<queue>

  7 using namespace std;

  8 

  9 struct node

 10 {

 11     bool flag;

 12     char str;

 13     int father;

 14 }hash[363001];

 15 struct st

 16 {

 17     char t[10];

 18 };

 19 queue<st>Q;

 20 int ans[10]={1};

 21 

 22 int ktzk(char *c)

 23 {

 24     int i,j,k,sum=0;

 25     for(i=0;i<=8;i++)

 26     {

 27         k=0;

 28         for(j=i+1;j<=8;j++)

 29             if(c[i]>c[j])

 30                 k++;

 31         sum=sum+k*ans[8-i];

 32     }

 33     return sum;

 34 }

 35 void bfs()

 36 {

 37     int i,k,num,val;

 38     struct st cur,t;

 39     k=ktzk("123456780");

 40     hash[k].flag=true;

 41     hash[k].str='\0';

 42     hash[k].father=k;

 43 

 44     strcpy(t.t,"123456780");

 45     Q.push(t);

 46 

 47     while(!Q.empty())

 48     {

 49         cur=Q.front();

 50         Q.pop();

 51         val=ktzk(cur.t);

 52         for(i=0;i<=8;i++)

 53         {

 54             if(cur.t[i]=='0')

 55             {

 56                 k=i;

 57                 break;

 58             }

 59         }

 60         if(k!=2 && k!=5 && k!=8)//rigth

 61         {

 62             t=cur;

 63             swap(t.t[k],t.t[k+1]);

 64             num=ktzk(t.t);

 65             if(hash[num].flag==false)

 66             {

 67                 hash[num].flag=true;

 68                 hash[num].str='r';

 69                 hash[num].father=val;

 70                 Q.push(t);

 71             }

 72         }

 73         if(k!=0 && k!=3 && k!=6)//left

 74         {

 75             t=cur;

 76             swap(t.t[k],t.t[k-1]);

 77             num=ktzk(t.t);

 78             if(hash[num].flag==false)

 79             {

 80                 hash[num].flag=true;

 81                 hash[num].str='l';

 82                 hash[num].father=val;

 83                 Q.push(t);

 84             }

 85         }

 86         if(k>=3)//u

 87         {

 88             t=cur;

 89             swap(t.t[k],t.t[k-3]);

 90             num=ktzk(t.t);

 91             if(hash[num].flag==false)

 92             {

 93                 hash[num].flag=true;

 94                 hash[num].str='u';

 95                 hash[num].father=val;

 96                 Q.push(t);

 97             }

 98         }

 99         if(k<=5)//D

100         {

101             t=cur;

102             swap(t.t[k],t.t[k+3]);

103             num=ktzk(t.t);

104             if(hash[num].flag==false)

105             {

106                 hash[num].flag=true;

107                 hash[num].str='d';

108                 hash[num].father=val;

109                 Q.push(t);

110             }

111         }

112     }

113 }

114 void prepare()

115 {

116     int i;

117     for(i=0;i<=363000;i++)    

118     {

119         hash[i].flag=false;

120     }

121     for(i=1;i<=9;i++) ans[i]=ans[i-1]*i;

122     bfs();

123 }

124 int main()

125 {

126     prepare();

127     char a[50],b[10],c[100];

128     bool tom[10];

129     int i,j,k,cur;

130     while(gets(a))

131     {

132         k=strlen(a);

133         b[9]='\0';

134         for(i=0,j=0;i<k;i++)

135         {

136             if(a[i]=='x' || (a[i]>='1'&&a[i]<='8'))

137             {

138                 if(a[i]=='x')

139                     b[j]='0';

140                 else b[j]=a[i];

141                 j++;

142             }

143         }

144         memset(tom,false,sizeof(tom));

145         for(i=0;i<=8;i++)

146         {

147             tom[b[i]-'0']=true;

148         }

149         for(i=0;i<=8;i++)

150         {

151             if(tom[i]==false)

152                 break;

153         }

154         if(i<=8){printf("unsolvable\n");continue;}

155         cur=ktzk(b);

156         if(hash[cur].flag==false)

157         {

158             printf("unsolvable\n");

159             continue;

160         }

161         k=0;

162         while(hash[cur].father!=cur)

163         {

164             c[k]=hash[cur].str;

165             k++;

166             cur=hash[cur].father;

167         }

168         for(i=0;i<=k-1;i++)

169         {

170             if(c[i]=='u')printf("d");

171             if(c[i]=='d')printf("u");

172             if(c[i]=='l')printf("r");

173             if(c[i]=='r')printf("l");

174         }

175         printf("\n");

176     }

177     return 0;

178 }