hdu1195 Open the Lock 双向BFS

1. 看http://blog.csdn.net/liuqiyao_01/article/details/8892261终于看懂双向BFS的具体做法了。
2. 准备两个队列，分别放出发点和终点。
3. 之后while（）
4. {
5.    BFS（0）
6.    BFS（1）
7.  //分别代表两个点出发遍历。
8. }
9. 对于每一个bfs，首先看看是否上一个bfs已经找到答案了，如果找到了，这个就不需要遍历了。
10. 之后就开始遍历，我们一般的就是while(!que.empty()),但是这个我们需要再加一个判定条件，因为双重遍历，如果不加，我们就
11. 一次性直接把某一个BFS遍历完了，根本不需要第二个遍历了。我们需要一层一层遍历，对于当前BFS我们只遍历一层，之后让另外一个
12. BFS进行遍历。所以说当前BFS，我们先取出一个来，q1。我们知道q1的步数是firststep，我们本次就之便利step次数的。也就是
13. while(!que.empty()&&que.front().step==firststep)。我们只遍历这一层。
14. 如果对于当前front的状态，另一个BFS已经到达了，也就是另一个的BFS的vis记录已经访问了，这代表我们两个出发点成功搭线了，
15. 直接输出即可。这里我们用vis1，2分别记录两个BFS到达某个状态的步数。那么就是两个vis相加输出即可。
16. 
    
17. 
    
18. #include <iostream>  
19. #include <cstdio>  
20. #include <queue>  
21. #include <cstring>  
22. using namespace std;  
23.   
24. struct node  
25. {  
26.     int num[4];  
27.     int step;  
28. };  
29. queue<node> q[2];  
30. int vis[2][10][10][10][10];  
31. int ansnum[4];  
32. int ans;  
33.   
34. void init()  
35. {  
36.     ans = -1;  
37.     memset(vis, -1, sizeof(vis));  
38.     while (!q[0].empty()) q[0].pop();  
39.     while (!q[1].empty()) q[1].pop();  
40. }  
41.   
42. bool istrue(node x, int i)  
43. {  
44.     if (vis[1^i][x.num[0]][x.num[1]][x.num[2]][x.num[3]] != -1)  
45.         return true;  
46.     return false;  
47. }  
48.   
49. bool judge(node x, int i)  
50. {  
51.     if (vis[i][x.num[0]][x.num[1]][x.num[2]][x.num[3]] != -1) return false;  
52.     return true;  
53. }  
54.   
55. node change(node a, int b)  
56. {  
57.     a.step ++;  
58.   
59.     if (b < 4)       // +  
60.     {  
61.         if (a.num[b] == 9) a.num[b] = 1;  
62.         else a.num[b] ++;  
63.     }  
64.     else if (b < 8)  // -  
65.     {  
66.         if (a.num[b%4] == 1) a.num[b%4] = 9;  
67.         else a.num[b%4] = a.num[b%4] - 1;  
68.     }  
69.     else    // 换  
70.     {  
71.         int tmp;  
72.         b %= 4;  
73.         tmp = a.num[b];  
74.         a.num[b] = a.num[b+1];  
75.         a.num[b+1] = tmp;  
76.     }  
77.   
78.     return a;  
79. }  
80.   
81. void bfs(int j)  
82. {  
83.     node now, next;  
84.     if (ans != -1 || q[j].empty()) return ;  
85.     int first = q[j].front().step;  
86.     while (!q[j].empty() && q[j].front().step == first)  
87.     {  
88.         now = q[j].front();  
89.         q[j].pop();  
90.   
91.         if (istrue(now, j))  
92.         {  
93.             ans = vis[j][now.num[0]][now.num[1]][now.num[2]][now.num[3]] + vis[1^j][now.num[0]][now.num[1]][now.num[2]][now.num[3]];  
94.             return ;  
95.         }  
96.   
97.         for (int i = 0; i < 11; i++)  
98.         {  
99.             next = change(now, i);  
100.             if (judge(next, j))  
101.             {  
102.                 vis[j][next.num[0]][next.num[1]][next.num[2]][next.num[3]] = next.step;  
103.                 q[j].push(next);  
104.             }  
105.         }  
106.     }  
107. }  
108.   
109. void db_bfs()  
110. {  
111.     while (ans == -1)  
112.     {  
113.         bfs(0);  
114.         bfs(1);  
115.     }  
116. }  
117.   
118. int main()  
119. {  
120.     int T;  
121.     scanf("%d", &T);  
122.     while (T--)  
123.     {  
124.         init();  
125.         int a, b;  
126.         node now0, now1;  
127.         scanf("%d %d", &a, &b);  
128.   
129.         for (int i=3; i>=0; i--)  
130.         {  
131.             now0.num[i] = a % 10;  
132.             now1.num[i] = b % 10;  
133.             a /= 10;  
134.             b /= 10;  
135.         }  
136.         now0.step = 0;  
137.         q[0].push(now0);  
138.         vis[0][now0.num[0]][now0.num[1]][now0.num[2]][now0.num[3]] = 0;  
139.         now1.step = 0;  
140.         q[1].push(now1);  
141.         vis[1][now1.num[0]][now1.num[1]][now1.num[2]][now1.num[3]] = 0;  
142.   
143.         db_bfs();  
144.   
145.         printf("%d\n", ans);  
146.     }  
147.     return 0;  
148. }