USACO2.4.2 穿越栅栏（简单版本） （重庆一中高2018级信息学竞赛测验2） 解题报告

这次的考题与USACO2.4.2原题不同，输入数据要简单一些。原题的解题报告见USACO2.4.2 穿越栅栏（原题） 解题报告。

【问题描述】  

FJ搭建了一个巨大的用栅栏围成的迷宫。幸运的是，他在迷宫的边界上留出了两段栅栏作为迷宫的出口，并且从迷宫中的任意一点都能找到一条走出迷宫的路。给定迷宫的行和列数和这个迷宫，然后计算从迷宫中最“糟糕”的那一个点走出迷宫所需的最少步数。


【输入格式】  
    第一行为正数m和n，表示迷宫的行数和列数，用空格隔开。迷宫用一个由数字组成的矩阵表示，一个数字表示迷宫的一个格子。每一个格子的数字告诉我们这个格子的东、西、南、北是否有栅栏存在。每个数字是由以下四个整数的某个或某几个或一个都没有加起来的。 
　　1: 在西面有栅栏
　　2: 在北面有栅栏
　　4: 在东面有栅栏
　　8: 在南面有栅栏
  迷宫内部的栅栏会被规定两次。比如说(1,1)南面的栅栏，亦会被标记为(2,1)北面的栅栏。 
  最后两行是由出口格子的行列坐标。
【输出格式】  
输出一个单独的整数，表示能保证牛从迷宫中任意一点走出迷宫的最小步数。


【输入输出样例】
pass.in
3 5
11 2 10 2 6
3 8 14 5 5
13 3 10 12 9
3 2
3 5

pass.out

9

【输入输出样例说明】

    样例输入的迷宫如图a，最糟糕的点是左下角的格子，走出迷宫需要9步，见图b。 


【数据范围】  
1 <= m <= 38

1 <= n <= 100

注：在所给的评测数据中，数据范围应为1<=m<=100 ，1<=n<=38

做题思路（正解1）：根据题意，要求每个格子到出口的步数比较麻烦，可以反过来求出口到格子的步数，可知该题的解法是从迷宫出口出发进行BFS，计算出出口到每个格子的步数（经过的边数），在建立存储结构时，可以循环找出的哪两个格子间有边相连，然后存在变长数组里的。然后分别从两个出口进行BFS，将走的步数分别存在两个数组中，然后枚举每个格子找最小步数的最大值，即为所求。

解题思路（正解2）：根据题意，在输入时，将每个格子周围的栅栏记录到数组中，然后以两个迷宫出口为出发点进行多源BFS，计算出每个格子到出口的最小步数，取最大值即为所求。

代码1：将每个格子的坐标转化为点的下标，记录与每个格子相连通的格子，从两个迷宫出口分别BFS

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
const int maxn=105;
int N,M,x,y;
int a[maxn][maxn]; 
int s[5];
vector<int>g[maxn*maxn];  //记录与每个格子相连通的格子
int vis[maxn*maxn],dep1[maxn*maxn],dep2[maxn*maxn];
void BFS(int i,int *dep)
{
	queue<int>q;
	memset(vis,0,sizeof(vis));
	q.push(i);
	vis[i]=1;
	dep[i]=1;
	while(!q.empty())
	{
		int i=q.front();  q.pop();
		for(int k=0;k<g[i].size();k++)
		{
			int j=g[i][k];
			if(vis[j])  continue;
			vis[j]=1;
			dep[j]=dep[i]+1;
			q.push(j);
		}
	}
}
int main()
{
	freopen("pass.in","r",stdin);
	freopen("pass.out","w",stdout);
	scanf("%d%d",&M,&N);
	for(int i=1;i<=M;i++)
	for(int j=1;j<=N;j++)
	scanf("%d",&a[i][j]);
	for(int i=1;i<=M;i++)
	for(int j=1;j<=N;j++)
	{
		if(i<M && a[i][j]<8)  //看该格子的南面是否有栅栏，以此判断两个格子是否连通
		{
			int b=(i-1)*N+j,c=(i-1)*N+j+N;  //将坐标转化为下标
			g[b].push_back(c);
			g[c].push_back(b);
		}
		if(j<N && (a[i][j]<4 || (a[i][j]>=8 && a[i][j]<12))) //看该格子的东面是否有栅栏，以此判断两个格子是否连通
		{
			int b=(i-1)*N+j,c=(i-1)*N+j+1;
			g[b].push_back(c);
			g[c].push_back(b);
		}
	}
	for(int i=1;i<=2;i++)
	{
		scanf("%d%d",&x,&y);
		s[i]=(x-1)*N+y;
	}
	int ans=0;
	BFS(s[1],dep1);
	BFS(s[2],dep2);
	for(int i=1;i<=N*M;i++)
	ans=max(ans,min(dep1[i],dep2[i]));  //同个格子取最小值（走到出口最近的步数），答案取最大值
	printf("%d\n",ans);
	return 0;
}

代码2：记录每个格子四周是否有栅栏，从两个出口同时进行BFS（多源BFS）

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
const int maxn=105;
int N,M,x,y;
struct data{int x,y;};
int mat[maxn][maxn][4];  //记录每个格子四周是否有栅栏
data s[5];
int vis[maxn][maxn],d[maxn][maxn];
int dx[]={1,0,-1,0};  //0南 1东 2北 3西 
int dy[]={0,1,0,-1};
void BFS()  //多源BFS
{
	queue<data>q;
	memset(vis,0,sizeof(vis));
	q.push(s[1]);
	vis[s[1].x][s[1].y]=1;
	d[s[1].x][s[1].y]=1;
	q.push(s[2]);
	vis[s[2].x][s[2].y]=1;
	d[s[2].x][s[2].y]=1;
	data t,tt;
	while(!q.empty())
	{
		t=q.front();  q.pop();
		for(int i=0;i<4;i++)
		{
			if(mat[t.x][t.y][i]==1)  continue;
			tt.x=t.x+dx[i];
			tt.y=t.y+dy[i];
			if(tt.x<1 || tt.x>M || tt.y<1 || tt.y>N)  continue;  //判断越界
			if(vis[tt.x][tt.y])  continue;
			vis[tt.x][tt.y]=1;
			d[tt.x][tt.y]=d[t.x][t.y]+1;
			q.push(tt);  
		}
	}
}
int main()
{
	freopen("pass.in","r",stdin);
	freopen("pass.out","w",stdout);
	scanf("%d%d",&M,&N);
	memset(mat,0,sizeof(mat));
	int t;
	for(int i=1;i<=M;i++)
	for(int j=1;j<=N;j++)
	{
	   	scanf("%d",&t);
	   	if(t-8>=0) mat[i][j][0]=1,t=t-8;
	   	if(t-4>=0) mat[i][j][1]=1,t=t-4;
	   	if(t-2>=0) mat[i][j][2]=1,t=t-2;
	   	if(t-1>=0) mat[i][j][3]=1,t=t-1;
	}
	for(int i=1;i<=2;i++)
	scanf("%d%d",&s[i].x,&s[i].y);
	int ans=0;
	BFS();
	for(int i=1;i<=M;i++)
	for(int j=1;j<=N;j++)
	ans=max(ans,d[i][j]);  //答案取最大值
	printf("%d\n",ans);
	return 0;
}

考后反思：做题时数据规模一定要看清楚，如果可以还是适当多设点，这次就被评测数据坑了。尽量还是用学过的知识做，用自己的方法做难免可能犯错。