bzoj3545&&3551: [ONTAK2010]Peaks离线&&在线【线段树合并&&kruskal重构树&&主席树】

Description

在Bytemountains有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，表示一组询问。

Output

对于每组询问，输出一个整数表示答案。

Sample Input

10 11 4

1 2 3 4 5 6 7 8 9 10

1 4 4

2 5 3

9 8 2

7 8 10

7 1 4

6 7 1

6 4 8

2 1 5

10 8 10

3 4 7

3 4 6

1 5 2

1 5 6

1 5 8

8 9 2

Sample Output

6

1

-1

8
【注】：bzoj3551是该题的强制在线版本。

解题思路:

离线版本比较简单，把边和询问按权值排序，从小到大处理，用并查集维护连通性，同时用线段树维护连通块内点权，合并并查集时线段树合并即可。

主要讲讲在线版本的做法。

解题关键是维护每个边权限制时的连通状态，同时还要在可行的复杂度内维护连通块内的点权。这里用到了一个比较奇妙的思路：kruskal重构树。

跟建kruskal最小生成树类似，不过做了变形

比如每次连边有 x=find(e[i].x), y=find(e[i].y);

这时候新建一个节点z，点权是e[i].val

然后fa[x]=fa[y]=z，即新建的节点是此连通块的根

这样做有什么用呢。。好处就是建完树后，所有的MST的节点都在叶子节点，上边的全是由边转化的点。而且由kruskal的过程可知，越晚加入的边，边权越大，因此在新树中，除了叶子节点，越往上点的权值越大（很好的性质）

这一点就可以被每次询问的边权不超过w所用，此时w只要从询问的v开始，倍增往上找到第一个边权小于等于w的点x，x的子树内的叶子结点就是当前状态下v所在的连通块。

剩下的问题就是求这棵树子树内第k大叶子了，主席树套路题。

求出kruskal树的dfs序，然后按dfs序建主席树，注意仅叶子节点要修改权值线段树，否则不进行修改，将上棵树的根复制过来。

然后按区间第k大找就是了。

AC代码

离线版：

#include<bits/stdc++.h>
#define ll long long
using namespace std;

int getint()
{
    int i=0,f=1;char c;
    for(c=getchar();(c!='-')&&(c<'0'||c>'9');c=getchar());
    if(c=='-')f=-1,c=getchar();
    for(;c>='0'&&c<='9';c=getchar())i=(i<<3)+(i<<1)+c-'0';
    return i*f;
}

const int N=100005,M=500005;
int n,m,Q,tot,mx,fa[N],h[N],rt[N],ans[M];
struct edge
{
    int x,y,val,id;
    inline friend bool operator < (const edge &a,const edge &b)
    {return a.val<b.val;}
}bian[M],q[M];
struct node{int lc,rc,size;}tr[5000005];

int find(int x){return fa[x]==x?x:fa[x]=find(fa[x]);}

void Insert(int &x,int l,int r,int v)
{
    if(!x)x=++tot;++tr[x].size;
    if(l==r)return;
    int mid=l+r>>1;
    if(v<=mid)Insert(tr[x].lc,l,mid,v);
    else Insert(tr[x].rc,mid+1,r,v);
}

int merge(int x,int y,int l,int r)
{
    if(!x||!y)return x+y;
    if(l==r){tr[x].size+=tr[y].size;return x;}
    int mid=l+r>>1;
    tr[x].lc=merge(tr[x].lc,tr[y].lc,l,mid);
    tr[x].rc=merge(tr[x].rc,tr[y].rc,mid+1,r);
    tr[x].size=tr[tr[x].lc].size+tr[tr[x].rc].size;
    return x;
}

int query(int x,int l,int r,int k)
{
    if(l==r)return l;
    int mid=l+r>>1,lsize=tr[tr[x].lc].size;
    if(k<=lsize)return query(tr[x].lc,l,mid,k);
    else return query(tr[x].rc,mid+1,r,k-lsize);
}

