Problem
给一张图，每条边有两个参数:(w,h),分别代表边长与海拔
有Q个询问，每次询问从给定点出发,借助一辆只能走海拔大于h的边的车后,到一号点最短步行的距离。
Solution
正解是(kruskal)重构树,很好理解，也很好打，网上题解很多，这里就不讲了
下面我们讲一下一个需吸氧且随缘(T)点的做法
可持久化并查集
有没有感觉十分高端大气上档次？
表示没有
之前上网看过这中算法，但是一直没有看懂
问右边大佬这个是怎么实现的
结果
右边大佬:啊？……不就是可持久化那样搞一下……按质合并……就可以了吗？
本(caiji)表示听不懂……
后来跑到隔壁的时候(Na_2S_2O_3 zbr)提了一嘴
(Na_2S_2O_3):你别(fake)啰
(caiji):我是真不会
(zbr):啊？就是拿个可持久化数组维护一下并查集就可以了啊
(caiji):可持久化数组是什么？
(Na_2S_2O_3):就是用主席树维护一个数组啊……
(恍然大雾.jpg)
咳咳，跑题了。
现在来讲一讲这道题
先考虑离线，就是先跑一边最短路
询问与边都按从大到小排序，然后每次询问倒序进去的时候按比海拔高的约束加入能开车的边，
这个东西可以用并查集维护。
每次维护这个联通块中到一号点的最小距离，直接输出就好了。
接下来就是在线了
某位伟大的博士曾说过
勇矢博士:所有可离线做的问题都可以用可持久化数据结构在线做。
好像很有道理……
所以我们这道题可以用可持久化并查集……
对于每个询问，我们只需回到没有添加海拔比(q)小的路的版本，再查询(v)所在的联通块即可
复杂度(O(n(logn)^2))
卡卡常，好像能过个鬼
拷了个海波的快输还是T了两点
Code
#include<bits/stdc++.h>
#define mp make_pair
#define fst first
#define snd second
#define LL long long
#define pli pair<LL,int>
#define pii pair<int,int>
using namespace std;
inline int read(){
int res = 0, fl = 1;
char r = getchar();
for (; !isdigit(r); r = getchar()) if(r == '-') fl = -1;
for (; isdigit(r); r = getchar()) res = (res << 3) + (res << 1) + r - 48;
return res * fl;
}
char _obuf[1 << 20], _stk[20];
class Ostream
{
char *opos, *oend, *stkpos;
public :
Ostream()
{
oend = (opos = _obuf) + (1 << 20);
stkpos = _stk;
}
~Ostream()
{ fwrite(_obuf, 1, opos - _obuf, stdout); }
void Putchar(char ch)
{
*opos++ = ch;
if(opos == oend)
{
fwrite(_obuf, 1, 1 << 20, stdout);
opos = _obuf;
}
}
Ostream& operator<<(int n)
{
do
{
*++stkpos = n % 10 ^ 48;
n /= 10;
} while(n);
while(stkpos != _stk)
Putchar(*stkpos--);
return *this;
}
Ostream& operator<<(char c)
{
Putchar(c);
return *this;
}
Ostream& operator<<(const char* str)
{
while(*str != ' ')
Putchar(*str++);
return *this;
}
} out;
inline void chkmin(int &A, int &B) { A = min(A, B);}
inline void chkmax(int &A, int &B) { A = max(A, B);}
const int Maxm = 4e5 + 10, Maxn = 2e5 + 10;
vector <pii> g[Maxn];
struct node{
int u, v, h;
bool operator < (const node A) const{ return h > A.h;}
}Map[Maxm];
int n, m, Q, K, S, ans;
int root[Maxn], dis[Maxn];
namespace CMT{
#define mid ((l + r) >> 1)
int ls[Maxn << 6], rs[Maxn << 6], cnt, root[Maxm << 2], Tim;
struct TRE{
int fa, siz, dis;
}tre[Maxn << 6];
inline void build(int &rt, int l, int r){
rt = ++cnt;
if(l == r) {tre[rt].fa = l, tre[rt].siz = 1, tre[rt].dis = dis[l]; return;}
build(ls[rt], l, mid);
build(rs[rt], mid + 1, r);
}
inline void Init(){ cnt = 0; build(root[1], 1, n); Tim = 0;}
inline int Query(int Begin, int rt, int l, int r, int pos){
if(l == r){return tre[rt].fa == l ? rt : Query(Begin, Begin, 1, n, tre[rt].fa);}
if(mid >= pos) return Query(Begin, ls[rt], l, mid, pos);
else return Query(Begin, rs[rt], mid + 1, r, pos);
}
inline void Modify_fa(int grt, int &rt, int l, int r, int pos, int fa){
rt = ++cnt, ls[rt] = ls[grt], rs[rt] = rs[grt], tre[rt] = tre[grt];
if(l == r) { tre[rt].fa = fa; return;}
if(mid >= pos) Modify_fa(ls[grt], ls[rt], l, mid, pos, fa);
else Modify_fa(rs[grt], rs[rt], mid + 1, r, pos, fa);
}
inline void Modify(int grt, int &rt, int l, int r, int pos, int siz, int Dis){
rt = ++cnt, ls[rt] = ls[grt], rs[rt] = rs[grt], tre[rt] = tre[grt];
if(l == r){
tre[rt].siz += siz, chkmin(tre[rt].dis, Dis);
return;
}
if(mid >= pos) Modify(ls[grt], ls[rt], l, mid, pos, siz, Dis);
else Modify(rs[grt], rs[rt], mid + 1, r, pos, siz, Dis);
}
inline int link(int u, int v){
register int rfu = Query(root[Tim << 1 | 1], root[Tim << 1 | 1], 1, n, u);
register int rfv = Query(root[Tim << 1 | 1], root[Tim << 1 | 1], 1, n, v);
if(tre[rfu].fa == tre[rfv].fa) return 0;
Tim++;
if(tre[rfu].siz > tre[rfv].siz) swap(rfu, rfv);
Modify_fa(root[(Tim << 1) - 1], root[Tim << 1], 1, n, tre[rfu].fa, tre[rfv].fa);
Modify(root[Tim << 1], root[Tim << 1 | 1], 1, n, tre[rfv].fa, tre[rfu].siz, tre[rfu].dis);
return Tim << 1 | 1;
}
inline LL Query_dis(int Time, int v){
return tre[Query(root[Time], root[Time], 1, n, v)].dis;
}
#undef mid
}
bitset<Maxn> vis, clean;
inline void dijstra(){
priority_queue <pii> Q;
memset(dis, 0x3f, sizeof dis);
vis = clean;
Q.push(mp(0, 1));
dis[1] = 0;
while(!Q.empty()){
register int now = Q.top().snd;
Q.pop();
if(vis[now]) continue;
vis[now] = 1;
for (register int i = g[now].size() - 1; i >= 0; --i){
register int nxt = g[now][i].fst;
if(dis[nxt] > dis[now] + g[now][i].snd)
dis[nxt] = dis[now] + g[now][i].snd,
Q.push(mp(-dis[nxt], nxt));
}
}
}
set<pii> Tim;
inline void work(int &T){
n = read(), m = read(), ans = 0;
for (register int i = 1; i <= m; ++i){
register int u = read(), v = read(), w = read(), h = read();
Map[i] = (node){u, v, h};
g[u].push_back(mp(v, w));
g[v].push_back(mp(u, w));
}
dijstra();
sort(Map + 1, Map + 1 + m);
CMT::Init();
for (register int i = 1; i <= m; ++i){
register int u = Map[i].u, v = Map[i].v;
register int TIME = CMT::link(u, v);
if(TIME)
Tim.insert(mp(Map[i].h, -TIME));
}
Q = read(), K = read(), S = read();
Tim.insert(mp(S + 1, -1));
Tim.insert(mp(0, -(CMT::Tim << 1 | 1)));
while(Q--){
register int v = ((LL)read() + K * ans - 1) % n + 1;
register int p = ((LL)read() + K * ans) % (S + 1);
pii Time = *Tim.upper_bound(mp(p, 1e9));
ans = CMT::Query_dis(-Time.snd, v);
out << ans << '
';
}
if(T) Tim.clear();
if(T) for (register int i = 1; i <= n; ++i) g[i].clear();
}
int main(){
freopen("a.in","r",stdin);
freopen("a.out","w",stdout);
int T = read();
while(T--) work(T);
return 0;
}