【XSY2418】修路（最短路图，支配）

首先可以 $O(m\log n)$ 按题意把树建出来，显然这是一棵最短路图的生成树。

那么询问 $u,v$ 相当于在树上 $(u,v)$ 路径上找到深度最深的一点 $w$，满足最短路图中刨掉树上路径 $(u,w)$ 上的边后仍有从根到达 $v$ 的路径。

考虑处理出 $f(u)$ 表示 $u$ 深度最浅的祖先满足 $f(u)$ 能通过非树上路径 $(f(u),u)$ 上的边在最短路图中到达 $u$。

在最短路图上使用拓扑排序从非树边转移即可得到 $f(u)$。

那么每次询问 $u,v$ 相当于在树上 $(u,v)$ 路径上找到深度最深的一个点 $w$，满足 $d_{f(w)}\le d_u$。使用倍增维护 $d$ 的最小值即可。

时间复杂度 $O((n+m+q)\log n)$。

#include<bits/stdc++.h>

#define LN 17
#define N 100010
#define M 200010
#define ll long long
#define INF 0x7fffffff

using namespace std;

inline int read()
{
	int x=0,f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9')
	{
		if(ch=='-') f=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9')
	{
		x=(x<<1)+(x<<3)+(ch^'0');
		ch=getchar();
	}
	return x*f;
}

int node;
int n,m,s,ty;

namespace Tree
{
	int cnt,head[N],to[N],nxt[N];
	int d[N],fa[N][LN];
	int minn[N][LN];
	void adde(int u,int v)
	{
		to[++cnt]=v;
		nxt[cnt]=head[u];
		head[u]=cnt;
	}
	void dfs(int u)
	{
		for(int i=1;i<=16;i++)
			fa[u][i]=fa[fa[u][i-1]][i-1];
		for(int i=head[u];i;i=nxt[i])
		{
			int v=to[i];
			fa[v][0]=u,d[v]=d[u]+1;
			dfs(v);
		}
	}
	void init()
	{
		d[s]=1;
		dfs(s);
		for(int i=0;i<=16;i++) minn[0][i]=INF;
	}
	void initf(int u,int val)
	{
		minn[u][0]=val;
		for(int i=1;i<=16;i++)
			minn[u][i]=min(minn[u][i-1],minn[fa[u][i-1]][i-1]);
	}
	int getlca(int a,int b)
	{
		if(d[a]<d[b]) swap(a,b);
		for(int i=16;i>=0;i--)
			if(d[fa[a][i]]>=d[b])
				a=fa[a][i];
		if(a==b) return a;
		for(int i=16;i>=0;i--)
			if(fa[a][i]!=fa[b][i])
				a=fa[a][i],b=fa[b][i];
		return fa[a][0];
	}
	int getmin(int u,int f)
	{
		int ans=INF;
		for(int i=16;i>=0;i--)
			if(d[fa[u][i]]>=d[f])
				ans=min(ans,minn[u][i]),u=fa[u][i];
		return min(ans,minn[u][0]);
	}
	int query(int f,int u)
	{
		for(int i=16;i>=0;i--)
			if(d[fa[u][i]]>=d[f]&&minn[u][i]>d[f])
				u=fa[u][i];
		return d[u]-d[f];
	}
}

namespace DAG
{
	int cnt,head[N],to[M],nxt[M];
	int du[N];
	int f[N];
	void adde(int u,int v)
	{
		du[v]++;
		to[++cnt]=v;
		nxt[cnt]=head[u];
		head[u]=cnt;
	}
	queue<int>q;
	void main()
	{
		for(int i=1;i<=n;i++) f[i]=Tree::d[i];
		q.push(s);
		while(!q.empty())
		{
			int u=q.front();
			q.pop();
			Tree::initf(u,f[u]);
			for(int i=head[u];i;i=nxt[i])
			{
				int v=to[i];
				if(Tree::fa[v][0]!=u)
				{
					int lca=Tree::getlca(u,v);
					f[v]=min(f[v],Tree::getmin(u,lca));
				}
				du[v]--;
				if(!du[v]) q.push(v);
			}
		}
	}
}

namespace Graph
{
	int p[N];
	int cnt,head[N],nxt[M<<1],to[M<<1],w[M<<1];
	ll dis[N];
	void adde(int u,int v,int wi)
	{
		to[++cnt]=v;
		w[cnt]=wi;
		nxt[cnt]=head[u];
		head[u]=cnt;
	}
	namespace Dijkstra
	{
		struct data
		{
			int u;ll s;
			data(){};
			data(int a,ll b){u=a,s=b;}
			bool operator < (const data &a) const
			{
				return s>a.s;
			}
		};
		priority_queue<data>q;
		bool vis[N];
		void main()
		{
			memset(dis,127,sizeof(dis));
			dis[s]=0;
			q.push(data(s,0));
			while(!q.empty())
			{
				data now=q.top();
				q.pop();
				if(vis[now.u]) continue;
				vis[now.u]=1;
				for(int i=head[now.u];i;i=nxt[i])
				{
					int v=to[i];
					if(dis[now.u]+w[i]<dis[v])
					{
						dis[v]=dis[now.u]+w[i];
						q.push(data(v,dis[v]));
					}
				}
			}
		}
	}
	struct data
	{
		int v,p;
		data(){};
		data(int a,int b){v=a,p=b;}
		bool operator < (const data &a) const
		{
			return p>a.p;
		}
	};
	bool vis[N];
	priority_queue<data>q[N];
	void dfs(int u)
	{
		vis[u]=1;
		for(int i=head[u];i;i=nxt[i])
		{
			int v=to[i];
			if(dis[u]+w[i]==dis[v])
				q[u].push(data(v,p[v]));
		}
		while(!q[u].empty())
		{
			data now=q[u].top();
			q[u].pop();
			DAG::adde(u,now.v);
			if(vis[now.v]) continue;
			Tree::adde(u,now.v);
			dfs(now.v);
		}
	}
	void main()
	{
		for(int i=1;i<=n;i++) p[i]=read();
		for(int i=1;i<=m;i++)
		{
			int u=read(),v=read(),w=read();
			adde(u,v,w),adde(v,u,w);
		}
		Dijkstra::main();
		dfs(s);
	}
}

int main()
{
	n=read(),m=read(),s=read(),ty=read();
	Graph::main();
	Tree::init();
	DAG::main();
	int q=read(),lans=0;
	while(q--)
	{
		int u=read(),v=read();
		if(ty) u^=lans,v^=lans;
		printf("%d\n",lans=Tree::query(u,v));
	}
	return 0;
}