1 #include <iostream>
  2 
  3  #include <cstdio>
  4 
  5  #include <cstring>
  6 
  7  #include < string>
  8 
  9  #include <algorithm>
 10 
 11  #include <cmath>
 12 
 13  #include <queue>
 14 
 15  
 16 
 17   using  namespace std;
 18 
 19  
 20 
 21   #define MAXN 363000   // 9!==326880
 22 
 23  
 24 
 25   struct node
 26 
 27  {
 28 
 29     int s[ 9]; // 当前状态
 30 
 31     int loc; // '0'的位置,即'x'的位置
 32 
 33     int stat; // 康托展开的hash值
 34 
 35     string path; // 路径
 36 
 37  };
 38 
 39  
 40 
 41   // 分别存储1--9的阶乘值
 42 
 43   int fac[]={ 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
 44 
 45   // 同以前一样，用一个二维数组dir[4][2]来装填方向
 46 
 47   int dir[ 4][ 2]={- 1, 0, 1, 0, 0,- 1, 0, 1};
 48 
 49   // 存储方向字符，以便在之后表明路径
 50 
 51   char index[ 5]= " udlr ";
 52 
 53   int aim= 322561; // 123456780对应的hash值
 54 
 55   string path; // 路径
 56 
 57    // 作为一种标记，遍历已经访问过的状态
 58 
 59   bool vis[MAXN];
 60 
 61   // 最初的结点
 62 
 63  node st;
 64 
 65  
 66 
 67   // 康托展开求序列的hash值
 68 
 69   int cantor( const  int *s)
 70 
 71  {
 72 
 73     int sum= 0;
 74 
 75     for( int i= 0;i< 9;i++)
 76 
 77    {
 78 
 79       int num= 0;
 80 
 81       for( int j= 0;j<i;j++)
 82 
 83         if(s[j]>s[i])
 84 
 85          num++;
 86 
 87      sum+=(num*fac[i]);
 88 
 89    }
 90 
 91     return (sum+ 1);
 92 
 93  }
 94 
 95  
 96 
 97   // 这里利用越界函数来标识是否越界
 98 
 99   bool isok( int x, int y)
100 
101  {
102 
103     if(x< 0 || x> 2 || y> 2 || y< 0)
104 
105       return  false;
106 
107     return  true;
108 
109  }
110 
111  
112 
113   bool bfs()
114 
115  {
116 
117     // 初始化vis数组，将其都标记为0
118 
119    memset(vis, 0, sizeof(vis));
120 
121     // 队列容器来装载结点
122 
123    queue<node>q;
124 
125    node cur,tmp;
126 
127     // 初始结点进入队列
128 
129    q.push(st);
130 
131    vis[st.stat]= 1;
132 
133     // 如果队列非空，那么就一直重复这个过程
134 
135     while(!q.empty())
136 
137    {
138 
139       // 将首结点取出作为当前结点
140 
141      cur=q.front();
142 
143       // 将队列剥离一个
144 
145      q.pop();
146 
147       // 得到空白方块的横坐标和纵坐标
148 
149       int x=cur.loc/ 3,y=cur.loc% 3;
150 
151       for( int i= 0;i< 4;i++)
152 
153      {
154 
155         // 从四个方向对空白位置进行搜索
156 
157         int tx=x+dir[i][ 0],ty=y+dir[i][ 1];
158 
159         // 如果越界的话，换一个方向
160 
161         if(!isok(tx,ty))
162 
163           continue;
164 
165        tmp=cur;
166 
167        tmp.loc=tx* 3+ty; // '0'移动到该位置
168 
169          // 这里，相当于交换了一个方向
170 
171        tmp.s[cur.loc]=tmp.s[tmp.loc];
172 
173        tmp.s[tmp.loc]= 0;
174 
175         // 获取这个状态的hash值
176 
177        tmp.stat=cantor(tmp.s);
178 
179         // 如果这个状态没有被遍历过的话
180 
181         if(!vis[tmp.stat])
182 
183        {
184 
185          vis[tmp.stat]= 1;
186 
187           // 修改路径，字符串可以直接在后面加
188 
189          tmp.path=cur.path+index[i];
190 
191           // 如果是正解的话
192 
193           if(tmp.stat==aim)
194 
195          {
196 
197            path=tmp.path;
198 
199             return  true;
200 
201          }
202 
203           // 如果不是最优解的话，继续入队列
204 
205          q.push(tmp);
206 
207        }
208 
209      }
210 
211    }
212 
213     return  0;
214 
215  }
216 
217  
218 
219   int main()
220 
221  {
222 
223     // 假设操作的总次数不大于256
224 
225     char buf[ 256];
226 
227     // 利用gets()函数读入一行
228 
229     while(gets(buf))
230 
231    {
232 
233       int len=strlen(buf);
234 
235       int cnt= 0;
236 
237       for( int i= 0;i<len;i++)
238 
239      {
240 
241         if(buf[i]>= ' 1 '&&buf[i]<= ' 9 ')
242 
243        {
244 
245          st.s[cnt++]=buf[i]- ' 0 ';
246 
247        }
248 
249         else  if(buf[i]== ' x ')
250 
251        {
252 
253          st.s[cnt]= 0;
254 
255           // 这里标识空白区域的具体位置
256 
257          st.loc=cnt++;
258 
259        }
260 
261      }
262 
263       // 利用cantor扩展函数得到初始状态
264 
265      st.stat=cantor(st.s);
266 
267       // 如果一开始就是目标状态的话，那么就输出空气好咯！
268 
269       if(st.stat==aim)
270 
271      {
272 
273        puts( "");
274 
275         continue;
276 
277      }
278 
279       // 广搜开始
280 
281       if(bfs())
282 
283         // 输出路径
284 
285        cout<<path<<endl;
286 
287       else
288 
289         // 输出不可解
290 
291        puts( " unsolvable ");
292 
293    }
294 
295     return  0;
296 
297  }