用深搜写的，对于每一个黑格子，分四个方向深搜，因为有四种情况，标记数组也就有了四种状态，即记录起点从哪个方向开始出发的（这个还有记录拐弯次数均为借鉴得来，不过好歹是又学会了新的处理方式）。

最近一直在复习准备补考，表示脑残手残的buff又开始肆虐了，写一个搜索竟然让我样例都过不去好几次。。

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 int map[55][55], n, m;
 9 char s[55][55];
10 const int d[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
11 bool inMap(int x, int y){
12     return x >= 0 && x < n && y >= 0 && y < m;
13 }
14 void dfs(int x, int y, int dir, int chg, int state){
15     map[x][y] = state;
16     for (int i = 0; i < 4; i++){
17         int xx = x + d[i][0];
18         int yy = y + d[i][1];
19         if (!inMap(xx, yy) || s[xx][yy] == 'W' || map[xx][yy] == state) continue;
20         if (i != dir && chg == 0) dfs(xx, yy, i, chg + 1, state);
21         else if (i == dir) dfs(xx, yy, i, chg, state);
22     }
23 }
24 int main(){
25     cin >> n >> m;
26     for (int i = 0; i < n; i++) cin >> s[i];
27     for (int i = 0; i < n; i++)
28       for (int j = 0; j < m; j++){
29           if (s[i][j] == 'B'){
30               memset(map, 0, sizeof(map));
31               for (int k = 0; k < 4; k++) dfs(i, j, k, 0, k + 1);
32               for (int k = 0; k < n; k++)
33                 for (int l = 0; l < m; l++)
34                   if (s[k][l] == 'B' && map[k][l] == 0){
35                       cout << "NO" << endl;
36                       return 0;
37                   }
38           }
39       }
40     cout << "YES" << endl;
41     return 0;
42 

真是不知道怎么回事儿，昨天晚上我写了一晚上没AC，今天重写了一遍就果断AC了。

这道题是使一个应该说是拐了一点儿弯儿的dfs，就是当且仅当遇到障碍的时候停止，剩下的时间全都一直在走，而且需要判断的是下一步是否是障碍，而不是当前所在位置是否是障碍，而且，需要维护的是障碍会消失，所以需要用dfs来维持地图的环境，搜索是逐点搜索的，就是用一个循环把不该停的地方跳过去就行了。。

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 int w, h, map[25][25], sx, sy, ans;
 9 bool ju;
10 const int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
11 bool inMap(int x, int y)
12 {
13     return x >= 0 && x < h && y >= 0 && y < w;
14 }
15 void init()
16 {
17     for (int i = 0; i < h; i++)
18       for (int j = 0; j < w; j++)
19         if (map[i][j] == 2) {sx = i; sy = j;}
20     ans = (1 << 31) - 1; ju = 0;
21 }
22 void dfs(int x, int y, int step)
23 {
24     if (step > 10) return;
25     for (int i = 0; i < 4; i++)
26     {
27         if (map[x + dir[i][0]][y + dir[i][1]] == 1 || !inMap(x + dir[i][0], y + dir[i][1])) continue;
28         int xx = x, yy = y;
29         while (map[xx + dir[i][0]][yy + dir[i][1]] != 1)
30         {
31             xx += dir[i][0]; yy += dir[i][1];
32             if (!inMap(xx, yy)) break;
33             if (map[xx][yy] == 3)
34             {
35                 ans = min(step, ans);
36                 ju = 1;
37                 return;
38             }
39         }
40         if (inMap(xx, yy))
41         {
42             map[xx + dir[i][0]][yy + dir[i][1]] = 0;
43             dfs(xx, yy, step + 1);
44             map[xx + dir[i][0]][yy + dir[i][1]] = 1;
45         }
46     }
47 }
48 int main()
49 {
50     while (~scanf("%d%d", &w, &h))
51     {
52         if (!w && !h) break;
53         memset(map, 0, sizeof(map));
54         for (int i = 0; i < h; i++)
55           for (int j = 0; j < w; j++) scanf("%d", &map[i][j]);
56         init();
57         dfs(sx, sy, 1);
58         if (ju) printf("%d\n", ans);
59         else printf("-1\n");
60     }
61     return 0;
62 }
63 

智商不够了擦……我写的是逐点搜索，果断写屎了……逐行搜索过了。。。不行……逐点搜索我明天要再写一写……

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 int G[10][10], n, m, ans, f[10];
 9 char s[10][10];
10 void init()
11 {
12     for (int i = 0; i < n; i++)
13       for (int j = 0; j < n; j++)
14         if (s[i][j] == '#') G[i][j] = 1;
15         else G[i][j] = 0;
16 }
17 void dfs(int dep, int k)
18 {
19     if (k == m)
20     {
21         ans++; return;
22     }
23     if (dep > n) return;
24     for (int j = 0; j < n; j++)
25     {
26         if (G[dep][j] && !f[j])
27         {
28             f[j] = 1;
29             dfs(dep + 1, k + 1);
30             f[j] = 0;
31         }
32     }
33     dfs(dep + 1, k);
34     return;
35 }
36 int main()
37 {
38     while (~scanf("%d%d", &n, &m))
39     {
40         if (n == -1 && m == -1) break;
41         memset(f, 0, sizeof(f));
42         for (int i = 0; i < n; i++) scanf("%s", s[i]);
43         init();
44         ans = 0;
45         dfs(0, 0);
46         printf("%d\n", ans);
47     }
48     return 0;
49 }
50 

这段时间我貌似在找回我高中的遗憾啊……做搜索。。。

闲扯完毕，喜闻乐见的骑士遍历，已经见过很多次了，但是经常是没有做就拉倒了，最近被虐的本着臭不要脸的精神，接着虐……分八个方向深搜，搜着搜着就出来了，一边搜一边把那个那个路径记录下来，最后打印出来就行了（我竟然还想用string偷懒，但是明显不可行啊……sigh，真是没智商了，深搜都不会了……）

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 int f[30][30], ans[30][2], n, m;
 9 bool g;
10 const int dir[8][2] = {{-2, -1}, {-2, 1}, {-1, -2}, {-1, 2}, {1, -2}, {1, 2}, {2, -1}, {2, 1}};
11 bool inMap(int x, int y)
12 {
13     return x >= 0 && x < m && y >= 0 && y < n;
14 }
15 void dfs(int x, int y, int k)
16 {
17     if (k == n * m)
18     {
19         for (int i = 0; i < k; i++)
20           printf("%c%d", ans[i][0] + 65, ans[i][1] + 1);
21         printf("\n");
22         g = 1;
23         return;
24     }
25     for (int i = 0; i < 8; i++)
26     {
27         int xx = x + dir[i][0];
28         int yy = y + dir[i][1];
29         if (inMap(xx, yy) && !f[xx][yy] && !g)
30         {
31             f[xx][yy] = 1;
32             ans[k][0] = xx; ans[k][1] = yy;
33             dfs(xx, yy, k + 1);
34             f[xx][yy] = 0;
35         }
36     }
37 }
38 int main()
39 {
40     int t;
41     while (~scanf("%d", &t))
42     {
43         for (int i = 1; i <= t; i++)
44         {
45             memset(f, 0, sizeof(f));
46             memset(ans, 0, sizeof(ans));
47             g = 0;
48             scanf("%d%d", &n, &m);
49             f[0][0] = 1;
50             ans[0][0] = ans[0][1] = 0;
51             printf("Scenario #%d:\n", i);
52             dfs(0, 0, 1);
53             if (!g) printf("impossible\n");
54             printf("\n");
55         }
56     }
57     return 0;
58 }
59 

分四个方向dfs，最后找到最大值。

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define maxl 10000
 9 int n, m, k, num, G[110][110], f[110][110];
10 int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
11 int dfs(int p, int q)
12 {
13     f[p][q] = 1;
14     for (int i = 0; i < 4; i++)
15     {
16         int x = p + dir[i][0];
17         int y = q + dir[i][1];
18         if (!f[x][y] && G[x][y])
19         {
20             num++;
21             dfs(x, y);
22         }
23     }
24     return num;
25 }
26 int main()
27 {
28     while (~scanf("%d%d%d", &n, &m, &k))
29     {
30         int ans = 0;
31         memset(f, 0, sizeof(f));
32         memset(G, 0, sizeof(G));
33         while (k--)
34         {
35             int x, y;
36             scanf("%d%d", &x, &y);
37             G[x][y] = 1;
38         }
39         for (int i = 1; i <= n; i++)
40           for (int j = 1; j <= m; j++)
41           {
42               if (!f[i][j] && G[i][j])
43               {
44                   num = 1;
45                   ans = max(ans, dfs(i, j));
46               }
47           }
48         printf("%d\n", ans);
49     }
50     return 0;
51