[NOI2018]归程

最新推荐文章于 2022-03-17 17:09:32 发布

StaroForgin

最新推荐文章于 2022-03-17 17:09:32 发布

阅读量207

点赞数 1

分类专栏： # 树 ------图论------

本文链接：https://blog.csdn.net/Tan_tan_tann/article/details/109270436

版权

------图论------ 同时被 2 个专栏收录

101 篇文章 0 订阅

订阅专栏

树

57 篇文章 0 订阅

订阅专栏

归程

题解

~~挺好想的一道题~~

很容易想到，由于一辆车只能在没有积水的路面上行驶，答案就是它所在的连通块中所有点距号节点的最小值。

如果每次询问都来缩一次点的话明显会T掉，而它每次询问的积水线又是不同的，我们考虑如何维护连通块的海拔。

由于海拔越高能满足的肯定越多，我们就想到了通过海拔构建一棵最小生成树，当查询为 (p,v) 时就是查询大于海拔的路构成的生成树上点所在的联通块的最小距点的距离。很明显，如果可以离线下来做的话这个问题很快就解决了，可是它又要求强制在线，考虑如何在线维护并查集。

可持久化的并查集明显是个很好的选择，但是笔者并没有打可持久化并查集。我们可以在连接两个节点祖先的并查集时建一个新点，其点权为当前边的海拔，作为这两个节点祖先的父亲。很容易发现，在我们连接得到的这棵二叉树上，从叶子节点到祖先节点的路径上，点权是递减的。我们可以通过倍增维护一条路径上的点权，找到深度最小的点权大于的祖先。那么，它的子树上到点距离最短的点就是我们停车的点，而这距离可以在dfs的过程中维护到每个点上。

至于每个点到点的距离可以通过dijkstra预处理出来。

时间复杂度 $O\left((n+m)log_{n} \right )$ 。

源码

#include<cstdio>
#include<cmath>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<set>
using namespace std;
#define MAXN 400005
const int INF=0x7f7f7f7f;
typedef long long LL;
typedef unsigned long long uLL;
typedef pair<int,int> pii;
template<typename _T>
_T Fabs(_T x){return x<0?-x:x;}
template<typename _T>
void read(_T &x){
	_T f=1;x=0;char s=getchar();
	while(s>'9'||s<'0'){if(s=='-')f=-1;s=getchar();}
	while('0'<=s&&s<='9'){x=(x<<3)+(x<<1)+(s^48);s=getchar();}
	x*=f;
}
int n,m,head[MAXN],tot,q,t,fa[MAXN],cnt;
int dis[MAXN],val[MAXN],minn[MAXN],f[MAXN][20];
LL k,s;
struct ming{int u,v,l,a;}a[MAXN];
struct edge{int to,nxt;}e[MAXN<<1];
vector<pii> G[MAXN];
struct tann{
	int id,ti;
	bool friend operator < (const tann &x,const tann &y){
		return x.ti>y.ti;
	}
};
void addEdge(int u,int v){e[++tot]=(edge){v,head[u]};head[u]=tot;}
bool cmp(ming x,ming y){return x.a>y.a;}
void makeSet(int x){for(int i=1;i<=x;i++)fa[i]=i;}
int findSet(int x){return fa[x]==x?x:fa[x]=findSet(fa[x]);}
priority_queue<tann> q1;
void dijkstra(){
	while(!q1.empty())q1.pop();
	for(int i=1;i<=n;i++)dis[i]=INF;
	q1.push((tann){1,0});dis[1]=0;
	while(!q1.empty()){
		tann t=q1.top();int u=t.id;q1.pop();
		if(t.ti!=dis[u])continue;int siz=G[u].size();
		//printf("queue%d %d\n",u,dis[u]);
		for(int i=0;i<siz;i++){
			int v=G[u][i].first,w=G[u][i].second;
			if(dis[v]>dis[u]+w)dis[v]=dis[u]+w,q1.push((tann){v,dis[v]});
		}
	}
	for(int i=1;i<=n;i++)minn[i]=dis[i];//,printf("dist%d:%d\n",i,dis[i]);
}
void dfs(int u,int fa){
	f[u][0]=fa;if(u>n)minn[u]=INF;
	for(int i=1;i<20;i++)f[u][i]=f[f[u][i-1]][i-1];
	for(int i=head[u];i;i=e[i].nxt){
		int v=e[i].to;if(v==fa)continue;//printf("%d to %d\n",u,v);
		dfs(v,u);minn[u]=min(minn[u],minn[v]);
	}
	//printf("%d-->%d %d %d\n",fa,u,minn[u],val[u]);
}
int query(int u,int w){
	for(int i=19;i>=0;i--)
		if(val[f[u][i]]>w)
			u=f[u][i];
	//printf("query%d %d %d\n",u,val[u],w);
	return minn[u];
}
signed main(){
	freopen("return.in","r",stdin);
	freopen("return.out","w",stdout);
	read(t);
	while(t--){
		read(n);read(m);cnt=n;tot=0;
		for(int i=1;i<=m;i++){
			read(a[i].u),read(a[i].v),read(a[i].l),read(a[i].a);
			G[a[i].u].push_back(make_pair(a[i].v,a[i].l));
			G[a[i].v].push_back(make_pair(a[i].u,a[i].l));
		}
		dijkstra();sort(a+1,a+m+1,cmp);makeSet(n);
		for(int i=1;i<=n;i++)val[i]=INF;
		for(int i=1;i<=m;i++){
			int u=a[i].u,v=a[i].v,w=a[i].a;
			if((u=findSet(u))==(v=findSet(v)))continue;
			cnt++;fa[cnt]=cnt;fa[u]=fa[v]=cnt;val[cnt]=w;
			//printf("%d-->%d-->%d\n",cnt,u,v);
			addEdge(u,cnt);addEdge(v,cnt);
			addEdge(cnt,u);addEdge(cnt,v);
		}
		int root=0,las=0;
		for(int i=1;i<=cnt;i++)if(fa[i]==i)root=i;
		dfs(root,0);read(q);read(k);read(s);
		for(int i=1;i<=q;i++){
			int p,v;read(v);read(p);
			v=(1ll*v+1ll*k*las-1LL)%n+1;
			p=(1ll*p+1ll*k*las)%(s+1);
			//printf("ask %d %d\n",v,p);
			las=query(v,p);printf("%d\n",las);
		}
		for(int i=1;i<=n;i++)G[i].clear();
		for(int i=1;i<=cnt;i++)head[i]=0;
		memset(f,0,sizeof(f));
	}
	return 0;
}