早上看了提到双向广搜的一篇文章，其中讲了双向广搜可以节约一半的时间和一半的空间（理论上），我画了一幅图：

（上面的对应普通BFS，下面的对应双向广搜）

可以看出简单BFS的搜索节点大约是双向广搜的二倍。

对于八数码问题，由于逆序剪枝可以将所有无解的状态全部剪掉，剩余的都是有解的状态，所以使用双向广搜速度可能会更快；

对下面两组数据（分别输入）

1 2 3 4 5 6 7 8 0
8 7 6 5 4 3 2 1 0

2 6 4 1 3 7 0 5 8
8 1 5 7 3 6 4 0 2

正确输出对应是 30、 31

使用BFS的运行时间：0.390s  0.359s

使用双广的运行时间：0.109s 0.046s

双广我开始想按自己的思路来写，定义的是两个队列，两个vis[]，两个dist[]，最后发现根本运行不了（后来写后面的时才发现是将几个大的数组定义在了局部引起的），睡了一觉，看了这篇Poj 1915 – Knight Moves 双向广搜（Maxwell.O.Y），才对双广的结构有了新的理解；

  1 # include <stdio.h>
  2 # include <mem.h>
  3 
  4 # define MAXN (362880 + 5)
  5 
  6 typedef struct 
  7 {
  8     char a[9];
  9 }state;
 10 
 11 const int dir[4][2] = {{-1,0}, {0,1}, {1,0}, {0,-1}};
 12 int fact[9];
 13 
 14 int front, rear;
 15 state cur, nst;            /* new state */
 16 char vis[MAXN];
 17 char dist[MAXN];        /* 求的是最短距离( < 100)，可以用 char 类型 */
 18 state Q[MAXN/2];
 19 
 20 
 21 void read(state *s);
 22 int inversions(state s);
 23 int cantor(state s);
 24 void init_fact(void);
 25 int bfs_d(state start, state goal);
 26 
 27 int main()
 28 {
 29     state start, goal;
 30     
 31     freopen("in.txt", "r", stdin);
 32     freopen("out.txt", "w", stdout);
 33     
 34     init_fact();
 35 
 36     read(&start);
 37     read(&goal);
 38 
 39     if (inversions(start)%2 == inversions(goal)%2)
 40     {
 41         printf("%d\n", bfs_d(start, goal));
 42     }
 43     else puts("-1");
 44 
 45     return 0;
 46 }
 47 
 48 int bfs_d(state start, state goal)
 49 {
 50     int i, x, y, nx, ny, ct, nt;
 51 
 52     memset(vis, 0, sizeof(vis));
 53     memset(dist, 0, sizeof(dist));
 54 
 55     front = 1;
 56     Q[front] = start;
 57     rear = 2;
 58     Q[rear++] = goal;
 59     vis[cantor(start)] = 1;                /* 1 表示从起始节点扩展得到 */
 60     vis[cantor(goal)] = 2;                /* 2 表示从目标节点扩展得到 */
 61 
 62     while (front < rear)
 63     {
 64         cur = Q[front++];
 65         ct = cantor(cur);
 66         for (i = 0; cur.a[i] && i < 9; ++i) ;
 67         x = i / 3;
 68         y = i % 3;
 69         for (i = 0; i < 4; ++i)
 70         {
 71             nx = x + dir[i][0];
 72             ny = y + dir[i][1];
 73             if (nx>=0 && nx<3 && ny>=0 && ny<3)
 74             {
 75                 nst = cur;
 76                 nst.a[x*3+y] = cur.a[nx*3+ny];
 77                 nst.a[nx*3+ny] = 0;
 78                 if (!vis[nt = cantor(nst)])
 79                 {
 80                     Q[rear++] = nst;
 81                     /* foot[nt] = ct; */
 82                     dist[nt] = dist[ct] + 1;
 83                     vis[nt] = vis[ct];
 84                 }
 85                 else if (vis[ct] != vis[nt])
 86                 {
 87                     return 1 + dist[nt] + dist[ct];
 88                 }
 89             }
 90         }
 91     }
 92 
 93     return -1;
 94 }
 95 
 96 void read(state *s)
 97 {
 98     int i;
 99     char c[5];
100 
101     for (i = 0; i < 9; ++i)
102     {
103         scanf("%s", c);
104         if (c[0] == 'x') (*s).a[i] = 0;
105         else (*s).a[i] = c[0] - '0';
106     }
107 }
108 
109 int inversions(state s)
110 {
111     char ch;
112     int i, j, ret;
113 
114     ret = 0;
115     for (i = 0; i < 9; ++i)
116     {
117         if (s.a[i] == 0) continue;
118         ch = s.a[i];
119         for (j = i+1; j < 9; ++j)
120         {
121             if (s.a[j] < ch && s.a[j] != 0)
122                 ++ret;
123         }
124     }
125 
126     return ret;
127 }
128 
129 int cantor(state s)
130 {
131     char ch;
132     int i, j, ret, cnt;
133 
134     ret = 0;
135     for (i = 0; i < 9; ++i)
136     {
137         cnt = 0;
138         ch = s.a[i];
139         for (j = i+1; j < 9; ++j)
140         {
141             if (s.a[j] < ch)
142                 ++cnt;
143         }
144         ret += cnt*fact[8-i];
145     }
146 
147     return ret;
148 }
149 
150 void init_fact(void)
151 {
152     int i;
153 
154     fact[0] = 1;
155     for (i = 1; i < 9; ++i)
156     {
157         fact[i] = i * fact[i-1];
158     }
159 }

用到的主要有：逆序剪枝，康托展开，双向广搜（……第四层）。

********************************************

刚吃饭想到了一种比较不正常的提速方法，也是看了郭大侠的博客才考试考虑提速的：假设最短距离的最大值是31，相应扩展的节点为N的话，根据BFS的特点完全可以将队列缩小很多！试了试果然提速了不少：（对应上面的例子）15ms 31ms；

郭大侠提出了一种构造法（非最优解）可以在有限的步数内按照一定的规则构造出一个解，对于大多数输入，速度要比搜索要快一些。