Problem

  給定一個n(≤2∗105)$n(\le 2\ast {10}^5)$個節點、m(≤4∗105)$m(\le 4\ast {10}^5)$條邊的無向連通圖，用l(≤104)$l(\le {10}^4)$,a(≤109)$a(\le {10}^9)$描述一條邊的長度、海拔。
  給定Q(≤4∗105)$Q(\le 4\ast {10}^5)$天，每天給出出發節點v和水位線p。所有海拔**不超過**p的邊都會被淹。Yazid要回到位於1號節點的家。他在點v有輛車，但不能駛過被淹的邊。Yazid 可以在任意節點下車，這樣接下來他就可以步行經過有積水的邊。但車會被留在他下車的節點並不會再被使用。

• 需要特殊說明的是，第二天車會被重置，這意味著：
  
  • 車會在新的出發點被準備好。
  • Yazid 不能利用之前在某處停放的車。

求最小的步行經過的邊的總長度。部分資料強制線上。有多組資料，但資料組數T≤3。

Solution

• 首先，可以以1為起點對原圖做一遍單源最短路，求出所有點到1的dis。據說spfa會被卡，所以宜使用穩定的dijkstra。
• 然後，若我們能求出所有v能到達的點，並知道這些點的dis的min，此問題便迎刃而解。

• 可以使用kruskal重構樹。
• 首先，對所有邊按照海拔從大到小排序。初始化fa陣列，令圖中每個點均為根。
• 順序掃一遍邊集陣列。對於一條u,v間海拔為a的邊，先找出u,v所在子樹的根fu,fv，然後新建一個節點num，令fu為num的左兒子，fv為num的右兒子，且fu、fv連向num的邊的邊權均為a。
• 為加速找根過程，使用並查集優化。

• 經過上述操作，我們就得出一棵二叉樹。顯然，樹上每個節點到根的路徑上的邊權是單調遞減的（我們優先處理了海拔較高的邊）。
• 對於某個詢問v,p，應從v往上走，直至走到不能再走（被水淹了）為止。因為若此時的邊被水淹了，則上面的邊肯定也被水淹了（權值單調遞減）。這樣可以用倍增。
• 設這樣走到的點為x，則Yazid通過開車能且僅能到達以x為根的子樹中的點。可以預先dfs一遍，求出以每個點為根的子樹中所有點的dis的min值。

• 時間複雜度：O(T∗(nlog2n+mα(n)+Q))$O(T\ast (nlo{g}_{2}n+m\alpha (n)+Q))$。

Code

#include <cstdio>
 

#include <cctype>
#include <cstring>
#include <queue>
#include <vector>
#include <algorithm>
#define fo(i,a,b) for(i=a;i<=b;i++)
#define fd(i,a,b) for(i=a;i>=b;i--)
#define clear(a) fo(ii,1,n)a[ii]=0
#define cle(a) memset(a,0,sizeof a)
#define rep(i,x) for(edg *i=x; i; i=i->ne)
#define MIN(x,y) x=min(x,y)
using namespace std;
typedef long long ll;

const int N=4e5+1;
const ll inf=0x7FFFFFFF; 
int T,i,n,m,u,v,a,ii,x,y,num,Q,K,S,v0,p0,p;
ll l,ans,dis[N];
struct edge
{
    int u,v,a;
    ll l;
}e[N];
struct edg
{
    int to;
    ll l;
    edg *ne;
    inline edg(int to,ll l,edg *ne) : to(to), l(l), ne(ne){}
}*fin[N];

template <class T> inline void read(T &x)
{
    char ch=getchar(); x=0;
    for(;!isdigit(ch);ch=getchar());
    for(;isdigit(ch);ch=getchar()) x=(x<<3)+(x<<1)+(ch^48);
}

inline void link(int x,int y)
{
    fin[x]=new edg(y,l,fin[x]);
}

struct node
{
    int i; ll dis;
    inline node(int _i,ll _dis){i=_i; dis=_dis;}
};
struct cmp1
{  
    inline bool operator ()(const node &a,const node &b){return a.dis>b.dis;}  
};  
priority_queue <node,vector<node>,cmp1> P;
bool vis[N];
void dijkstra()
{
    while(!P.empty())P.pop();   P.push(node(1,0));
    clear(vis); 
    memset(dis,127,sizeof dis);   dis[1]=0;

    while(!P.empty())
    {
        node t=P.top(); P.pop();
        int x=t.i; ll d=t.dis;
        if(vis[x]) continue;
        vis[x]=1;
        rep(i,fin[x])
        {
            y=i->to; l=i->l;
            if(!vis[y]&&dis[y]>d+l)
            {
                dis[y]=d+l;
                P.push(node(y,dis[y]));
            }
        }
    }
}

int fa[N],fu,fv,L[N],R[N],anc[N][18],low[N][18];
ll mi[N];
inline bool cmp(edge a,edge b){return a.a>b.a;}
int gef(int x)
{
    return fa[x]==x ? x : fa[x]=gef(fa[x]);
}
void kruskal()
{
    sort(e+1,e+m+1,cmp);
    cle(anc); cle(low); cle(L); cle(R);
    int i;
    fo(i,1,n)fa[i]=i;
    fo(i,1,m)
    {
        u=e[i].u; v=e[i].v;
        fu=gef(u);fv=gef(v);
        if(fu!=fv)
        {
            anc[fu][0]=fa[fu]=anc[fv][0]=fa[fv]=fa[num+1]=++num;
            low[fu][0]=low[fv][0]=e[i].a;
            L[num]=fu; R[num]=fv;
        }
    }
}
void dfs(int x)
{
    int i,f=anc[x][0]; mi[x]=dis[x];
    fo(i,1,17)
    {
        if(!f) break;
        low[x][i]=low[f][i-1];
        f=anc[x][i]=anc[f][i-1];
    }
    if(L[x]) dfs(L[x]), MIN(mi[x],mi[L[x]]);
    if(R[x]) dfs(R[x]), MIN(mi[x],mi[R[x]]);
}

int main()
{
    for(read(T);T;T--)
    {
        read(n); read(m);
        clear(fin);
        fo(i,1,m) 
        {
            read(u), read(v), read(l), read(a);
            e[i].u=u,e[i].v=v,e[i].l=l,e[i].a=a;
            link(u,v); link(v,u);
        }

        dijkstra();

        num=n; kruskal();

        dfs(num);

        read(Q); read(K); read(S); ans=0;
        fo(i,1,Q)
        {
            read(v0); v=(v0+K*ans-1)%n+1;
            read(p0); p=(p0+K*ans)%(S+1);
            fd(ii,17,0) if( anc[v][ii] && low[v][ii]>p ) v=anc[v][ii];
            printf("%lld\n",ans=mi[v]);
        }
    }
}