bzoj 3551 [ONTAK2010]Peaks加强版（kruskal，主席树，dfs序）

 

Description

【题目描述】同3545

Input

第一行三个数N，M，Q。

第二行N个数，第i个数为h_i

接下来M行，每行3个数a b c，表示从a到b有一条困难值为c的双向路径。

接下来Q行，每行三个数v x k，表示一组询问。v=v xor lastans，x=x xor lastans，k=k xor lastans。如果lastans=-1则不变。

 

Output

同3545

 

【思路】

 

       Kruskal+主席树+dfs序

       一个叫kruskal重构树的方法QWQ。在kruskal合并子树的时候新建一个ext结点，然后让它成为两棵子树公共的根，赋边权为权值。

       新建成的树的性质：

 

       对于一个询问，我们找到v的点权值不超过x的最小祖先，以该祖先为根的子树中所有的点与v都满足条件，然后就是在一个子树中找到第k大的问题，可以基于dfs序建主席树处理。

 

 

【代码】

#include<cstdlib>
#include<queue>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define FOR(a,b,c) for(int a=(b);a<=(c);a++)
using namespace std;

typedef long long ll;
const int N = 200005;
const int M = 5100005;
const int D = 17;

struct Edge {
    int u,v,w;
    bool operator < (const Edge& rhs) const {
        return w<rhs.w;
    }
};
struct LEdge { int v,nxt;
};
struct Tnode{
    int lc,rc,sum;
}T[M];

ll read() {
    char c=getchar();
    ll f=1,x=0;
    while(!isdigit(c)) {
        if(c=='-') f=-1; c=getchar();
    }
    while(isdigit(c))
        x=x*10+c-'0',c=getchar();
    return x*f;
}

int n,m,q,sz,tot,dfsc;
int hash[N],h[N],rt[N],val[N],bin[N];
int p[N],dep[N],fa[N][D],mx[N][D],L[N],R[N];

Edge es[N<<1]; LEdge e[N<<1];
int en=-1,front[N];
void adde(int u,int v)
{
    en++; e[en].v=v; e[en].nxt=front[u]; front[u]=en;
}
int ifind(int u)
{
    return u==p[u]? u: p[u]=ifind(p[u]);
}
void update(int l,int r,int x,int& y,int num)
{
    T[y=++sz]=T[x];
    T[y].sum++;
    if(l>=r) return ;
    int mid=(l+r)>>1;
    if(num<=mid) update(l,mid,T[x].lc,T[y].lc,num);
    else update(mid+1,r,T[x].rc,T[y].rc,num);
}
int query(int l,int r,int a,int b,int rk)
{
    int mid=(l+r)>>1;
    if(l>=r) return mid;
    int now=T[T[b].rc].sum-T[T[a].rc].sum;
    if(rk<=now) return query(mid+1,r,T[a].rc,T[b].rc,rk);
    else return query(l,mid,T[a].lc,T[b].lc,rk-now);
}
void dfs(int u)
{
    L[u]=++dfsc;
    update(0,tot,rt[L[u]-1],rt[L[u]],h[u]);
    FOR(i,1,D-1) {
        fa[u][i]=fa[fa[u][i-1]][i-1];
        mx[u][i]=max(mx[u][i-1],mx[fa[u][i-1]][i-1]);
    }
    for(int i=front[u];i>=0;i=e[i].nxt) {
        int v=e[i].v;
        dep[v]=dep[u]+1,
        dfs(v);
    }
    R[u]=dfsc;
}
int find_root(int u,int x)
{
    for(int i=D-1;i>=0;i--)
        if(fa[u][i] && mx[u][i]<=x)
            u=fa[u][i];
    return u;
}

int main()
{
    //reopen("in.in","r",stdin);
    //freopen("out.out","w",stdout);

    memset(front,-1,sizeof(front));
    n=read(),m=read(),q=read();
    FOR(i,1,n) h[i]=read(),hash[i]=h[i];
    int u,v,w,x,k,ans=0;
    FOR(i,1,m) {
        u=read(),v=read(),w=read();
        es[i]=(Edge){u,v,w};
    }

    FOR(i,1,2*n) p[i]=i;
    sort(hash+1,hash+n+1);
    tot=unique(hash+1,hash+n+1)-hash-1;
    FOR(i,1,n)
        h[i]=lower_bound(hash+1,hash+tot+1,h[i])-hash;

    sort(es+1,es+m+1);
    FOR(i,1,m) {
        Edge e=es[i];
        int x=ifind(e.u),y=ifind(e.v);
        if(x!=y) {
            int ext=++n;
            fa[x][0]=fa[y][0]=ext;
            mx[x][0]=mx[y][0]=e.w;
            p[x]=p[y]=ext;
            adde(ext,x),adde(ext,y);
        }
    }

    dfs(n);

    FOR(i,1,q) {
        v=read(),x=read(),k=read();
        v^=ans,x^=ans,k^=ans;
        int root=find_root(v,x);
        if(R[root]-L[root]+1<k) puts("-1"),ans=0;
        else {
            ans=query(0,tot,rt[L[root]-1],rt[R[root]],k);
            if(!ans) puts("-1");
            else printf("%d\n",ans=hash[ans]);
        }
    }
    return 0;
}