P5663 [CSP-J2019] 加工零件

闲话:

因某wsx248老师强迫建议而写的 第一篇博客
有错误恳请指正

题面:

[CSP-J2019] 加工零件

题目描述

凯凯的工厂正在有条不紊地生产一种神奇的零件,神奇的零件的生产过程自然也很神奇。工厂里有 n n n 位工人,工人们从 1 ∼ n 1 \sim n 1n 编号。某些工人之间存在双向的零件传送带。保证每两名工人之间最多只存在一条传送带。

如果 x x x 号工人想生产一个被加工到第 L   ( L > 1 ) L\,(L \gt 1) L(L>1) 阶段的零件,则所有 x x x 号工人有传送带直接相连的工人,都需要生产一个被加工到第 L − 1 L - 1 L1 阶段的零件(但 x x x 号工人自己无需生产第 L − 1 L - 1 L1 阶段的零件)。

如果 x x x 号工人想生产一个被加工到第 1 1 1 阶段的零件,则所有 x x x 号工人有传送带直接相连的工人,都需要为 x x x 号工人提供一个原材料。

轩轩是 1 1 1 号工人。现在给出 q q q 张工单,第 i i i 张工单表示编号为 a i a_i ai 的工人想生产一个第 L i L_i Li 阶段的零件。轩轩想知道对于每张工单,他是否需要给别人提供原材料。他知道聪明的你一定可以帮他计算出来!

输入格式

第一行三个正整数 n n n m m m q q q,分别表示工人的数目、传送带的数目和工单的数目。

接下来 m m m 行,每行两个正整数 u u u v v v,表示编号为 u u u v v v 的工人之间存在一条零件传输带。保证 u ≠ v u \neq v u=v

接下来 q q q 行,每行两个正整数 a a a L L L,表示编号为 a a a 的工人想生产一个第 L L L 阶段的零件。

输出格式

q q q 行,每行一个字符串 Yes 或者 No。如果按照第 i i i 张工单生产,需要编号为 1 的轩轩提供原材料,则在第 i i i 行输出 Yes;否则在第 i i i 行输出 No。注意输出不含引号。

样例 #1

样例输入 #1
3 2 6
1 2
2 3
1 1
2 1
3 1
1 2
2 2
3 2
样例输出 #1
No
Yes
No
Yes
No
Yes

样例 #2

样例输入 #2
5 5 5
1 2
2 3
3 4
4 5
1 5
1 1
1 2
1 3
1 4
1 5
样例输出 #2
No
Yes
No
Yes
Yes

提示

样例 1 说明

P5663 [CSP-J2019] 加工零件_第1张图片

编号为 1 的工人想生产第 1 阶段的零件,需要编号为 2 的工人提供原材料。

编号为 2 的工人想生产第 1 阶段的零件,需要编号为 1 和 3 的工人提供原材料。

编号为 3 的工人想生产第 1 阶段的零件,需要编号为 2 的工人提供原材料。

编号为 1 的工人想生产第 2 阶段的零件,需要编号为 2 的工人生产第 1 阶段的零 件,需要编号为 1 和 3 的工人提供原材料。

编号为 2 的工人想生产第 2 阶段的零件,需要编号为 1 和 3 的工人生产第 1 阶段的零件,他/她们都需要编号为 2 的工人提供原材料。

编号为 3 的工人想生产第 2 阶段的零件,需要编号为 2 的工人生产第 1 阶段的零件,需要编号为 1 和 3 的工人提供原材料。

样例 2 说明

P5663 [CSP-J2019] 加工零件_第2张图片

编号为 1 的工人想生产第 1 阶段的零件,需要编号为 2 和 5 的工人提供原材料。

编号为 1 的工人想生产第 2 阶段的零件,需要编号为 2 和 5 的工人生产第 1 阶段的零件,需要编号为 1,3,4 的工人提供原材料。

编号为 1 的工人想生产第 3 阶段的零件,需要编号为 2 和 5 的工人生产第 2 阶段的零件,需要编号为 1,3,4 的工人生产第 1 阶段的零件,需要编号为 2,3,4,5 的工人提供原材料。

编号为 1 的工人想生产第 4 阶段的零件,需要编号为 2 和 5 的工人生产第 3 阶段的零件,需要编号为 1,3,4 的工人生产第 2 阶段的零件,需要编号为 2,3,4,5 的工人生产第 1 阶段的零件,需要全部工人提供原材料。

编号为 1 的工人想生产第 5 阶段的零件,需要编号为 2 和 5 的工人生产第 4 阶段的零件,需要编号为 1,3,4 的工人生产第 3 阶段的零件,需要编号为 2,3,4,5 的工人生产第 2 阶段的零件,需要全部工人生产第 1 阶段的零件,需要全部工人提供原材料。

数据规模与约定

20 20 20 个测试点。

对所有测试点保证 1 ≤ u , v , a ≤ n 1 \leq u, v, a \leq n 1u,v,an

测试点 1 ∼ 4 1\sim4 14 1 ≤ n , m ≤ 1000 1 \leq n, m \leq 1000 1n,m1000 q = 3 q = 3 q=3 L = 1 L = 1 L=1

