NOIP2014 提高组 寻找道路

描述

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

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

注意：图 G 中可能存在重边和自环，题目保证终点没有出边。 请你输出符合条件的路径的长度。

格式

输入格式

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

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

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

输出格式

输出只有一行，包含一个整数，表示满足题目描述的最短路径的长度。

如果这样的路径不存在，输出-1。

样例1

样例输入1[复制]

3 2
1 2
2 1
1 3

样例输出1[复制]

-1

样例2

样例输入2[复制]

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

样例输出2[复制]

3

限制

对于 30%的数据，0 < n ≤ 10，0 < m ≤ 20；

对于 60%的数据，0 < n ≤ 100，0 < m ≤ 2000；

对于 100%的数据，0 < n ≤ 10,000，0 < m ≤ 200,000，0 < x，y，s，t ≤ n，x ≠ t。

提示

【输入输出样例1说明】

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

【输入输出样例2说明】

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

来源

NOIP2014 提高组 Day2

/*

简单说一下我的思路：

  条件一是 路径上的所有点的出边所指向的点都直接或间接与终点连通

这个比较好处理 ，你就从终点开始逆向DFS，把能到终点的点全部标记一下。

标记完了以后你就想想哪些点使我们可以使用的。假设有一点1  如果点1所有出边所指向的点都被标记过的话，

显然这个点是可以经过的。

那么你把这些点存起来，跑最短路的时候只跑保存的点的，就OK了。

*/

#include<set>
#include<map>
#include<cmath>
#include<queue>
#include<stack>
#include<cstdio>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#define MAXN 10037
#define MAXM 200037

using namespace std;

int n;
int m;
int S;
int T;
int cnt;
int a[MAXM];
int b[MAXN];
int cd[MAXN];
int dis[MAXN];
int vis[MAXN];
int head[MAXN][2];

bool used[MAXN];

queue<int>Q;

stack<int>V;

struct Edge
{
	int to;
	int next;
} edge[MAXM][2];

inline void add(int u,int v)
{
	edge[++cnt][0].to=v;
	edge[cnt][0].next=head[u][0];
	head[u][0]=cnt;
	edge[cnt][1].to=u;
	edge[cnt][1].next=head[v][1];
	head[v][1]=cnt;
}

inline void T_DFS(int u)
{
	V.push(u); vis[u]=1;
	for (int i=head[u][1];i;i=edge[i][1].next) {
		int v=edge[i][1].to;
		if (!vis[v]) {
			T_DFS(v);
		}
	} return ;
}

inline void S_BFS(int s)
{
	while(!Q.empty()) Q.pop();
	dis[s]=0; Q.push(s); vis[s]=1;
	while(!Q.empty()) {
		int u=Q.front(); Q.pop();
		for (int i=head[u][0];i;i=edge[i][0].next) {
			int v=edge[i][0].to;
			if (!vis[v]&&!used[v]) {
				vis[v]=1;
				dis[v]=dis[u]+1;
				Q.push(v);
			}
		}
	}
}

inline void solve()
{
	scanf("%d%d",&n,&m);
	for (int i=1;i<=m;i++) {
		scanf("%d%d",&a[i],&b[i]);
		add(a[i],b[i]);
		cd[a[i]]++;
	}
	scanf("%d%d",&S,&T);
	T_DFS(T);
	for (int i=1;i<=n;i++) {
		for (int j=head[i][0];j;j=edge[j][0].next) {
			int v=edge[j][0].to;
			if (!vis[v])
				used[i]=1;
		}
	}
	memset(vis,0,sizeof(vis));
	S_BFS(S);
	if (!vis[T])
		printf("-1\n");
	else
		printf("%d\n",dis[T]);
}

int main()
{
	solve();
	return 0;
}