本题的故事发生在魔力之都，在这里我们将为你介绍一些必要的设定。 魔力之都可以抽象成一个n 个节点、m 条边的无向连通图（节点的编号从 1至 n）。我们依次用 l,a描述一条边的长度、海拔。 作为季风气候的代表城市，魔力之都时常有雨水相伴，因此道路积水总是不可避免 的。由于整个城市的排水系统连通，因此有积水的边一定是海拔相对最低的一些边。我们用水位线来描述降雨的程度，它的意义是：所有海拔不超过水位线的边都是有积水的。
Yazid 是一名来自魔力之都的OIer，刚参加完ION2018 的他将踏上归程，回到他 温暖的家。 Yazid 的家恰好在魔力之都的 1 号节点。对于接下来 Q天，每一天Yazid 都会告诉你他的出发点 v，以及当天的水位线 p 。 每一天，Yazid 在出发点都拥有一辆车。这辆车由于一些故障不能经过有积水的边。 Yazid 可以在任意节点下车，这样接下来他就可以步行经过有积水的边。但车会被留在他下车的节点并不会再被使用。 需要特殊说明的是，第二天车会被重置，这意味着：
- 车会在新的出发点被准备好。
- Yazid 不能利用之前在某处停放的车。 Yazid 非常讨厌在雨天步行，因此他希望在完成回家这一目标的同时，最小化他步行经过的边的总长度。请你帮助 Yazid 进行计算。 本题的部分测试点将强制在线，具体细节请见【输入格式】和【子任务】。
-
输入输出格式
输入格式：
单个测试点中包含多组数据。输入的第一行为一个非负整数 T ，表示数据的组数。
接下来依次描述每组数据，对于每组数据：
第一行 2 个非负整数 n,m分别表示节点数、边数。
接下来 m 行，每行 4 个正整数 u,v,l,a描述一条连接节点 u,v 的、长度为 l、海拔为 a 的边。 在这里，我们保证 1≤u,v≤n 。
接下来一行 3 个非负数 Q,K,S其中 Q 表示总天数， K∈0,1 是一个会在下面被用到的系数， S 表示的是可能的最高水位线。
接下来 Q 行依次描述每天的状况。每行 2 个整数 v0;p0 描述一天：
这一天的出发节点为 v=(v0+K×lastans−1)modn+1。
这一天的水位线为 p=(p0+K×lastans)mod(S+1)。
其中 lastans 表示上一天的答案（最小步行总路程）。特别地，我们规定第 1 天时 lastans = 0。 在这里，我们保证 1≤v0≤n,0≤p0≤S1 。
对于输入中的每一行，如果该行包含多个数，则用单个空格将它们隔开。
输出格式：
依次输出各组数据的答案。对于每组数据：
- 输出 Q行每行一个整数，依次表示每天的最小步行总路程。
-
输入输出样例
输入样例#1：
1
4 3
1 2 50 1
2 3 100 2
3 4 50 1
5 0 2
3 0
2 1
4 1
3 1
3 2
输出样例#1：
0
50
200
50
150
输入样例#2：
1
5 5
1 2 1 2
2 3 1 2
4 3 1 2
5 3 1 2
1 5 2 1
4 1 3
5 1
5 2
2 0
4 0
输出样例#2：
0
2
3
1
说明
【样例1 解释】 第一天没有降水，Yazid 可以坐车直接回到家中。
第二天、第三天、第四天的积水情况相同，均为连接1; 2 号节点的边、连接3; 4 号 点的边有积水。
对于第二天，Yazid 从2 号点出发坐车只能去往3 号节点，对回家没有帮助。因此 Yazid 只能纯靠徒步回家。
对于第三天，从4 号节点出发的唯一一条边是有积水的，车也就变得无用了。Yazid只能纯靠徒步回家。
对于第四天，Yazid 可以坐车先到达2 号节点，再步行回家。
第五天所有的边都积水了，因此Yazid 只能纯靠徒步回家。
本组数据强制在线。
本组数据强制在线。
第一天的答案是 0 ，因此第二天的 v=(5+0−1)mod5+1=5， p=(2+0)mod(3+1)=2 。
第二天的答案是 2，因此第三天的 v=(2+2−1)mod5+1=4， p=(0+2)mod(3+1)=2 。
第三天的答案是 3 ，因此第四天的 v=(4+3−1)mod5+1=2 ， p=(0+3)mod(3+1)=3 。
所有测试点均保证 T≤3，所有测试点中的所有数据均满足如下限制：
- 任意两点之间都直接或间接通过边相连。
为了方便你快速理解，我们在表格中使用了一些简单易懂的表述。在此，我们对这些内容作形式化的说明：
- 图形态：对于表格中该项为“一棵树”或“一条链”的测试点，保证m = n-1。 除此之外，这两类测试点分别满足如下限制：
- 一棵树：保证输入的图是一棵树，即保证边不会构成回路。
- 一条链：保证所有边满足u + 1 = v。
- 海拔：对于表格中该项为“一种”的测试点，保证对于所有边有a = 1。
- 强制在线：对于表格中该项为“是”的测试点，保证K = 1；如果该项为“否”， 则有K = 0。
- 对于所有测试点，如果上述对应项为“不保证”，则对该项内容不作任何保证。
-
soulution
正解好像是什么克鲁斯卡尔重构树吧，身为蒟蒻的我表示不会，从网上看到了可持久化并查集，仔细想了一下好像是可以做。
那么如何运用可持久化并查集来过这道题呢？
首先，题目要求最小步行路程到一点，而每次出发点和水位线不同，水位大于等于边的海拔都要被淹掉，也就是不能开车，由此可以想到并查集，判断每个点和哪些点是否联通，在判断这个联通块里的点哪个点距离１点最近，最短路可以预处理出来，听说SPFA炸了，在这里我用dijkstra。
但每次水位线都不一样，而且强制在线，我们可以想到用可持久化并查集。每次询问一个水位线，运用二分找到当前并查集，直接查询就可以了。复杂度(nlog^2n)
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
typedef long long ll;
typedef pair<int,int> pr;
priority_queue<pr,vector<pr>,greater<pr> >kk;//dijstra堆优化
struct TREE
{
ll ln,rn;
}t[15001000];
struct node
{
ll to,next,w,h;
}a[800100];
struct bian
{
ll x,y,z,w;
bool operator< (const bian &c) const
{
return w>c.w;
}
}p[1001000];
ll last[500100],len,d[500001],vis[501000],tot,root[501000],fa[10100000],dep[10001000];//dep[]表示当前并查集深度，为了按秩合并，mn存下当前并查集哪个点到１点最近。
ll hash[501000],mn[10001000];
ll n,m,q,k,s;
ll read()
{
ll x=0,flag=1;char ch=getchar();
while(ch<'0'||ch>'9') {if(ch=='-') flag=-1;ch=getchar();}
while(ch>='0'&&ch<='9') x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
return x*flag;
}
void add(ll a1,ll a2,ll a3,ll a4)
{
a[++len].to=a2;
a[len].w=a3;
a[len].h=a4;
a[len].next=last[a1];
last[a1]=len;
}
ll lastans=0;
void build(ll &node,ll l,ll r)
{
node=++tot;
ll mid=(l+r)/2;
if(l==r) {fa[node]=l;mn[node]=d[l];dep[node]=1;return;}
build(t[node].ln,l,mid);
build(t[node].rn,mid+1,r);
}
ll getpos(ll node,ll l,ll r,ll x)
{
if(l==r) return node;
ll mid=(l+r)/2;
if(x<=mid) return getpos(t[node].ln,l,mid,x);
else return getpos(t[node].rn,mid+1,r,x);
}
ll getfa(ll node,ll x)
{
ll p=getpos(node,1,n,x);
if(fa[p]==x) return p;
else return getfa(node,fa[p]);
}
void gai(ll &node,ll last,ll l,ll r,ll x,ll y)
{
node=++tot;
if(l==r) {fa[node]=y;dep[node]=dep[last];mn[node]=mn[last];return;}
t[node]=t[last];
ll mid=(l+r)/2;
if(x<=mid) gai(t[node].ln,t[last].ln,l,mid,x,y);
else gai(t[node].rn,t[last].rn,mid+1,r,x,y);
}
void xiu(ll node,ll l,ll r,ll x)
{
if(l==r) {dep[node]++;return;}
ll mid=(l+r)/2;
if(x<=mid) xiu(t[node].ln,l,mid,x);
else xiu(t[node].rn,mid+1,r,x);
}
ll minn(ll x,ll y)
{
if(x>y) return y;
return x;
}
void gai1(ll &node,ll last,ll l,ll r,ll x)
{
node=++tot;
if(l==r) {mn[node]=mn[last];fa[node]=fa[last];dep[node]=dep[last];return;}
t[node]=t[last];
ll mid=(l+r)/2;
if(x<=mid) gai1(t[node].ln,t[last].ln,l,mid,x);
else gai1(t[node].rn,t[last].rn,mid+1,r,x);
}
void merge(ll x,ll y,ll i)//合并并查集
{
if(dep[x]>dep[y]) swap(x,y);
gai(root[i],root[i-1],1,n,fa[x],fa[y]);
//很重要的两步，第一次修fa[x],第二次修改y的mn.
gai1(root[i],root[i],1,n,fa[y]);
ll orz=getpos(root[i],1,n,fa[y]);
ll sto=getpos(root[i],1,n,fa[x]);
mn[orz]=minn(mn[orz],mn[sto]);
if(dep[x]==dep[y]) xiu(root[i],1,n,fa[y]);
}
void spfa()//dijkstra
{
for(ll i=1;i<=n;i++)
d[i]=1000000000000;
d[1]=0;
kk.push((pr){0,1});
while(!kk.empty())
{
ll k=kk.top().second;
kk.pop();
if(vis[k]) continue;
vis[k]=1;
for(ll i=last[k];i;i=a[i].next)
{
ll to=a[i].to;
if(d[to]>d[k]+a[i].w)
{
d[to]=d[k]+a[i].w;
kk.push((pr){d[to],to});
}
}
}
}
int main()
{
ll t;
cin>>t;
while(t--)
{
memset(vis,0,sizeof(vis));
memset(root,0,sizeof(root));tot=0;
lastans=0;
len=0;memset(last,0,sizeof(last));
n=read();m=read();
for(ll i=1;i<=m;i++)
{
p[i].x=read();p[i].y=read();p[i].z=read();p[i].w=read();
add(p[i].x,p[i].y,p[i].z,p[i].w);add(p[i].y,p[i].x,p[i].z,p[i].w);
}
sort(p+1,p+1+m);
for(int i=1;i<=m;i++)
hash[i]=p[m-i+1].w;
q=read();k=read();s=read();
spfa();//之前spfa炸了，没改函数名
build(root[0],1,n);
for(ll i=1;i<=m;i++)
{
root[i]=root[i-1];
ll x=p[i].x,y=p[i].y;
x=getfa(root[i],x);y=getfa(root[i],y);
if(fa[x]!=fa[y]) merge(x,y,i);
}
for(ll i=1;i<=q;i++)
{
ll x,y;
scanf("%lld%lld",&x,&y);
x=(x+k*lastans-1)%n+1;
y=(y+k*lastans)%(s+1);
int tt=m-(upper_bound(hash+1,hash+1+m,y)-hash)+1;
int orz=getfa(root[tt],x);
printf("%lld
",lastans=mn[orz]);
}
}
return 0;
}
复杂度有点高，洛谷上最后一个点跑3.7秒。