SDUT OJ 1124 飞越原野 （三维BFS练习）

飞跃原野

Time Limit: 5000ms   Memory limit: 65536K  有疑问？点这里^_^

题目描述

勇敢的法里奥出色的完成了任务之后，正在迅速地向自己的基地撤退。但由于后面有着一大群追兵，所以法里奥要尽快地返回基地，否则就会被敌人逮住。

终于，法里奥来到了最后的一站:泰拉希尔原野，穿过这里就可以回到基地了。然而，敌人依然紧追不舍。不过，泰拉希尔的地理条件对法里奥十分有利，众多的湖泊随处分布。敌人需要绕道而行，但法里奥还是决定找一条能尽快回到基地的路。
 
假设泰拉希尔原野是一个m*n的矩阵，它有两种地形，P表示平，L表示湖泊，法里奥只能停留在平地上。他目前的位置在左上角（1，1）处，而目的地为右下角的（m，n）。法里奥可以向前后左右4个方向移动或飞行，每移动1格需要1单位时间。而飞行的时间主要花费在变形上，飞行本身时间消耗很短，所以无论一次飞行多远的距离，都只需要1单位时间。飞行的途中不能变向，并且一次飞行最终必须要降落到平地上。当然，由于受到能量的限制，法里奥不能无限制飞行，他总共最多可以飞行的距离为D。在知道了以上的信息之后，请你帮助法里奥计算一下，他最快到达基地所需要的时间。

输入

第一行是3个整数，m（1≤m≤100），n（1≤n≤100），D（1≤D≤100）。表示原野是m*n的矩阵，法里奥最多只能飞行距离为D。接下来的m行每行有n个字符，相互之间没有空格。P表示当前位置是平地，L则表示湖泊。假定（1，1）和（m，n）一定是平地。

输出

一个整数，表示法里奥到达基地需要的最短时间。如果无法到达基地，则输出impossible。

示例输入

4 4 2
PLLP
PPLP
PPPP
PLLP

示例输出

5

简单的三维BFS

手残，WA了好几次，就是没发现t.d 写成 f.d

还有 题意理解错了，跪了一会，不一定非是湖泊才能飞，平原也可以飞

[html]  view plain copy

1. /*  
2. 简单的三维BFS  
3. 手残，WA了好几次，就是没发现t.d 写成 f.d  
4. 还有 题意理解错了，跪了一会，不一定非是湖泊才能飞，平原也可以飞*/  
5. #include <iostream>  
6. #include <cstdio>  
7. #include <cstring>  
8. #include <cstdlib>  
9. #include <queue>  
10. const int  N  = 200;  
11. using namespace std;  
12. int mapp[N][N];  
13. bool vis[N][N][N];  
14. int n,m,D;  
15. int mv[4][2] = {{1,0},{0,-1},{0,1},{-1,0}};  
16. struct node  
17. {  
18.     int x,y,ans,d;  
19. };  
20. int st(int x,int y)  
21. {  
22.     return x*y;  
23. }  
24. int BFS(int D)  
25. {  
26.     node f,t;  
27.     queue<node>q;  
28.     memset(vis,0,sizeof(vis));  
29.     f.x = 0; f.y = 0; f.ans = 0; f.d = D;  
30.     q.push(f);  
31.     vis[f.x][f.y][f.d] = true;  
32.     while(!q.empty())  
33.     {  
34.         t = q.front();  
35.   
36.         if(t.x==n-1 && t.y==m-1)  
37.             return t.ans;  
38.           
39.         q.pop();  
40.         for(int i = 0;i < 4;i++) //走路  
41.         {  
42.             f.x = t.x + mv[i][0];  
43.             f.y = t.y + mv[i][1];  
44.             if(0 <= f.x && f.x<n && 0<=f.y && f.y<m &&!vis[f.x][f.y][t.d] && mapp[t.x][t.y]==0&&mapp[f.x][f.y]==0)  
45.             {                                                     // ↑这写错了  
46.                 f.ans = t.ans + 1;  
47.                 f.d = t.d;  
48.                 vis[f.x][f.y][f.d] = true;  
49.                 q.push(f);  
50.             }  
51.         }  
52.             for(int i=0; i<4; i++) //飞  
53.             {  
54.                 for(int num=t.d; num>=1;num--)//找当前最优路线，尽可能的飞的最远  
55.               {  
56.                 f.x = t.x + st(mv[i][0],num);  
57.                 f.y = t.y + st(mv[i][1],num);//注意平原陆地都可以飞，但是起飞点和落地点必须都是平原  
58.                 if(0 <=f.x && f.x<n && 0<=f.y && f.y<m && !vis[f.x][f.y][t.d-num]&&mapp[t.x][t.y]==0&&mapp[f.x][f.y]==0)  
59.                 {  
60.                     f.d = t.d - num;  
61.                     f.ans = t.ans + 1;  
62.                     vis[f.x][f.y][f.d] = true;  
63.                     q.push(f);  
64.                 }  
65.               }  
66.         }  
67.     }  
68.     return -1;  
69. }  
70. int main()  
71. {  
72.     char a[110];  
73.     scanf("%d%d%d",&n,&m,&D);  
74.     memset(mapp,0,sizeof(mapp));  
75.     for(int i = 0;i<n;i++)  
76.     {  
77.         scanf("%s",a);  
78.         for(int j = 0;j<m;j++)  
79.             if(a[j]=='L')  
80.             mapp[i][j] = 1;  
81.     }  
82.     if(mapp[n-1][m-1]==1)  
83.          puts("impossible");  
84.     else  
85.        {  
86.            int wz = BFS(D);  
87.            if(wz!=-1)  
88.            cout<<wz<<endl;  
89.            else  
90.             puts("impossible");  
91.        }  
92.     return 0;  
93. }  

