问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1077思路:
传说中经典的经典
解法有: 单向BFS，双向BFS，还有A*等启发式搜索算法
今天先写了前两种方法的代码，至于启发式算法待续
判重: 全排列的哈希，详见:
http://www.cppblog.com/Joe/archive/2010/08/06/122410.html代码(单向BFS，110MS):
1 #define RC 3
2 #define STR_LEN 9
3 #define HASH_LEN 362880 /* 9! */
4 const int facs[] = {1, 2, 6, 24, 120, 720, 5040, 40320};
5 const char letters[] = "udlr";
6 const int dx[] = {-1, 1, 0, 0};
7 const int dy[] = {0, 0, -1, 1};
8 char success[] = "123456780";
9 char begin[STR_LEN+1];
10 int success_hash, begin_position;
11 int hash[HASH_LEN];
12 struct EACH {
13 char str[STR_LEN+1];
14 int position;
15 int pre;
16 int dir;
17 } queue[HASH_LEN];
18
19 /* permutation -> number */
20 int
21 hash_func(char *str)
22 {
23 int i, j, cnt, result = 0;
24 for(i=1; i<STR_LEN; i++) {
25 cnt = 0;
26 for(j=0; j<i; j++)
27 if(str[j] > str[i])
28 ++cnt;
29 result += (cnt*facs[i-1]);
30 }
31 return result;
32 }
33
34 void
35 init()
36 {
37 int i;
38 char input[2];
39 memset(hash, 0, sizeof(hash));
40 for(i=0; i<STR_LEN; i++) {
41 scanf("%s", input);
42 begin[i] = input[0];
43 if(begin[i] == 'x') {
44 begin[i] = '0';
45 begin_position = i;
46 }
47 }
48 begin[STR_LEN] = '\0';
49 success_hash = hash_func(success);
50 }
51
52 void
53 output(int index)
54 {
55 if(queue[index].pre == -1)
56 return;
57 output(queue[index].pre);
58 printf("%c", letters[queue[index].dir]);
59 }
60
61 #define ADD(tail, s, pos, p, d) strcpy(queue[tail].str, s); \
62 queue[tail].position = pos; \
63 queue[tail].pre = p; \
64 queue[tail].dir = d;
65
66 #define CHECK(h) if(h == success_hash) { \
67 output(tail); \
68 printf("\n"); \
69 return; \
70 }
71
72 void
73 bfs()
74 {
75 int i, h, head, tail;
76 char nxt[STR_LEN+1];
77 int curx, cury, nxtx, nxty;
78 head = -1;
79 tail = 0;
80 ADD(tail, begin, begin_position, -1, -1);
81 h = hash_func(begin);
82 hash[h] = 1;
83 CHECK(h);
84 while(head < tail) {
85 ++head;
86 curx = queue[head].position/RC;
87 cury = queue[head].position%RC;
88 for(i=0; i<4; i++) {
89 nxtx = curx + dx[i];
90 nxty = cury + dy[i];
91 if(nxtx>=0 && nxtx<RC && nxty>=0 && nxty<RC) {
92 strcpy(nxt, queue[head].str);
93 nxt[queue[head].position] = nxt[nxtx*RC+nxty];
94 nxt[nxtx*RC+nxty] = '0';
95 h = hash_func(nxt);
96 if(!hash[h]) {
97 ++tail;
98 ADD(tail, nxt, nxtx*RC+nxty, head, i);
99 hash[h] = 1;
100 CHECK(h);
101 }
102 }
103 }
104 }
105 printf("unsolvable\n");
106 }
代码(双向BFS，16MS):
1 #define RC 3
2 #define STR_LEN 9
3 #define HASH_LEN 362880 /* 9! */
4 const int facs[] = {1, 2, 6, 24, 120, 720, 5040, 40320};
5 const char letters[] = "udlr";
6 const int pos[] = {-3, 3, -1, 1}; /* up, down, left, right */
7 const int movable[][4] = {0,1,0,1, 0,1,1,1, 0,1,1,0, 1,1,0,1, 1,1,1,1, 1,1,1,0, 1,0,0,1, 1,0,1,1, 1,0,1,0};
8 int hash[2][HASH_LEN];
9 struct EACH {
10 char str[STR_LEN+1];
11 int position, pre, dir, hval;
12 } queue[2][HASH_LEN];
13
14 /* permutation -> number */
15 int
16 hash_func(char *str)
17 {
18 int i, j, cnt, result = 0;
19 for(i=1; i<STR_LEN; i++) {
20 cnt = 0;
21 for(j=0; j<i; j++)
22 if(str[j] > str[i])
23 ++cnt;
24 result += (cnt*facs[i-1]);
25 }
26 return result;
27 }
28
29 void
30 output(int hash_value)
31 {
32 int i, j;
33 char tmp[250];
34 for(i=0; i<HASH_LEN; i++)
35 if(queue[0][i].hval == hash_value)
36 break;
37 j = 0;
38 while(queue[0][i].pre != -1) {
39 tmp[j++] = letters[queue[0][i].dir];
40 i = queue[0][i].pre;
41 }
42 for(i=j-1; i>=0; i--)
43 printf("%c", tmp[i]);
44
45 for(i=0; i<HASH_LEN; i++)
46 if(queue[1][i].hval == hash_value)
47 break;
48 while(queue[1][i].pre != -1) {
49 printf("%c", queue[1][i].dir%2==0 ? letters[queue[1][i].dir+1] : letters[queue[1][i].dir-1]);
50 i = queue[1][i].pre;
51 }
52 }
53
54 #define ADD(index, tail, s, pos, p, d, h) strcpy(queue[index][tail].str, s); \
55 queue[index][tail].position = pos; \
56 queue[index][tail].pre = p; \
57 queue[index][tail].dir = d; \
58 queue[index][tail].hval = h;
59
60 int
61 bfs(char *start_str, int start_pos)
62 {
63 int i, index, h, curp, nxtp, head[2], tail[2];
64 char suc[] = "123456780";
65 char nxt[STR_LEN+1];
66 head[0] = head[1] = -1;
67 tail[0] = tail[1] = 0;
68 h = hash_func(start_str);
69 hash[0][h] = 1;
70 ADD(0, tail[0], start_str, start_pos, -1, -1, h);
71 h = hash_func(suc);
72 hash[1][h] = 1;
73 ADD(1, tail[1], suc, 8, -1, -1, h);
74 while(head[0]<tail[0] && head[1]<tail[1]) {
75 for(index=0; index<2; index++) {
76 ++head[index];
77 curp = queue[index][head[index]].position;
78 for(i=0; i<4; i++) {
79 if(movable[curp][i]) {
80 nxtp = curp + pos[i];
81 strcpy(nxt, queue[index][head[index]].str);
82 nxt[curp] = nxt[nxtp];
83 nxt[nxtp] = '0';
84 h = hash_func(nxt);
85 if(!hash[index][h]) {
86 ++tail[index];
87 ADD(index, tail[index], nxt, nxtp, head[index], i, h);
88 hash[index][h] = 1;
89 }
90 if(hash[1-index][h])
91 return h;
92 }
93 }
94 }
95 }
96 return -1;
97 }
98
99 int
100 main(int argc, char **argv)
101 {
102 int i, sp, h;
103 char input[2], num[STR_LEN+1];
104 for(i=0; i<STR_LEN; i++) {
105 scanf("%s", input);
106 num[i] = input[0];
107 if(num[i]=='x') {
108 num[i] = '0';
109 sp = i;
110 }
111 }
112 num[STR_LEN] = '\0';
113 h = bfs(num, sp);
114 if(h==-1)
115 printf("unsolvable\n");
116 else {
117 output(h);
118 printf("\n");
119 }
120 return 0;
121 }