BZOJ3551 [ONTAK2010]Peaks加强版【Kruskal重构树+主席树+树上倍增】

Time Limit: 20 Sec
Memory Limit: 128 MB

Description

在有N座山峰，每座山峰有他的高度h_i，有些山峰之间有双向道路相连，共M条路经，每条路径有一个困难值，这个值越大表示越难走，现有Q组询问，每组询问从点v开始只经过困难值小于等于x的路径所能到达的山峰中第k高的山峰，如果无解输出-1

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则不变。

---

题目分析

本题的非强制在线题为BZOJ3545，权限题
总之懂了这道题就可以顺手双倍经验了

“从v出发只经过小于等于x的边能到达的山峰”
这里不难想到kruskal重构树
在重构树中找到点权小于等于x且深度最小结点
(这里可以用树上倍增在log的时间内找到)
那么他的子树内所有节点就是从v出发只经过小于等于x的边能到达的山峰

而要在某个子树内求静态区间第k大
不难想到主席树
用dfs序维护就好

虽然思路不难，但调起来真的很烦人啊
整整两天才搞完=_=

---

#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
         
int read()
{
    int f=1,x=0;
    char ss=getchar();
    while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
    while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
    return f*x;
}
         
const int maxn=200010;
int n,m,q,ans;
int hi[maxn],cnt;
int poss[maxn],a[maxn];
         
struct node{int u,v,dis;}edge[500010];
bool cmp(node a,node b){return a.dis<b.dis;}
         
struct node2{int v,nxt;}E[500010];
int head[maxn],tot;
     
int val[maxn],ff[maxn],vis[maxn];
int dfn[maxn],pos[maxn],mx[maxn],mi[maxn],cnt1;
         
int rt[maxn],sum[maxn*20];
int lc[maxn*20],rc[maxn*20],cnt2;
int gra[maxn][25];
         
void add(int u,int v)
{
    E[++tot].nxt=head[u];
    E[tot].v=v;
    head[u]=tot;
}
         
int find(int x)
{
    if(x==ff[x]) return x;
    else return ff[x]=find(ff[x]);
}
//***********************************************
void dfs(int u)//mx,mi分别记录以u为根的子树内最大/小的dfs序编号
{
    vis[u]=1;
    if(u<=n) mi[u]=mx[u]=++cnt1,pos[cnt1]=u;
    else mi[u]=n+1;
    for(int i=head[u];i;i=E[i].nxt)
    {
        int v=E[i].v;
        gra[v][0]=u;
        dfs(v);
        mi[u]=min(mi[u],mi[v]);
        mx[u]=max(mx[u],mx[v]);
    }
}
//**********************************************//kruskal重构树
void kruskal()
{
    sort(edge+1,edge+1+m,cmp);
    for(int i=1;i<=n<<1;++i)ff[i]=i;
    for(int i=1;i<=m;++i)
    {
        int fu=find(edge[i].u),fv=find(edge[i].v);
        if(fu!=fv)
        {
            val[++cnt]=edge[i].dis;
            ff[fu]=ff[fv]=cnt;
            add(cnt,fu); add(cnt,fv);
        }
    }
    //for(int i=cnt;i>=1;--i)
    //if(!vis[i]){ int f=find(i); dfs(f);}
    dfs(cnt);
}
//**********************************************//主席树
int query(int u,int v,int ll,int rr,int k)
{
    if(sum[v]-sum[u]<k) return -1;
    if(ll==rr) return ll;
    int x=sum[rc[v]]-sum[rc[u]];
    int mid=ll+rr>>1;
    if(k<=x) return query(rc[u],rc[v],mid+1,rr,k);
    else return query(lc[u],lc[v],ll,mid,k-x);
}
         
int update(int pre,int ll,int rr,int x)
{
    int tt=++cnt2; 
    sum[tt]=sum[pre]+1; lc[tt]=lc[pre]; rc[tt]=rc[pre];
    int mid=ll+rr>>1;
    if(ll<rr)
    {
        if(x<=mid) lc[tt]=update(lc[pre],ll,mid,x);
        else rc[tt]=update(rc[pre],mid+1,rr,x);
    }
    return tt;
}         
//****************************************
int main()
{
    n=read();m=read();q=read();cnt=n;
    for(int i=1;i<=n;++i)hi[i]=a[i]=read();
    for(int i=1;i<=m;++i)
    edge[i].u=read(),edge[i].v=read(),edge[i].dis=read();
             
    sort(a+1,a+1+n);
    for(int i=1;i<=n;++i)
    if(i==1||a[i]!=a[i-1])
    poss[++poss[0]]=a[i];
     
    kruskal();
             
    for(int i=1;i<=n;++i)
    {
        int x=lower_bound(poss+1,poss+1+poss[0],hi[pos[i]])-poss;
        rt[i]=update(rt[i-1],1,poss[0],x);
    }
             
    for(int i=1;(1<<i)<=cnt;++i)//倍增预处理
    for(int u=1;u<=cnt;++u)
    gra[u][i]=gra[gra[u][i-1]][i-1];
             
    while(q--)
    {
        int u=read(),x=read(),k=read();
        if(ans>-1)u=u^ans,x=x^ans,k=k^ans;
               
        for(int i=22;i>=0;--i)//找点权小于等于x且深度最小结点
        if(gra[u][i]&&val[gra[u][i]]<=x)u=gra[u][i];
     
        int ll=mi[u],rr=mx[u];
         
        ans=query(rt[ll-1],rt[rr],1,poss[0],k);      
        if(ans>-1)ans=poss[ans];
        printf("%d\n",ans);
    }
    return 0;
}