The 2024 ICPC Asia East Continent Online Contest (I) L. Bull Farm（性质题+有向图可达性/最短路）

题目

t(t<=2e3)组样例，有n(n<=2e3)个槽和n-1头牛，l(l<=2e3)个按钮，

第i个按钮能同时控制n头牛，如果牛在按按钮前位于j位置，则按完之后位于tij位置

q(q<=1e6)组询问，每次询问给出a,b,c，

询问能否使得初始局面空出来的是a槽的情况下，只用前c种按钮，使得终态局面空出来的是b槽，

可以的话输出1，否则输出0

特别地，任意时刻都不能有两头牛位于同一个槽内

思路来源

乱搞ac+qoj榜一代码

题解

如果按完按钮之后会导致两头牛位于同一个槽内，则这个按钮不能按

dp[i][j]表示初始局面空出来的是j槽，按了i按钮后，空出来的是dp[i][j]槽，

也就是需要满足，t[i][1]到t[i][n]这一行，除去t[i][j]以外，其他n-1个数两两不重复

这有两种情况，

1. 本身t[i]这一行就是一个排列，如5 4 2 3 1，此时空任意一个都可以，

空5的话可以变成空1，反过来也可以，因为1、5在一个置换环内，2、3、4在一个环内，

此时该对每个环连无向边，可以用并查集代替

2. 恰好只有一组数出现了两次，如1 2 2 4 5，此时只能空t[i][2]/t[i][3]，

空2的话最后变成空3，空3的话最后还是空3，

也就是初始时是空的j，终态就会变成去掉t[i][j]后n-1个数里没有的那个数v

此时该连有向边j->v

所以，基于这个数据范围，很自然暴力的做法就是，离线询问，从前0个处理到前l个，

每次释放一个按钮时，动态加无向边和有向边，然后询问a到b是否可达，复杂度O(2000^3/64)

认真动动脑子发现，这个可以给每个点i求访问其他点j的最早时机dis[j]，

按按钮从小到大释放边，按钮的编号即视为距离，

开l个队列，按距离从小到大bfs，达到去掉最短路的log的目的

对于边u->v来说，每次只用u被访问过，且v未被访问过的边，并把v加入队列，

也就是最早前dis[j]个按钮时，i是可以访问j的，此时把无向边也当成有向边做，最多也就加3n条边

复杂度O(n*(n+m+l))

代码1（tarjan缩点+并查集+拓扑排序+bitset）

#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=(a);i<=(b);++i)
#define per(i,a,b) for(int i=(a);i>=(b);--i)
typedef long long ll;
typedef double db;
typedef pair<int,int> P;
#define fi first
#define se second
#define pb push_back
#define dbg(x) cerr<<(#x)<<":"<<x<<" ";
#define dbg2(x) cerr<<(#x)<<":"<<x<<endl;
#define SZ(a) (int)(a.size())
#define sci(a) scanf("%d",&(a))
#define scll(a) scanf("%lld",&(a))
#define pt(a) printf("%d",a);
#define pte(a) printf("%d\n",a)
#define ptlle(a) printf("%lld\n",a)
#define debug(...) fprintf(stderr, __VA_ARGS__)
const int N=4e3+10,M=5e3+10,X=1e6+10,K=256;
int c,n,l,q,g[K][K];
int to[N][N],par[N],deg[N],Q[N],now[N];
char s[X],ans[X];
vector<array<int,3>>ask[N];
int head[N],cnt;
int low[N],dfn[N],num;//最早非负祖先时间戳 时间戳 
int stk[N],top;//用数组模拟栈 栈顶 当前栈顶值 
int col[N],tot;//染色 颜色数 
bool in[N];//是否在栈中 
vector<int>all,F[N];
P E[M];
int find(int x){
	return par[x]==x?x:par[x]=find(par[x]);
}
void mer(int x,int y){
	//if(!x || !y)while(1);
	x=find(x),y=find(y);
	if(x==y)return;
	par[y]=x;
}
int f(char x,char y){
	int nx=x,ny=y;
	//if(nx>100 || ny>100)while(1);
	return g[nx][ny];
}
struct edge{
	int to,next;
}e[M];
void add(int u,int v){
	e[++cnt].to=v;
	e[cnt].next=head[u];
	head[u]=cnt;
}
void dfs(int u){
	low[u]=dfn[u]=++num;
	in[u]=1;
	stk[++top]=u;
	for(int i=head[u];i;i=e[i].next){
		int v=e[i].to;
		if(!dfn[v]){
			dfs(v);
			low[u]=min(low[u],low[v]);
		}
		else if(in[v]){
			low[u]=min(low[u],dfn[v]);
		}
	}
	if(low[u]==dfn[u]){
		tot++;
		int now;
		do{
			now=stk[top--];
			col[now]=tot;
			in[now]=0; 
		}while(now!=u);
	}
}
void init(int n){
	memset(head,0,(n+5)*sizeof(int));
	memset(in,0,(n+5)*sizeof(bool));
	memset(dfn,0,(n+5)*sizeof(int));
	memset(low,0,(n+5)*sizeof(int));
	memset(deg,0,(n+5)*sizeof(int));
	memset(now,0,(n+5)*sizeof(int));
	cnt=num=top=tot=0;
	rep(i,1,n)F[i].clear();
}

