HDU 1728 逃离迷宫 （bfs）

　　给定一个m × n (m行, n列)的迷宫，迷宫中有两个位置，gloria想从迷宫的一个位置走到另外一个位置，当然迷宫中有些地方是空地，gloria可以穿越，有些地方是障碍，她必须绕行，从迷宫的一个位置，只能走到与它相邻的4个位置中,当然在行走过程中，gloria不能走到迷宫外面去。令人头痛的是，gloria是个没什么方向感的人，因此，她在行走过程中，不能转太多弯了，否则她会晕倒的。我们假定给定的两个位置都是空地，初始时，gloria所面向的方向未定，她可以选择4个方向的任何一个出发，而不算成一次转弯。gloria能从一个位置走到另外一个位置吗？

Input　　第1行为一个整数t (1 ≤ t ≤ 100),表示测试数据的个数，接下来为t组测试数据，每组测试数据中， 
　　第1行为两个整数m, n (1 ≤ m, n ≤ 100),分别表示迷宫的行数和列数，接下来m行，每行包括n个字符，其中字符'.'表示该位置为空地，字符'*'表示该位置为障碍，输入数据中只有这两种字符，每组测试数据的最后一行为5个整数k, x  ₁ , y  ₁ , x  ₂ , y  ₂  (1 ≤ k ≤ 10, 1 ≤ x ₁ , x  ₂  ≤ n, 1 ≤ y  ₁ , y  ₂  ≤ m),其中k表示gloria最多能转的弯数，(x  ₁ , y  ₁ ), (x  ₂ , y ₂ )表示两个位置，其中x  ₁ ，x  ₂ 对应列，y  ₁ , y  ₂ 对应行。 
Output　　每组测试数据对应为一行，若gloria能从一个位置走到另外一个位置，输出“yes”，否则输出“no”。Sample Input

2
5 5
...**
*.**.
.....
.....
*....
1 1 1 1 3
5 5
...**
*.**.
.....
.....
*....
2 1 1 1 3

Sample Output

no
yes

走迷宫的题一下就想到是搜索来做，但是这个题用bfs来做的时候，只要当前方向能走，就先一直走到头，并把经过的点加到队列中，让我对bfs有了新的理解。要注意的是，题目输入的x1,x2是代表列的，所以读的时候x和y颠倒一下。

当时做的时候把数据读入顺序写错了，以为k是最后一个，wa了无数发，哭死。

 下面放代码吧：

[cpp]  view plain  copy

1. #include <bits/stdc++.h>  
2. #include <cstring>  
3. using namespace std;  
4. char mp[1005][1005];  
5. struct node  
6. {  
7.     int x,y;  
8.     int tms;  
9. };  
10. int to[4][2]={{0,1},{1,0},{0,-1},{-1,0}};  
11. int vis[1005][1005];  
12.   
13. int main()  
14. {  
15.     int T,n,m;  
16.     int X1,Y1,X2,Y2,k;  
17.     scanf("%d",&T);  
18.     while(T--)  
19.     {  
20.         memset(vis,0,sizeof(vis));  
21.         int flag=0;  
22.         scanf("%d%d",&n,&m);  
23.         for(int i=0;i<n;i++)  
24.         {  
25.             scanf("%s",mp[i]);  
26.         }  
27.         scanf("%d%d%d%d%d",&k,&Y1,&X1,&Y2,&X2);  
28.         if(X1==X2&&Y1==Y2)  
29.         {  
30.             cout<<"yes"<<endl;  
31.             continue;  
32.         }  
33.         X1--;X2--;Y1--;Y2--;  
34.         vis[X1][Y1]=1;  
35.         queue <node> que;  
36.         node ss;  
37.         ss.x=X1;  
38.         ss.y=Y1;  
39.         ss.tms=-1;  
40.         que.push(ss);  
41.         while(!que.empty())  
42.         {  
43.             node temp=que.front();  
44.             que.pop();  
45.             for(int i=0;i<4;i++)  
46.             {  
47.                 node nw;  
48.                 nw=temp;  
49.                 nw.x+=to[i][0];  
50.                 nw.y+=to[i][1];  
51.                 while(nw.x>=0&&nw.x<n&&nw.y>=0&&nw.y<m&&mp[nw.x][nw.y]=='.')  
52.                 {  
53.                     if(vis[nw.x][nw.y]==0)  
54.                     {  
55.                         vis[nw.x][nw.y]=1;  
56.                         nw.tms=temp.tms+1;  
57.                         if(nw.x==X2&&nw.y==Y2&&nw.tms<=k)  
58.                         {  
59.                             flag=1;  
60.                             break;  
61.                         }  
62.                         que.push(nw);  
63.                     }  
64.                     nw.x+=to[i][0];  
65.                     nw.y+=to[i][1];  
66.                 }  
67.                 if(flag)  
68.                     break;  
69.             }  
70.             if(flag)  
71.                 break;  
72.         }  
73.         if(flag)  
74.             cout<<"yes"<<endl;  
75.         else  
76.             cout<<"no"<<endl;  
77.     }  
78.     return 0;  
79. }