刷题记录:牛客NC15665maze

传送门:牛客

题目描述:

小明来到一个由n x m个格子组成的迷宫，有些格子是陷阱，用'#'表示，小明进入陷阱就会死亡，'.'表示没有陷阱。小明所在的位置用'S'表示，目的地用'T'表示。
小明只能向上下左右相邻的格子移动，每移动一次花费1秒。
有q个单向传送阵，每个传送阵各有一个入口和一个出口，入口和出口都在迷宫的格子里，当走到或被传送
到一个有传送阵入口的格子时，小明可以选择是否开启传送阵。如果开启传送阵,小明就会被传送到出口对
应的格子里，这个过程会花费3秒；如果不开启传送阵，将不会发生任何事情，小明可以继续向上下左右四
个方向移动。
一个格子可能既有多个入口，又有多个出口，小明可以选择任意一个入口开启传送阵。使用传送阵是非常
危险的，因为有的传送阵的出口在陷阱里，如果小明使用这样的传送阵，那他就会死亡。也有一些传送阵
的入口在陷阱里，这样的传送阵是没有用的，因为小明不能活着进入。请告诉小明活着到达目的地的最短
时间。
输入:
5 5 1
..S..
.....
.###.
.....
..T..
1 2 3 3
5 5 1
..S..
.....
.###.
.....
..T..
3 3 1 2
5 5 1
S.#..
..#..
###..
.....
....T
0 1 0 2
4 4 2
S#.T
.#.#
.#.#
.#.#
0 0 0 3
2 0 2 2
输出:
6
8
-1
3

emmm,一眼跑图题,所以我们应该使用BFS来进行搜索,但是感觉这道题的细节还是有点多的,难度怎么会只有两星呢??

主要思路:

1. 首先我们根据给出的图进行存图,然后找到起点和终点的位置,并且存储障碍物的位置
2. 然后我们开始存储传送门的起点和终点,此时我们使用vector来进行存储(这里注意,我们的传送门是单向的,刚开始我存了双向的边…,并且改一下我们的原来的图,将传送门的位置改一下字符.注意我们的陷阱可能在起点也可能在终点位置)
3. 然后我们开始BFS,在BFS的过程中每次都判断是不是传送门的位置,如果是的话就加入我门的传送门的目的地和该点的四周位置即可.注意此时如果我们需要使用vis数组的话需要将我们的队列改为优先队列,因为传送门的加入,使我们无法保证当前我们加入队列中的点是不是最优的.[也就是说之后我们可能需要更新这一点的],但是如果不加vis数组的又会导致大量的重复枚举导致MLE或者TLE.所以我们应该使用优先队列,保证每次拿出来的点都是当前时间段时间花费最小的,这样就不怕前面不优的解存在了(有一点像最短路dij的算法,保证我们的BFS队列中的时间花费尽量一致,BFS就是基于时间一致性的)

下面是具体的代码部分:

#include <iostream>
#include <cstdio>
#include <cmath>
# include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <string.h>
#include <stack>
#include <deque>
using namespace std;
typedef long long ll;
#define inf 0x3f3f3f3f
#define root 1,n,1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
#define ll_maxn 0x3f3f3f3f3f3f3f3f
const double eps=1e-8;
int T,n,m,q;int sx,sy,ex,ey;
char mp[400][400];vector<int>mp_to_x[301][301];vector<int>mp_to_y[301][301];
struct Que{
	int x,y,sum;
	bool operator<(const Que &rhs) const {
		return sum>rhs.sum;
	}
};
int vis[600][600];
int dx[4]={1,0,-1,0};
int dy[4]={0,-1,0,1};
int ans=inf;
void BFS(int x,int y) {
	priority_queue<Que>q;
	q.push({x,y,0});
	while(!q.empty()) {
		Que f=q.top();q.pop();
		int xx=f.x,yy=f.y;
		if(vis[xx][yy]) continue;
		vis[xx][yy]=1;//注意这个vis的判断只能放在这里,刚开始我将这个判断放在了后面,导致反复的wa
		//因为我们使用的是优先队列,所以我们后面加入的点应该服从于之前加入的,所以不能在加入时直接染色
		if(xx==ex&&yy==ey) {
			ans=f.sum;break;
		}
		if(mp[xx][yy]=='$') {
			for(int j=0;j<mp_to_x[xx][yy].size();j++) {
				if(vis[mp_to_x[xx][yy][j]][mp_to_y[xx][yy][j]]) continue;
				q.push({mp_to_x[xx][yy][j],mp_to_y[xx][yy][j],f.sum+3});
			}
		}
		for(int i=0;i<=3;i++) {
			xx=f.x+dx[i],yy=f.y+dy[i];
			if(xx<1||yy<1||xx>n||yy>m||vis[xx][yy]==1) continue;
			q.push({xx,yy,f.sum+1});
		}
	}
}
int main() {
	while(scanf("%d%d%d",&n,&m,&q)!=EOF) {
		ans=inf;
		memset(vis,0,sizeof(vis));memset(mp_to_x,0,sizeof(mp_to_x));
		memset(mp,'\0',sizeof(mp));memset(mp_to_y,0,sizeof(mp_to_y));
		for(int i=1;i<=n;i++) {
			for(int j=1;j<=m;j++) {
				cin>>mp[i][j];
				if(mp[i][j]=='S'){
					sx=i;sy=j;
				}else if(mp[i][j]=='T'){
					ex=i;ey=j;
				}else if(mp[i][j]=='#') {
					vis[i][j]=1;
				}
			}
		}
		int x1,y1,x2,y2;
		for(int i=1;i<=q;i++) {
			x1=read();y1=read();x2=read();y2=read();
			x1+=1;y1+=1;x2+=1;y2+=1;
			if(mp[x1][y1]=='#'||mp[x2][y2]=='#') continue;
			mp[x1][y1]='$';mp_to_x[x1][y1].push_back(x2);mp_to_y[x1][y1].push_back(y2);
		}
		BFS(sx,sy);
		if(ans==inf) printf("-1\n");
		else printf("%d\n",ans);
	}
	return 0;
}