飞跃原野
Time Limit: 5000ms Memory limit: 65536K 有疑问?点这里^_^
题目描述
勇敢的法里奥出色的完成了任务之后,正在迅速地向自己的基地撤退。但由于后面有着一大群追兵,所以法里奥要尽快地返回基地,否则就会被敌人逮住。
终于,法里奥来到了最后的一站:泰拉希尔原野,穿过这里就可以回到基地了。然而,敌人依然紧追不舍。不过,泰拉希尔的地理条件对法里奥十分有利,众多的湖泊随处分布。敌人需要绕道而行,但法里奥还是决定找一条能尽快回到基地的路。
假设泰拉希尔原野是一个m*n的矩阵,它有两种地形,P表示平,L表示湖泊,法里奥只能停留在平地上。他目前的位置在左上角(1,1)处,而目的地为右下角的(m,n)。法里奥可以向前后左右4个方向移动或飞行,每移动1格需要1单位时间。而飞行的时间主要花费在变形上,飞行本身时间消耗很短,所以无论一次飞行多远的距离,都只需要1单位时间。飞行的途中不能变向,并且一次飞行最终必须要降落到平地上。当然,由于受到能量的限制,法里奥不能无限制飞行,他总共最多可以飞行的距离为D。在知道了以上的信息之后,请你帮助法里奥计算一下,他最快到达基地所需要的时间。
终于,法里奥来到了最后的一站:泰拉希尔原野,穿过这里就可以回到基地了。然而,敌人依然紧追不舍。不过,泰拉希尔的地理条件对法里奥十分有利,众多的湖泊随处分布。敌人需要绕道而行,但法里奥还是决定找一条能尽快回到基地的路。
假设泰拉希尔原野是一个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
还有 题意理解错了,跪了一会,不一定非是湖泊才能飞,平原也可以飞
- /*
- 简单的三维BFS
- 手残,WA了好几次,就是没发现t.d 写成 f.d
- 还有 题意理解错了,跪了一会,不一定非是湖泊才能飞,平原也可以飞*/
- #include <iostream>
- #include <cstdio>
- #include <cstring>
- #include <cstdlib>
- #include <queue>
- const int N = 200;
- using namespace std;
- int mapp[N][N];
- bool vis[N][N][N];
- int n,m,D;
- int mv[4][2] = {{1,0},{0,-1},{0,1},{-1,0}};
- struct node
- {
- int x,y,ans,d;
- };
- int st(int x,int y)
- {
- return x*y;
- }
- int BFS(int D)
- {
- node f,t;
- queue<node>q;
- memset(vis,0,sizeof(vis));
- f.x = 0; f.y = 0; f.ans = 0; f.d = D;
- q.push(f);
- vis[f.x][f.y][f.d] = true;
- while(!q.empty())
- {
- t = q.front();
- if(t.x==n-1 && t.y==m-1)
- return t.ans;
- q.pop();
- for(int i = 0;i < 4;i++) //走路
- {
- f.x = t.x + mv[i][0];
- f.y = t.y + mv[i][1];
- 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)
- { // ↑这写错了
- f.ans = t.ans + 1;
- f.d = t.d;
- vis[f.x][f.y][f.d] = true;
- q.push(f);
- }
- }
- for(int i=0; i<4; i++) //飞
- {
- for(int num=t.d; num>=1;num--)//找当前最优路线,尽可能的飞的最远
- {
- f.x = t.x + st(mv[i][0],num);
- f.y = t.y + st(mv[i][1],num);//注意平原陆地都可以飞,但是起飞点和落地点必须都是平原
- 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)
- {
- f.d = t.d - num;
- f.ans = t.ans + 1;
- vis[f.x][f.y][f.d] = true;
- q.push(f);
- }
- }
- }
- }
- return -1;
- }
- int main()
- {
- char a[110];
- scanf("%d%d%d",&n,&m,&D);
- memset(mapp,0,sizeof(mapp));
- for(int i = 0;i<n;i++)
- {
- scanf("%s",a);
- for(int j = 0;j<m;j++)
- if(a[j]=='L')
- mapp[i][j] = 1;
- }
- if(mapp[n-1][m-1]==1)
- puts("impossible");
- else
- {
- int wz = BFS(D);
- if(wz!=-1)
- cout<<wz<<endl;
- else
- puts("impossible");
- }
- return 0;
- }
5 5 4
PPPPP
PPPPP
LLLLL
LLLLL
LLLLL
impossible
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;
}
#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],广度优先,先进先出
思路:
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。
最后,能到达目的点的状态,是我们所要求的最短时间
用一个队列记录需要扩展的结点,并依次对队列中每个(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];
}
}
#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 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;
}
{ int ans;
init();
ans=work();
if(ans>0)
printf("%d\n",ans-1);
else
printf("impossible\n");
return 0;
}