SPOJ 10628 求树上的某条路径上第k小的点

第k小，很容易会想到用主席树来解决

这里简单想一下树的转移过程

因为本身无向图形成一棵树，那么我们总以1为根，那么之后连下去的边对应的点建立的线段树总是在父亲节点对应的树上加上一个当前点对应位置出现的值

这跟在普通序列上由前一个转移到下一个是差不多的

那么每个点上生成的线段树记录的就是当前节点到根节点的总信息

然后每次询问求出2个点的公共祖先，那么找第k小，总是两个点的总前缀 减去一个 公共祖先的前缀和公共祖先父亲的前缀

那么询问的时候只要查询这四个点对应的线段树的值就可以了

 #include <bits/stdc++.h>

 using namespace std;
 #define N 100010
 #define lowbit(x) x&(-x)
 #define define_m int m=(l+r)>>1
 #define LS(x) node[x].ls
 #define RS(x) node[x].rs
 #define INIT(x) node[x].init()
 #define SZ(x) node[x].sz

 int a[N] , val[N] , fa[N] , T[N];
 int n , m , first[N] , k , curn;//curn表示离散化后还剩多少种数

 //LCA所需
 int dp[N<<][];
 int id[N<<] , dep[N<<] , No[N] , dfs_clock;

 int HASH(int x){return lower_bound(a+ , a+curn+ , x)-a;}

 struct Node{
     int ls , rs , sz;
     void init(){ls=rs=sz=;}
 }node[N*];

 int tot;
 int build(int l , int r)
 {
     int u=tot++;
     INIT(u);
     if(l!=r){
         define_m;
         LS(u) = build(l , m);
         RS(u) = build(m+ , r);
     }
     return u;
 }

 void build(int o1 , int o2 , int l , int r , int pos , int v)
 {
     if(l==r){
         SZ(o2) = SZ(o1)+v;
         return;
     }
     define_m;
     INIT(tot);
     if(m>=pos){
         LS(o2) = tot++ , RS(o2) = RS(o1);
         build(LS(o1) , LS(o2) , l , m , pos , v);
     }else{
         LS(o2) = LS(o1) , RS(o2) = tot++;
         build(RS(o1) , RS(o2) , m+ , r , pos , v);
     }
     SZ(o2) = SZ(LS(o2)) + SZ(RS(o2));
 }

 int query(int u , int v , int anc1 , int anc2 , int l , int r , int k)
 {
     if(l==r) return l;
     define_m;
     int c = SZ(LS(u))+SZ(LS(v))-SZ(LS(anc1))-SZ(LS(anc2));
     if(c>=k) return query(LS(u) , LS(v) , LS(anc1) , LS(anc2) , l , m , k);
     else return query(RS(u) , RS(v) , RS(anc1) , RS(anc2) , m+ , r , k-c);
 }

 struct Edge{
     int x , y , next;
     Edge(){}
     Edge(int x , int y , int next):x(x),y(y),next(next){}
 }e[N<<];

 void add_edge(int x , int y){
     e[k] = Edge(x , y , first[x]);
     first[x] = k++;
 }

 void dfs(int u , int f , int d)
 {
     fa[u] = f , id[++dfs_clock] = u , No[u] = dfs_clock , dep[dfs_clock] = d;
     INIT(tot);
     T[u] = tot++;
     build(T[f] , T[u] ,  , curn , HASH(val[u]) , );
     for(int i=first[u] ; ~i ; i=e[i].next){
         int v = e[i].y;
         if(v == f) continue;
         dfs(v , u ,d+);
         id[++dfs_clock] = u , dep[dfs_clock] = d;
     }
 }

 void ST(int n){
     for(int i= ; i<=n ; i++) dp[i][] = i;
     for(int j= ; (<<j)<=n ; j++){
         for(int i= ; i+(<<j)-<=n ; i++){
             int a = dp[i][j-] , b=dp[i+(<<(j-))][j-];
             dp[i][j] = dep[a]<dep[b]?a:b;
         }
     }
 }

 int RMQ(int l , int r){
     int k= ;
     while((<<(k+))<=r-l+) k++;
     int a = dp[l][k] , b=dp[r-(<<k)+][k];
     return dep[a]<dep[b]?a:b;
 }

 int LCA(int u , int v)
 {
     int x = No[u] , y = No[v];
     if(x>y) swap(x , y);
     return id[RMQ(x,y)];
 }

 int main()
 {
    // freopen("in.txt" , "r" , stdin);
     //freopen("out1.txt" , "w" , stdout);
     while(~scanf("%d%d" , &n , &m)){
         k = ;
         memset(first , - , sizeof(first));
         for(int i= ; i<=n ; i++){scanf("%d" , &val[i]);a[i]=val[i];}
         sort(a+ , a+n+);
         curn = unique(a+ , a+n+)-(a+);
       //  cout<<"check: "<<curn<<endl;
         for(int i= ; i<n ; i++){
             int x , y;
             scanf("%d%d" , &x , &y);
             add_edge(x , y);
             add_edge(y , x);
         }
         dfs_clock = ;
         tot=;
         INIT(tot);
         T[] = build( , curn);
         dfs(,,);
         ST(*n-);
         while(m--){
             int x , y , k;
             scanf("%d%d%d" , &x , &y , &k);
             int anc = LCA(x , y);
             int index = query(T[x] , T[y] , T[anc] , T[fa[anc]] ,  , curn , k);
             printf("%d\n" , a[index]);
         }
     }
     return ;
 }