测试点 5 ∼ 8 5\sim8 58 1 ≤ n , m ≤ 1000 1 \leq n, m \leq 1000 1n,m1000 q = 3 q = 3 q=3 1 ≤ L ≤ 10 1 \leq L \leq 10 1L10

测试点 9 ∼ 12 9\sim12 912 1 ≤ n , m , L ≤ 1000 1 \leq n, m, L \leq 1000 1n,m,L1000 1 ≤ q ≤ 100 1 \leq q \leq 100 1q100

测试点 13 ∼ 16 13\sim16 1316 1 ≤ n , m , L ≤ 1000 1 \leq n, m, L \leq 1000 1n,m,L1000 1 ≤ q ≤ 1 0 5 1 \leq q \leq 10^5 1q105

测试点 17 ∼ 20 17\sim20 1720 1 ≤ n , m , q ≤ 1 0 5 1 \leq n, m, q \leq 10^5 1n,m,q105 1 ≤ L ≤ 1 0 9 1 \leq L \leq 10^9 1L109

sol:

一道比较容易 想到的题,可我竟然想了好久看了好久的题解 才稍微明白了。

首先根据题目可以得出简化题意:n个点,m条边,从ai号点出发,设当前点的将要做的零件为L,周围有边直接相连的点会做上L-1阶段的零件,以此类推。q次询问,求1号点是否需要做0阶段的零件。( 1 ≤ n , m , q ≤ 1 0 5 1 \leq n, m, q \leq 10^5 1n,m,q105 1 ≤ L ≤ 1 0 9 1 \leq L \leq 10^9 1L109

那么显然的事实:由于每个点的可以做的零件种类不唯一,所以可以反复在一条双向边上传来传去(也就是假设X点与Y点相连,X要做Z阶段的零件,那Y就要做z-1,z-3,z-5…的零件,X就要做Z,Z-2,Z-4,Z-6…的零件)。

就可以得出ai点(至少)会做L,L-2,L-4,L-6,L-8…等阶段零件,旁边的点至少做L-1,L-3,L-5,L-7…等阶段零件。
将问题转化为是否存在一条从ai到1(是不是和其他的题解从1开始搜索不太一样,主要是为了引出为什么想到从1开始bfs,可以看q2),长度为L的路径(可以走重复边,点),所以可以先思考如果保证L为偶数(或奇数)时怎样判定为Yes还是No。
可以做从ai到1的长度为偶数的最短路,以确保1号点有零件做。如果他有零件做,那么是不是可能会做到原材料 。
当长度为奇数时,同理可得。
那么有几个问题
q1.如何求长度为奇数和偶数的最短路?

ans1:如果单独求奇数或偶数的最短路,不太好思考。但是两个都求出来,长度为奇数就可以由长度为偶数的转移过来,偶数就可以由长度为奇数的转移过来(因为边权全为一)。若还不太懂可以看看代码。

q2:每次都从ai到1做一遍bfs,时间复杂度不会爆吗?

ans2:由于求出最短路只会用到到1的值,又因为是双向边,就可以等价于从1到所有的点做bfs,后面有点ai用就行了,就达到了预处理O(n),查询O(1)。

q3:代码中不需要处理不连通的特殊情况吗?

ans3:之所以不用特殊处理不连通的情况,是因为若不连通,dis的值会是0x3f3f3f3f(无穷大)。

code:

#include 
using namespace std;
inline int read(){
	int w=0,f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9'){
		if(ch=='-') f=-1;
		ch=getchar();
	}
	while('0'<=ch&&ch<='9'){
		w=w*10+ch-'0';
		ch=getchar();
	}
	return w*f;
}
const int N=1e5+15;
int n,m,q,dis[N][2];//dis[i][0]为从1到i的偶数最短路,dis[i][1]为从1到i的奇数最短路。
vector <int> e[N];
struct Point{
	int p,w,z;//p是当前点,w是从1到当前点的最小距离,z是奇偶性质 (当z==0时为偶,当 z==1是为奇) 
};
void bfs(){
	queue <Point> q;
	memset(dis,0x3f,sizeof(dis));
	q.push(Point{1,0,0});
	dis[1][0]=0;
	while(!q.empty()){
		Point now=q.front();
		q.pop();
		int len=e[now.p].size(),w=now.w;
		for(int i = 0 ; i<len ; i++){
			int to=e[now.p][i];
			if(dis[now.p][now.z]+1<dis[to][now.z^1]){//运用^,将0改成1,1改成0.
				dis[to][now.z^1]=dis[now.p][now.z]+1;
				q.push({to,dis[to][now.z^1],now.z^1});
			}
		}
	}
}//之所以不用特殊处理不连通的情况,是因为若不连通,dis的值会是0x3f3f3f3f(无穷大)
int main(){
	n=read(),m=read(),q=read();
	for(int i = 1 ; i<=m ; i++){
		int u=read(),v=read();
		e[u].push_back(v);
		e[v].push_back(u);
	}
	bfs();
	for(int i = 1 ; i<=q ; i++){
		int a=read(),L=read();
		if(L>=dis[a][L&1]){
			puts("Yes");
		}
		else{
			puts("No");
		}
	}
	return 0;
}

如果有其他问题,可以@或私信我,会尽量回答的。

你可能感兴趣的:(算法,广度优先)