template<int LEN>void solve(int p){
	if(LEN<=n){solve<min(N,LEN<<1)>(p);return;}
	if(p){
		init(n);
		bool no=0;
		int two=0;
		rep(j,1,n){
			int v=to[p][j];	
			now[v]++;
			if(now[v]==2)two++;
			if(now[v]==3)no=1;
		}
		if(two>=2)no=1;
		//printf("i:%d no:%1d two:%d\n",i,no,two);
		if(!no){
			if(!two){
				rep(j,1,n){
					int v=to[p][j];
					if(j==v)continue;
					//printf("p:%d j:%d v:%d\n",p,j,v);
					mer(j,v);
				}
			}
			else{
				int pos=0;
				rep(j,1,n){
					if(!now[j]){
						pos=j;
						break;
					}
				}
				rep(j,1,n){
					int v=to[p][j];
					if(now[v]==2){
						E[++c]=P(j,pos);
					}
				}	
			}
		}
		all.clear();
		rep(j,1,c){
			int u=E[j].fi,v=E[j].se;
			int fj=find(u),fp=find(v);
			//printf("p:%d j:%d v:%d pos:%d\n",p,j,v,pos);
			if(fj==fp)continue;
			add(fj,fp);
		}
		rep(j,1,n){
			if(find(j)==j){
				//printf("p:%d j:%d\n",p,j);
				all.pb(j);
				if(!dfn[j])dfs(j);
			}
		}
		vector<bitset<LEN>>can(n+1,bitset<LEN>());
		int t=0;
		for(auto &u:all){
			for(int i=head[u];i;i=e[i].next){
	    		int v=e[i].to;
	    		//printf("u:%d v:%d\n",u,v);
	    		if(col[u]==col[v])continue;
				F[col[u]].pb(col[v]);
				deg[col[v]]++;
			}
		}
		rep(i,1,tot){
			if(!deg[i])Q[t++]=i;
		}
		for(int s=0;s<t;++s){
			int u=Q[s];
			for(auto &v:F[u]){
				if((--deg[v])==0){
					Q[t++]=v;
				}
			}
		}
		for(int i=t-1;i>=0;--i){
			int u=Q[i];
			//if(u>LEN)while(1);
			can[u]=bitset<LEN>();
			can[u][u]=1;
			for(auto &v:F[u]){
				can[u]|=can[v];
			}
		}
		for(auto &x:ask[p]){
			int a=x[0],b=x[1],id=x[2];
			//printf("a:%d fa:%d b:%d fb:%d ca:%d cb:%d\n",a,find(a),b,find(b),col[find(a)],col[find(b)]);
			a=col[find(a)],b=col[find(b)];
			ans[id]=can[a].test(b)?'1':'0';
		}
	}
	else{
		for(auto &x:ask[p]){
			int a=x[0],b=x[1],id=x[2];
			ans[id]=(a==b)?'1':'0';
		}
	}
	ask[p].clear();
}
void sol(){
	sci(n),sci(l),sci(q);
	rep(i,1,n)par[i]=i;
	rep(i,1,l){
		scanf("%s",s+1);
		for(int j=1;j<=2*n;j+=2){
			to[i][(j+1)/2]=f(s[j],s[j+1]);
			//printf("%d ",to[i][(j+1)/2]);
		}
		//puts("");
	}
	c=0;
	rep(i,1,q){
		scanf("%s",s+1);
		int a=f(s[1],s[2]),b=f(s[3],s[4]),p=f(s[5],s[6]);
		//printf("%d %d %d\n",a,b,c);
		ask[p].pb({a,b,i});
	}
	rep(i,0,l){
		solve<1>(i);
	}
	ans[q+1]='\0';
	printf("%s\n",ans+1);
}
int main(){
	//freopen("24L.in","r",stdin);
	//freopen("2024L.out","w",stdout);
	rep(i,0,5000){
		int x=48+(i/50),y=48+(i%50);
		g[x][y]=i;
	}
	int T;
	sci(T); // t=1
	while(T--){
		sol();
	}
	return 0;
}

