[NOIP2014 提高组] 寻找道路(Solution bfs)

[NOIP2014 提高组] 寻找道路

题目描述

在有向图 G 中，每条边的长度均为 1，现给定起点和终点，请你在图中找一条从起点到终点的路径，该路径满足以下条件：

1. 路径上的所有点的出边所指向的点都直接或间接与终点连通。
2. 在满足条件1的情况下使路径最短。

注意：图 G 中可能存在重边和自环，题目保证终点没有出边。

请你输出符合条件的路径的长度。

输入格式

第一行有两个用一个空格隔开的整数 n 和 m，表示图有 n 个点和 m 条边。

接下来的 m 行每行 2 个整数 x,y，之间用一个空格隔开，表示有一条边从点 x 指向点y。

最后一行有两个用一个空格隔开的整数 s,t，表示起点为 s，终点为 t。

输出格式

输出只有一行，包含一个整数，表示满足题目描述的最短路径的长度。如果这样的路径不存在，输出−1。

输入输出样例

输入 #1

3 2
1 2
2 1
1 3

输出 #1

-1

输入 #2

6 6
1 2
1 3
2 6
2 5  
4 5
3 4
1 5

输出 #2

3

说明/提示

解释1：

如上图所示，箭头表示有向道路，圆点表示城市。起点1与终点3不连通，所以满足题目描述的路径不存在，故输出−1 。

解释2：

如上图所示，满足条件的路径为1- >3- >4- >5。注意点2 不能在答案路径中，因为点2连了一条边到点6 ，而点6 不与终点5 连通。

---

此题乍看一脸懵逼，数据量也很吓人，后来一看就是两遍广搜，题目说的路径上的所有点的出边所指向的点都直接或间接与终点连通。只需要多处理一下每一个节点连向的节点就行了，复杂度O($3(n+m)$)

第一遍广搜反向建边，从终点开始，能到的点全部打上标记。

枚举每一个点，如果当前节点不能到或者子节点不能到都标记为0，否则标记为1，记作数组vis

第二遍广搜，从起点开始，走没打过标记的点（重边），并且vis_x等于1，才满足题意，记录步数就行了，连01边权都没有，bfs走到点最优

#include<bits/stdc++.h>
using namespace std;
int n,m,hed[200009],nxt[200009],to[200009],cnt,ans;
int hed1[200009],nxt1[200009],to1[200009],cnt1;
int u,v,s,t;
bool ld[200009],cant[200009],vis[200009],flag;
void add(int x,int y)
{
	to[++cnt]=y;
	nxt[cnt]=hed[x];
	hed[x]=cnt;
}
void add1(int x,int y)
{
	to1[++cnt1]=y;
	nxt1[cnt1]=hed1[x];
	hed1[x]=cnt1;
}
void bfs1(int st)
{
	ld[st]=1;
	queue<int>qu;
	qu.push(st);
	while(!qu.empty())
	{
		int x=qu.front();
		qu.pop();
		for(int i=hed1[x];i;i=nxt1[i])
		{
			int y=to1[i];
			if(!ld[y]) 
			{
				qu.push(y);
				ld[y]=1;
			}
		}
	}
}
struct node
{
	int x,dis;
};
void bfs2(int st)
{
	queue<node>qu2;
	qu2.push((node){st,0});
	while(!qu2.empty())
	{
		node now=qu2.front();
		qu2.pop();
		int x=now.x;
		if(x==t)
		{
			flag=1;
			ans=now.dis;
			return;
		}
		for(int i=hed[x];i;i=nxt[i])
		{
			int y=to[i];
			if(!vis[y]&&!cant[y])
			{
				qu2.push((node){y,now.dis+1});
				vis[y]=1;
			}
		}
	}
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d",&u,&v);
		if(u!=v) add(u,v),add1(v,u);
	}
	scanf("%d%d",&s,&t);
	bfs1(t);
	for(int i=1;i<=n;i++)
	{
		if(ld[i])
		{
			for(int j=hed[i];j;j=nxt[j])
			{
				int arv=to[j];
				if(!ld[arv]) 
				{
					cant[i]=1;
					break;
				}
			}
		}
		else cant[i]=1;
	}
	bfs2(s);
	if(flag) printf("%d",ans);
	else printf("-1");
	return 0;
}