5 5 4
PPPPP
PPPPP
LLLLL
LLLLL
LLLLL
impossible

6 6 5
PPPPPL
PLPLPL
LLLLLL
PPPPPP
PPPPPP
PPPPPP
6

1 1 1
P
0

3 3 3
PPP
PPP
PPP
3

4 4 4
PLPL
LPLP
PPPP
LLLP
4

8 8 1
PPPPPPPP
PLPLPLPL
LLLLLLLL
PPPPPPPP
PPPPPPPP
PPPPPPPP
PPPPPPPP
PPPPPPPP
impossible

mycode:

#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
char map[111][111];
int vis[111][111][111],D,n,m;
int d[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
struct node{
int x;
int y;
int d;
int step;
};
node st,ed;
queue<node>Q;
int bfs()
{
int i,j,xi,yi,di;
node now,next;
st.d=D;
st.step=0;
Q.push(st);
vis[st.x][st.y][st.d]=1;
while(!Q.empty())
{
now=Q.front();
if(now.x==ed.x&&now.y==ed.y)
return now.step;
Q.pop();
for(i=0;i<4;i++)
{
xi=d[i][0]+now.x;
yi=d[i][1]+now.y;
di=now.d;
if(xi>=0&&xi<n&&yi>=0&&yi<m&&map[xi][yi]=='P'&&!vis[xi][yi][di]&&map[now.x][now.y]=='P')
{
vis[xi][yi][di]=1;
next.x=xi;
next.y=yi;
next.d=di;
next.step=now.step+1;
Q.push(next);
}
}
for(i=0;i<4;i++)
{
for(j=now.d;j>=1;j--)
{
xi=d[i][0]*j+now.x;
                yi=d[i][1]*j+now.y;
if(xi>=0&&xi<n&&yi>=0&&yi<m&&map[xi][yi]=='P'&&!vis[xi][yi][now.d-j]&&map[now.x][now.y]=='P')
{
vis[xi][yi][now.d-j]=1;
next.x=xi;
next.y=yi;
next.step=now.step+1;
next.d=now.d-j;
Q.push(next);
}
}
}
}
return -1;
}
int main()
{
int i,fg;
while(scanf("%d%d%d",&n,&m,&D)!=EOF)
{
getchar();
for(i=0;i<n;i++)
{
scanf("%s",map[i]);
}
memset(vis,0,sizeof(vis));
while(!Q.empty())
{
Q.pop();
}
st.x=0;
st.y=0;
ed.x=n-1;
ed.y=m-1;
fg=bfs();
if(fg==-1)
printf("impossible\n");
else
printf("%d\n",fg);
}
return 0;
}

总结：

广度优先搜索举例——飞跃原野

特点：求矩阵上最短路问题，广搜是最常用方法
思路: 
1.确定搜索顺序：右下左上 （0，1）（1，0）（0，-1）（-1，0）
2.搜索时每个方向要完成如下工作：
 1）行走方式扩展结点，生成新结点，记录状态变化；
 2）飞行方式扩展结点（满足飞行规则），生成新结点，记录状态变化。
数据结构
1.搜索顺序：二维数组dir[4][2] 
2.状态记录： mark[i][j][k]
  通常情况下，最短路问题求解时，可以用一个二维表mark[i][j]存
放从起点到当前点（i，j）的距离。但对这道题目，已知法里奥每次不
仅可以向上下左右4个方向移动一格，也可以一次飞跃一定长度的距离。
由于飞行的总共长度是有限的，所以需要在平时存储最短路的二维表中
多加一维，用来表示还可以飞行多少距离。用三维数组mark[i][j][k]
来记录状态，k表示在（i，j）点，还可以飞行K长度的距离。
3.带扩展结点：队列stack[100010][3]，广度优先，先进先出

搜索过程
   用一个队列记录需要扩展的结点，并依次对队列中每个（i，j，k）
扩展。对于每个（i，j，k），从（i，j）出发，往4个方向各走一格到
（i0，j0），若mark[i0][j0][k]没有访问过，标记它已访问，并且把
（i0，j0 ，k ）入队列。此时到点（i0，j0）并且还剩下k长度可供飞行
的最短时间已经算出来了，记为mark[i0][j0][k]= mark[i][j][k]+1。
   接着，再往4个方向飞行k0步（1≤k0≤k）到（i1，j1），同样的，若
mark[i1][j1][k1]没有访问过，标记它已访问，并且把（i1，j1，k1）入
队列，并计算mark[i1][j1][k1]= mark[i][j][k]+1。
   最后，能到达目的点的状态，是我们所要求的最短时间

代码
#include <stdio.h>
 int stack[1000010][3];
 int mark[110][110][110]; 
char map[110][110];
 int m,n,d; 
const int dir[4][2]={0,1,1,0,0,-1,-1,0};
 void init()
 { int i,j;
   char s[110];
   scanf("%d %d %d",&m,&n,&d); 
   for(i=1;i<=m;i++) 
   { scanf("%s",s);
     for(j=1;j<=n;j++)
     map[i][j]=s[j-1]; 
   }
 } 

int work() 
{ int i,j,k,total,tx,ty,td,tempx,tempy,tempd;
  stack[1][0]=1;  stack[1][1]=1; stack[1][2]=d;  mark[1][1][d]=1; 
  i=total=1; 
  while(i<=total)
  { tx=stack[i][0]; ty=stack[i][1]; td=stack[i][2];
     for(j=0;j<4;j++) 
     { tempx=tx+dir[j][0]; tempy=ty+dir[j][1];
       if(tempx>0 && tempx<=m && tempy>0 && tempy<=n &&
                                       map[tempx][tempy]=='P' && !mark[tempx][tempy][td])
       { stack[++total][0]=tempx; stack[total][1]=tempy; stack[total][2]=td;
          mark[tempx][tempy][td]=mark[tx][ty][td]+1; 
          if(tempx==m && tempy==n) return mark[tempx][tempy][td];
        }
       tempx=tx; tempy=ty; tempd=td; 
       for(k=1;k<=td;k++) 
       { tempx+=dir[j][0]; tempy+=dir[j][1]; tempd--; 
          if(tempx<=0 || tempx>m || tempy<=0 || tempy>n) break;
          if(map[tempx][tempy]=='P' && !mark[tempx][tempy][tempd]) 
          { stack[++total][0]=tempx; stack[total][1]=tempy; stack[total][2]=tempd;
             mark[tempx][tempy][tempd]=mark[tx][ty][td]+1;
             if(tempx==m && tempy==n) return mark[tempx][tempy][tempd];
          }
        }
      }
      i++; 
   } 
   return -1;
 }

int main() 
{ int ans;
   init();
   ans=work(); 
   if(ans>0) 
      printf("%d\n",ans-1);
    else 
      printf("impossible\n");
    return 0;
 }