[NOI2018]归程 kruskal重构树

～～～题面～～～

题解：

　　此题可以用可持久化并查集暴力水过，但正解是kruskal重构树。

　　不会kruskal重构树请戳：kruskal重构树

　　观察到车可以通过哪些边跟边的长度并没有关系，所以考虑用边的海拔排序建出重构树，这样我们就得到了一个只跟海拔相关的关系。

　　于是对于任意水位线，我们都可以得知，在不超过这个水位线的情况下我们可以到达哪些点，也就是哪些点可以使用车子到达，既然我们已经可以知道这个东西了，显然我们只需要在这些点中找到使得步行距离最短的点即可。

　　因为要使得步行路径最短，所以要先预处理出每个点到1的最短路，然后每个点的点权就是它到1号节点的最短路了，然后每次查询的时候，不断倍增向上跳，直到水位线超过海拔就停下，因为重构树的特性，所有可以到达的节点都会在你当前停下的这个点下面（属于这个点的子树），

　　因此我们找到了这个停下的节点，就已经知道我们可以到达哪些点了，这个时候我们要做的就是查询这个节点管理的叶子节点内权值最小的那个，这个可以在预处理倍增数组的时候用树形DP求出来，每个节点的点权即当前节点子树内的权值最小值。

　　于是对于每次查询，我们只需要倍增找到对应的停下节点，然后查询这个节点的点权即可。

 

#include<bits/stdc++.h>
using namespace std;
#define R register int
#define AC 300100
#define ac 800100

int n, m, cnt;
int s[AC * 2], g[AC * 2], belong[AC * 2], dis[AC];
int f[AC * 2][23];
int Head[AC * 2], Next[ac], date[ac], len[ac], tot;
int Head2[AC * 2], Next2[ac], date2[ac], tot2;
bool vis[AC];

struct road{
    int x, y, high;
}way[ac];

struct node{
    int x, dis;
};

struct cmp{
    bool operator () (node a, node b)
    {
        return a.dis > b.dis;
    }
};

priority_queue<node, vector<node>, cmp> q;

inline int read()
{
    int x = 0;char c = getchar();
    while(c > '9' || c < '0') c = getchar();
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x;
}

inline void add(int f, int w, int S)
{
    date[++tot] = w, Next[tot] = Head[f], Head[f] = tot, len[tot] = S;
    date[++tot] = f, Next[tot] = Head[w], Head[w] = tot, len[tot] = S;
}

inline int Min(int a, int b)
{
    if(a < b) return a;
    else return b;
}

inline void upmin(int &a, int b)
{
    if(b < a) a = b;
}

inline bool cmp1(road a, road b)
{
    return a.high > b.high;
}

#define date date2
#define Next Next2
#define tot tot2
#define Head Head2

inline void add2(int f, int w)
{
    date[++tot] = w, Next[tot] = Head[f], Head[f] = tot, belong[w] = f;
}

void dfs(int x)
{
    int now;
    g[x] = INT_MAX;
    for(R i = 1; i <= 22; i ++)
        f[x][i] = f[f[x][i - 1]][i - 1];
    if(x <= n) g[x] = dis[x];
    for(R i = Head[x]; i; i = Next[i])
    {
        now = date[i];
        //if(f[x][0] == now) continue;
        f[now][0] = x;
        dfs(now);
        upmin(g[x], g[now]);
    }
}

#undef date
#undef Next
#undef tot
#undef Head

void init()
{
    memset(Head, 0, sizeof(Head));
    memset(Head2, 0, sizeof(Head2));
    memset(dis, 127, sizeof(dis));
    //memset(g, 127, sizeof(g));
    memset(vis, 0, sizeof(vis));
    tot = tot2 = 0;
    //memset(f, 0, sizeof(f));
}

void pre()
{
    n = cnt = read(), m = read();
    for(R i = 1; i <= m; i ++)
    {
        int a = read(), b = read(), c = read(), d = read();
        way[i] = (road){a, b, d};
        add(a, b, c);
    }
    sort(way + 1, way + m + 1, cmp1);
}

void dij()
{
    node x; int now;
    dis[1] = 0, q.push((node){1, 0});
    while(!q.empty())
    {
        x = q.top(), q.pop();
        while(vis[x.x] && !q.empty()) x = q.top(), q.pop();
        vis[x.x] = true;
        for(R i = Head[x.x]; i; i = Next[i])
        {
            now = date[i];
            if(dis[now] > dis[x.x] + len[i])
            {
                dis[now] = dis[x.x] + len[i];
                q.push((node){now, dis[now]});
            }
        }
    }
}

int find(int x)
{
    if(belong[x] == x) return x;
    else return belong[x] = find(belong[x]);
}

void build()
{
    int b = n + n;
    for(R i = 1; i <= b; i ++) belong[i] = i;
    for(R i = 1; i <= m; i ++)
    {
        int fx = find(way[i].x), fy = find(way[i].y);
        if(fx == fy) continue;
        s[++cnt] = way[i].high;
        add2(cnt, fx), add2(cnt, fy);
    }
    for(R i = 0; i <= 22; i ++) f[cnt][i] = 0;
}

int jump(int x, int d)
{
    for(R i = 22; i >= 0; i--)
        if(s[f[x][i]] > d) x = f[x][i];
    return g[x];
}

void work()
{
    int now = 0, all = read(), k = read(), tt = read();
    for(R i = 1; i <= all; i ++)
    {
        int a = read(), b = read();
        a = (a + k * now - 1) % n + 1;
        b = (b + k * now) % (tt + 1);
        printf("%d\n", now = jump(a, b));
    }
}

int main()
{
    freopen("10.in", "r", stdin);
    int T = read();
    while(T --)
    {
        init();//初始化
        pre();//读入
        build();//重构树
        dij();//最短路
        dfs(cnt);//树上倍增
        work();//回答询问
    }
    fclose(stdin);
    return 0;
}