int main()
{
    //freopen("lx.in","r",stdin);
    //freopen("lx1.out","w",stdout);
    n=getint(),m=getint(),Q=getint();
    for(int i=1;i<=n;i++)fa[i]=i,h[i]=getint(),mx=max(mx,h[i]);
    for(int i=1;i<=n;i++)Insert(rt[i],1,mx,h[i]);
    for(int i=1;i<=m;i++)bian[i].x=getint(),bian[i].y=getint(),bian[i].val=getint();
    sort(bian+1,bian+m+1);
    for(int i=1;i<=Q;i++)
        q[i].x=getint(),q[i].val=getint(),q[i].y=getint(),q[i].id=i;
    sort(q+1,q+Q+1);
    for(int i=1,j=1;i<=Q;i++)
    {
        while(bian[j].val<=q[i].val&&j<=m)
        {
            int x=find(bian[j].x),y=find(bian[j].y);
            j++;
            if(x!=y)fa[y]=x,rt[x]=merge(rt[x],rt[y],1,mx);
        }
        int x=find(q[i].x),k=q[i].y,sz=tr[rt[x]].size;
        if(k>sz)ans[q[i].id]=-1;
        else ans[q[i].id]=query(rt[x],1,mx,sz+1-k);
    }
    for(int i=1;i<=Q;i++)printf("%d\n",ans[i]);
}

在线版：

#include<bits/stdc++.h>
#define ll long long
using namespace std;

int getint()
{
    int i=0,f=1;char c;
    for(c=getchar();(c!='-')&&(c<'0'||c>'9');c=getchar());
    if(c=='-')f=-1,c=getchar();
    for(;c>='0'&&c<='9';c=getchar())i=(i<<3)+(i<<1)+c-'0';
    return i*f;
}

const int N=200005,M=500005;
int n,m,Q,mx,ans,h[N],id[N];
int ecnt,first[N],to[N],nxt[N];
int idx,cnt,in[N],out[N],fa[N][20],val[N];
int tot,rt[N];
struct edge
{
    int x,y,val;
    inline friend bool operator < (const edge &a,const edge &b)
    {return a.val<b.val;}
}bian[M];
struct node{int lc,rc,size;}tr[5000000];

int find(int x){return id[x]==x?x:id[x]=find(id[x]);}

void add(int x,int y)
{
    nxt[++ecnt]=first[x],first[x]=ecnt,to[ecnt]=y;
}

int find_root(int x,int lim)
{
    for(int i=19;i>=0;i--)
        if(fa[x][i]&&val[fa[x][i]]<=lim)x=fa[x][i];
    return x;
}

void Insert(int y,int &x,int l,int r,int v)
{
    tr[x=++tot]=tr[y];
    tr[x].size++;
    if(l==r)return;
    int mid=l+r>>1;
    if(v<=mid)Insert(tr[y].lc,tr[x].lc,l,mid,v);
    else Insert(tr[y].rc,tr[x].rc,mid+1,r,v);
}

int query(int x,int y,int l,int r,int k)
{
    if(l==r)return l;
    int mid=l+r>>1,lsize=tr[tr[y].lc].size-tr[tr[x].lc].size;
    if(k<=lsize)return query(tr[x].lc,tr[y].lc,l,mid,k);
    else return query(tr[x].rc,tr[y].rc,mid+1,r,k-lsize);
}

void dfs(int u)
{
    in[u]=++idx;
    for(int i=1;i<20;i++)fa[u][i]=fa[fa[u][i-1]][i-1];
    if(u<=n)Insert(rt[in[u]-1],rt[in[u]],1,mx,h[u]);
    else tr[rt[in[u]]=++tot]=tr[rt[in[u]-1]];
    for(int e=first[u];e;e=nxt[e])
    {
        int v=to[e];fa[v][0]=u;
        dfs(v);
    }
    out[u]=idx;
}

int main()
{
    //freopen("lx.in","r",stdin);
    //freopen("lx.out","w",stdout);
    n=getint(),m=getint(),Q=getint();
    for(int i=1;i<=n;i++)id[i]=i,val[++cnt]=0,h[i]=getint(),mx=max(mx,h[i]);
    for(int i=1;i<=m;i++)bian[i].x=getint(),bian[i].y=getint(),bian[i].val=getint();
    sort(bian+1,bian+m+1);
    for(int i=1;i<=m;i++)
    {
        int x=find(bian[i].x),y=find(bian[i].y);
        if(x==y)continue;
        id[++cnt]=cnt,val[cnt]=bian[i].val,id[x]=id[y]=cnt;
        add(cnt,x),add(cnt,y);
    }
    for(int i=cnt;i;i--)if(!in[i])dfs(i);
    while(Q--)
    {
        int v=getint(),lim=getint(),k=getint();
        if(ans!=-1)v^=ans,lim^=ans,k^=ans;
        v=find_root(v,lim);
        int x=rt[in[v]-1],y=rt[out[v]],sz=tr[y].size-tr[x].size;
        if(sz<k)ans=-1,puts("-1");
        else printf("%d\n",ans=query(x,y,1,mx,sz+1-k));
    }
    return 0;
}