洛谷p4197 [克鲁斯卡尔树+主席树+倍增]

传送门

题意：给出一个带权无向图，图的边有权值同时点也有权值，有q次询问，每次询问v x k，求从v出发只经过权值不超过x的边可以走到的权值第k大的点，不存在则输出-1

题解：由经过不超过x的边可知可以直接建立克鲁斯卡尔树，同时dfs给原结点重新编号，并得出每个新建结点可以管辖的老节点的区间[L,R]，那么可以对重新编号后的原结点建立主席树，对每次询问，倍增得到不超过x的最高结点，同时得到它管辖的区间[L,R]，直接求root[R]-root[L-1]的第k大即可

#include<bits/stdc++.h>

using namespace std;
//#define debug(x) cout<<#x<<" is "<<x<<endl;
typedef long long ll;

const int maxn=1e5+5;
const int inf=1e7;

struct edge{
    int fr;
    int to;
    int val;
}e[maxn*5];

struct edge2{
    int fr;
    int to;
    int nex;
}e2[maxn*11];

struct Node{
    int lson;
    int rson;
    int val;
}nod[maxn*21];

int Tot,TOT,cnt,root[maxn],bb[maxn],L[maxn*3],R[maxn*3],val[maxn],id[maxn],head[maxn*3],Val[maxn*3],fa[maxn*3],fa2[31][maxn*3];

bool cmp(struct edge aa,struct edge bb){
    return aa.val<bb.val;
}

void pushup(int rt){
    nod[rt].val=nod[nod[rt].lson].val+nod[nod[rt].rson].val;
}

void build(int &rt,int l,int r){
    rt=++TOT;
    nod[rt].val=0;
    if(l==r)return;
    int mid=(l+r)>>1;
    build(nod[rt].lson,l,mid);
    build(nod[rt].rson,mid+1,r);
}

void update(int &rt,int pre,int l,int r,int v){
    rt=++TOT;
    nod[rt].lson=nod[pre].lson;
    nod[rt].rson=nod[pre].rson;
    nod[rt].val=nod[pre].val;
    if(l==r){nod[rt].val++;return;}
    int mid=(l+r)>>1;
    if(mid>=v)update(nod[rt].lson,nod[pre].lson,l,mid,v);
    else update(nod[rt].rson,nod[pre].rson,mid+1,r,v);
    pushup(rt);
}

void adde(int x,int y){
    e2[cnt].fr=x;
    e2[cnt].to=y;
    e2[cnt].nex=head[x];
    head[x]=cnt++;
}

int finds(int x){
    int xx=x;
    while(fa[x]!=x)x=fa[x];
    while(fa[xx]!=x){
        int t=fa[xx];
        fa[xx]=x;
        xx=t;
    }
    return x;
}

void dfs(int u,int f){
    fa2[0][u]=f;
    for(int i=1;i<=30;i++){
        if(fa2[i-1][u])fa2[i][u]=fa2[i-1][fa2[i-1][u]];
        else break;
    }
    int F=1;
    int L0=1e7;
    int R0=0;
    for(int i=head[u];i!=-1;i=e2[i].nex){
        int v=e2[i].to;
        F=0;
        dfs(v,u);
        L0=min(L0,L[v]);
        R0=max(R0,R[v]);
    }
    if(F){
        L[u]=R[u]=++Tot;
        id[Tot]=u;
    }
    else{
        L[u]=L0;
        R[u]=R0;
    }
}

int query(int rt1,int rt2,int l,int r,int k){
    if(l==r){
        return bb[l];
    }
    int mid=(l+r)>>1;
    if(nod[nod[rt1].lson].val-nod[nod[rt2].lson].val>=k)
        return query(nod[rt1].lson,nod[rt2].lson,l,mid,k);
    else
        return query(nod[rt1].rson,nod[rt2].rson,mid+1,r,k-(nod[nod[rt1].lson].val-nod[nod[rt2].lson].val));
}

int main(){
    int n,m,q;
    memset(head,-1,sizeof(head));
    scanf("%d%d%d",&n,&m,&q);
    for(int i=1;i<=n;i++){scanf("%d",&val[i]);bb[i]=val[i];}
    for(int i=1;i<=3*n;i++)fa[i]=i;
    int tot=0;
    for(int i=1;i<=m;i++){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        e[++tot].fr=a;
        e[tot].to=b;
        e[tot].val=c;
    }
    sort(e+1,e+1+tot,cmp);
    sort(bb+1,bb+1+n);
    int siz=unique(bb+1,bb+1+n)-(bb+1);
    int num=n;
    for(int i=1;i<=tot;i++){
        int f1=finds(e[i].fr);
        int f2=finds(e[i].to);
        if(f1!=f2){
            num++;
            fa[f1]=num;
            fa[f2]=num;
            adde(num,f1);
            adde(num,f2);
            Val[num]=e[i].val;
        }
    }
    dfs(num,0);
    build(root[0],1,siz);
    for(int i=1;i<=Tot;i++){
        int ww=lower_bound(bb+1,bb+1+siz,val[id[i]])-bb;
        update(root[i],root[i-1],1,siz,ww);
    }
    while(q--){
        int v,x,k;
        scanf("%d%d%d",&v,&x,&k);
        int w=v;
        for(int i=30;i>=0;i--){
            if(Val[fa2[i][w]]<=x&&fa2[i][w]){
                w=fa2[i][w];
            }
        }
        if(R[w]-L[w]+1<k){
            printf("-1\n");
            continue;
        }
        printf("%d\n",query(root[R[w]],root[L[w]-1],1,siz,R[w]-L[w]+2-k));
    }
    return 0;
}