bzoj 2588 Spoj 10628. Count on a tree（主席树）

 

Description

给定一棵N个节点的树，每个点有一个权值，对于M个询问(u,v,k)，你需要回答u xor lastans和v这两个节点间第K小的点权。其中lastans是上一个询问的答案，初始为0，即第一个询问的u是明文。

 

Input

第一行两个整数N,M。

第二行有N个整数，其中第i个整数表示点i的权值。

后面N-1行每行两个整数(x,y)，表示点x到点y有一条边。

最后M行每行两个整数(u,v,k)，表示一组询问。

 

Output

 

M行，表示每个询问的答案。

Sample Input

8 5
105 2 9 3 8 5 7 7
1 2
1 3
1 4
3 5
3 6
3 7
4 8
2 5 1
0 5 2
10 5 3
11 5 4
110 8 2

Sample Output

2
8
9
105
7

HINT

 

HINT：

N,M<=100000

暴力自重。。。

 

 

【题意】

 

       求u到v路径上的第k小的数。

 

【思路】

 

       主席树，dfs序，lca，二分

       主席树就是可持久化线段树，即保留历史版本的线段树。

       为什么要保留历史版本呢？因为我们要完成对区间的查询，对于一个区间和的询问我们可以利用前缀和的思想来解决，主席树大概也是这个思路。

       我们对每一个点建一棵线段树，每一棵线段树以权值为下标，维护区间中点的数目。依次建立每一棵线段树，第i棵线段树是从第i-1棵线段树上插了个权值i而得到的。这样对于区间[l,r]的查询，我们可以通过询问T[r]和T[l-1]的相应区间而得到。

       对应到这道题中，我们先离散化权值（不离散化空间还不得飞起来233），然后按照树的形态来建立每一棵线段树，每一棵线段树就是从父节点对应的线段树上拓展来的，相当于上一个版本。这样从祖先到结点路径上的线段树就是逐渐增大且只包括路径上的权值的。

       建好主席树后，对于查询(u,v)，二分数的大小mid，我们就可以知道“区间”内所有小于mid的数目，为T[u].lc.sum-T[lca].lc.sum+T[v].lc.sum-T[fa[lca]].lc.sum (T[i]为i对应一棵线段树，lc为左儿子，sum为对应的权值数目)，如果rank比之小则缩小数的区间，使u,v,lca,fa[lca]进入左儿子，否则修改rank后进入右儿子。

 

【代码】

 

 

#include<cstdio>
#include<vector>
#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 = 1e5+5;
const int M = 2*1e6+5;
const int D = 18;

int n,m,tot,sz,ind;
int hash[N],pos[N],num[N],v[N],root[N];
int sum[M],ls[M],rs[M];
vector<int> g[N];

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 fa[N],top[N],son[N],siz[N],dep[N];
void dfs1(int u) 
{
    siz[u]=1; son[u]=0; num[++ind]=u; pos[u]=ind;
    for(int i=0;i<g[u].size();i++) {
        int v=g[u][i];
        if(v!=fa[u]) {
            fa[v]=u;
            dep[v]=dep[u]+1;
            dfs1(v);
            siz[u]+=siz[v];
            if(siz[v]>siz[son[u]]) son[u]=v;
        }
    }
}
void dfs2(int u,int tp) 
{
    top[u]=tp;
    if(son[u]) dfs2(son[u],tp);
    for(int i=0;i<g[u].size();i++) {
        int v=g[u][i];
        if(v!=fa[u] && v!=son[u]) dfs2(v,v);
    }
}
int lca(int u,int v) 
{
    while(top[u]!=top[v]) {
        if(dep[top[u]]<dep[top[v]]) swap(u,v);
        u=fa[top[u]];
    }
    return dep[u]>dep[v]? v:u;
}
void update(int l,int r,int x,int &y,int num) 
{
    y=++sz;
    sum[y]=sum[x]+1;
    if(l==r) return ;
    ls[y]=ls[x] ; rs[y]=rs[x]; 
    int mid=(l+r)>>1;
    if(num<=mid) update(l,mid,ls[x],ls[y],num);
    else update(mid+1,r,rs[x],rs[y],num);
}
int query(int x,int y,int rank) 
{
    int a=x,b=y,c=lca(x,y),d=fa[c];
    a=root[pos[a]],b=root[pos[b]],c=root[pos[c]],d=root[pos[d]];
    int l=1,r=tot;
    while(l<r) {
        int mid=(l+r)>>1;
        int now=sum[ls[a]]+sum[ls[b]]-sum[ls[c]]-sum[ls[d]];
        if(rank<=now) r=mid,a=ls[a],b=ls[b],c=ls[c],d=ls[d];
        else l=mid+1,rank-=now,a=rs[a],b=rs[b],c=rs[c],d=rs[d];
    }
    return hash[l];
}

int main()
{
    //freopen("in.in","r",stdin);
    //freopen("out.out","w",stdout); 
    n=read(),m=read();
    FOR(i,1,n) {
        v[i]=read(); hash[i]=v[i];
    }
    sort(hash+1,hash+n+1);
    tot=1;
    FOR(i,2,n) if(hash[i]!=hash[i-1])
        hash[++tot]=hash[i];
    FOR(i,1,n)
        v[i]=lower_bound(hash+1,hash+tot+1,v[i])-hash;
    int x,y,z;
    FOR(i,1,n-1) {
        x=read(),y=read();
        g[x].push_back(y);
        g[y].push_back(x);
    }
    dfs1(1),dfs2(1,1);
    FOR(i,1,n) {
        int t=num[i];
        update(1,tot,root[pos[fa[t]]],root[i],v[t]);
    }
    int lastans=0;
    FOR(i,1,m) {
        x=read(),y=read(),z=read();
        x^=lastans;
        printf("%d",lastans=query(x,y,z));
        if(i!=m) puts("");
    }
    return 0;
}