代码2（bfs+队列实现最短路）

*bulijiojiodibuliduo代码

需要保证无向图转有向图那里的边数量不能太多，

比如，如果每行都全是无向图的边的话，已经连过的边，后面就不需要再连了，

所以用并查集去控制一下这块的边的数量，只有触发merge的才需要加边

后面就是bfs+距离队列实现最短路

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
typedef vector<int> VI;
typedef basic_string<int> BI;
typedef long long ll;
typedef pair<int,int> PII;
typedef double db;
mt19937 mrand(random_device{}()); 
const ll mod=1000000007;
int rnd(int x) { return mrand() % x;}
ll powmod(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
// head

const int N=2010;
int n,l,q,f[N],g[N],vis[N],dis[N],pc[N],qc[N][N],ans[N][N];
vector<PII> e[N];
string s;
int find(int x)  {
	return f[x]==x?x:f[x]=find(f[x]);
}
void solve() {
	cin>>n>>l>>q;
	rep(j,0,n) f[j]=j,e[j].clear();
	rep(i,1,l+1) {
		cin>>s;
		rep(j,0,n) vis[j]=0;
		rep(j,0,n) {
			g[j]=(s[j*2]-'0')*50+(s[j*2+1]-'0')-1;
			vis[g[j]]+=1;
		}
		int sz=0;
		rep(j,0,n) sz+=vis[j]!=0;
		if (sz<=n-2) continue;
		if (sz==n) {
			rep(j,0,n) {
				if (find(j)!=find(g[j])) {
					f[find(j)]=find(g[j]);
					e[j].pb(mp(g[j],i));
					e[g[j]].pb(mp(j,i));
				}
			}
		} else {
			int mc2=-1,mc0=-1;
			rep(j,0,n) {
				if (vis[j]==2) mc2=j;
				if (vis[j]==0) mc0=j;
			}
			assert(mc2!=-1&&mc0!=-1);
			rep(j,0,n) if (g[j]==mc2) e[j].pb(mp(mc0,i));
		}
	}
	rep(S,0,n) {
		rep(i,0,l+1) pc[i]=0;
		rep(i,0,n) dis[i]=1<<30,vis[i]=0;
		dis[S]=0;
		qc[0][pc[0]++]=S;
		rep(rd,0,l+1) {
			rep(i,0,pc[rd]) {
				int u=qc[rd][i];
				if (vis[u]) continue;
				vis[u]=1;
				for (auto [v,w]:e[u]) {
					if (dis[v]>max(dis[u],w)) {
						dis[v]=max(dis[u],w);
						qc[dis[v]][pc[dis[v]]++]=v;
					}
				}
			}
		}
		rep(i,0,n) ans[S][i]=dis[i];
	}
	string ret;
	rep(i,0,q) {
		cin>>s;
		rep(j,0,3) g[j]=(s[j*2]-'0')*50+(s[j*2+1]-'0')-1;
		//g[0]--; g[1]--;
		g[2]++;
		if (ans[g[0]][g[1]]<=g[2]) ret.pb('1'); else ret.pb('0');
	}
	cout<<ret<<"\n";

}

int _;
int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	for (cin>>_;_;_--) {
		solve();
	}
}