Count on a tree SPOJ - COT （主席树，LCA）

You are given a tree with N nodes. The tree nodes are numbered from 1 to N. Each node has an integer weight.

We will ask you to perform the following operation:

u v k : ask for the kth minimum weight on the path from node u to node v

Input

In the first line there are two integers N and M. (N, M <= 100000)

In the second line there are N integers. The ith integer denotes the weight of the ith node.

In the next N-1 lines, each line contains two integers u v, which describes an edge (u, v).

In the next M lines, each line contains three integers u v k, which means an operation asking for the kth minimum weight on the path from node u to node v.

Output

For each operation, print its result.

Example

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
2 5 2
2 5 3
2 5 4
7 8 2

Output:

2
8
9
105
7 
给出一棵树，每个点都自己的权重，然后给出树上的边，要求从节点 u 到节点 v 路径上的第 k 小的权重的大小。
因为权重可能很大，所以需要离散化。
主席树求区间第 k 小维护的是权值线段树的前缀和，然后通过区间相减得到查询区间的权值线段树
所以树形结构的第 k 小维护的也是权值线段树的前缀和，这里的前缀和表示从第 i 个结点到根的前缀和，比如样例的树是

那么我们用主席树把这八个结点维护成这个样子

那么要得到其中两个点（u，v）之间的树形结构，就可以看成 TREE（u） + TREE（v） - TREE（lca（u，v））- TREE（fa（lca（u，v））），把查询看成四棵树之间的相加相减，然后在求一下lca（u，v）就可以了，这里我比较懒直接用在线的写了

 /*

           .

          ';;;;;.

         '!;;;;;;!;`

        '!;|&#@|;;;;!:

       `;;!&####@|;;;;!:

      .;;;!&@$$%|!;;;;;;!'.`:::::'.

      '!;;;;;;;;!$@###&|;;|%!;!$|;;;;|&&;.

      :!;;;;!$@&%|;;;;;;;;;|!::!!:::;!$%;!$%`    '!%&#########@$!:.

      ;!;;!!;;;;;|$$&@##$;;;::'''''::;;;;|&|%@$|;;;;;;;;;;;;;;;;!$;

      ;|;;;;;;;;;;;;;;;;;;!%@#####&!:::;!;;;;;;;;;;!&####@%!;;;;$%`

     `!!;;;;;;;;;;!|%%|!!;::;;|@##%|$|;;;;;;;;;;;;!|%$#####%;;;%&;

     :@###&!:;;!!||%%%%%|!;;;;;||;;;;||!$&&@@%;;;;;;;|$$##$;;;%@|

     ;|::;;;;;;;;;;;;|&&$|;;!$@&$!;;;;!;;;;;;;;;;;;;;;;!%|;;;%@%.

    `!!;;;;;;;!!!!;;;;;$@@@&&&&&@$!;!%|;;;;!||!;;;;;!|%%%!;;%@|.

 %&&$!;;;;;!;;;;;;;;;;;|$&&&&&&&&&@@%!%%;!||!;;;;;;;;;;;;;$##!

 !%;;;;;;!%!:;;;;;;;;;;!$&&&&&&&&&&@##&%|||;;;!!||!;;;;;;;$&:

 ':|@###%;:;;;;;;;;;;;;!%$&&&&&&@@$!;;;;;;;!!!;;;;;%&!;;|&%.

  !@|;;;;;;;;;;;;;;;;;;|%|$&&$%&&|;;;;;;;;;;;;!;;;;;!&@@&'

   .:%#&!;;;;;;;;;;;;;;!%|$$%%&@%;;;;;;;;;;;;;;;;;;;!&@:

   .%$;;;;;;;;;;;;;;;;;;|$$$$@&|;;;;;;;;;;;;;;;;;;;;%@%.

     !&!;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;|@#;

      `%$!;;;;;;;;;;;$@|;;;;;;;;;;;;;;;;;;;;;;;;!%$@#@|.

        .|@%!;;;;;;;;;!$&%||;;;;;;;;;;;;;;;;;!%$$$$$@#|.

            ;&$!;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;%#####|.

            |##$|!;;;;;;::'':;;;;;;;;;;;;;!%$$$@#@;

           ;@&|;;;;;;;::'''''':;;;;;;;|$&@###@|`

         .%##@|;;;;:::''''''''''::;!%&##$'

       `$##@$$@@&|!!;;;:'''''::::;;;;;|&#%.

     ;&@##&$%!;;;;;;::''''''''::;!|%$@#@&@@:

      .%@&$$|;;;;;;;;;;:'''':''''::;;;%@#@@#%.

     :@##@###@$$$$$|;;:'''':;;!!;;;;;;!$#@@#$;`

      `%@$$|;;;;;;;;:'''''''::;;;;|%$$|!!&###&'

      |##&%!;;;;;::''''''''''''::;;;;;;;!$@&:`!'

     :;!@$|;;;;;;;::''''''''''':;;;;;;;;!%&@$:                !@#$'

       |##@@&%;;;;;::''''''''':;;;;;;;!%&@#@$%:            '%%!%&;

       |&%!;;;;;;;%$!:''''''':|%!;;;;;;;;|&@%||`         '%$|!%&;

       |@%!;;!!;;;||;:'''''':;%$!;;;;!%%%&#&%$&:        .|%;:!&%`

       !@&%;;;;;;;||;;;:''::;;%$!;;;;;;;|&@%;!$;       `%&%!!$&:

       '$$|;!!!!;;||;;;;;;;;;;%%;;;;;;;|@@|!$##;      !$!;:!$&:

        |#&|;;;;;;!||;;;;;;;;!%|;;;;!$##$;;;;|%'   `%$|%%;|&$'

         |&%!;;;;;;|%;;;;;;;;$$;;;;;;|&&|!|%&&;  .:%&$!;;;:!$@!

         `%#&%!!;;;;||;;;;;!$&|;;;!%%%@&!;;;!!;;;|%!;;%@$!%@!

         !&!;;;;;;;;;||;;%&!;;;;;;;;;%@&!;;!&$;;;|&%;;;%@%`

        '%|;;;;;;;;!!|$|%&%;;;;;;;;;;|&#&|!!||!!|%$@@|'

        .!%%&%'`|$;     :|$#%|@#&;%#%.

 */

 #include <map>

 #include <set>

 #include <list>

 #include <ctime>

 #include <cmath>

 #include <stack>

 #include <queue>

 #include <string>

 #include <vector>

 #include <cstdio>

 #include <bitset>

 #include <cstdlib>

 #include <cstring>

 #include <iostream>

 #include <algorithm>

 #define  lowbit(x)  x & (-x)

 #define  mes(a, b)  memset(a, b, sizeof a)

 #define  fi         first

 #define  se         second

 #define  pii        pair<int, int>

 #define  INOPEN     freopen("in.txt", "r", stdin)

 #define  OUTOPEN    freopen("out.txt", "w", stdout)

 typedef unsigned long long int ull;

 typedef long long int ll;

 const int    maxn = 1e5 + ;

 const int    maxm = 1e5 + ;

 const int    mod  = 1e9 + ;

 const ll     INF  = 1e18 + ;

 const int    inf  = 0x3f3f3f3f;

 const double pi   = acos(-1.0);

 const double eps  = 1e-;

 using namespace std;

 int n, m;

 int cas, tol, T;

 struct Node {

     int l, r;

     int sum;

 } node[maxn * ];

 int a[maxn];

 int rt[maxn];

 bool vis[maxn];

 int deep[maxn];

 int fa[maxn][];

 vector<int> vec[maxn];

 vector<int> vv;

 void init() {

     tol = ;

     mes(a, );

     mes(rt, );

     mes(fa, );

     mes(vis, );

     mes(node, );

     mes(deep, );

     vv.clear();

     for(int i=; i<=n; i++)

         vec[i].clear();

 }

 int getid(int x) {

     return lower_bound(vv.begin(), vv.end(), x) - vv.begin() + ;

 }

 void lca_dfs(int u, int f, int d) {

     deep[u] = d;

     int len = vec[u].size();

     for(int i=; i<len; i++) {

         int v = vec[u][i];

         if(v == f)    continue;

         if(fa[v][])continue;

         fa[v][] = u;

         lca_dfs(v, u, d+);

     }

 }

 void lca_update() {

     for(int j=; (<<j)<=n; j++) {

         for(int i=; i<=n; i++) {

             fa[i][j] = fa[fa[i][j-]][j-];

         }

     }

 }

 int lca_query(int u, int v) {

     if(deep[u] < deep[v])    swap(u, v);

     int f = deep[u] - deep[v];

     for(int i=; (<<i)<=f; i++) {

         if(f & (<<i)) {

             u = fa[u][i];

         }

     }

     if(u != v) {

         for(int i=(int)log2(n); i>=; i--) {

             if(fa[u][i] != fa[v][i]) {

                 u = fa[u][i];

                 v = fa[v][i];

             }

         }

         u = fa[u][];

     }

     return u;

 }

 void hjt_update(int l, int r, int &x, int y, int pos) {

     tol++;

     node[tol] = node[y];

     node[tol].sum++;

     x = tol;

     if(l == r)    return ;

     int mid = (l + r) >> ;

     if(pos <= mid)

         hjt_update(l, mid, node[x].l, node[y].l, pos);

     else

         hjt_update(mid+, r, node[x].r, node[y].r, pos);

 }

 void hjt_build(int u, int f) {

 //    printf("%d %d\n", u, f);

     hjt_update(, n, rt[u], rt[f], getid(a[u]));

     vis[u] = true;

     int len = vec[u].size();

     for(int i=; i<len; i++) {

         int v = vec[u][i];

         if(vis[v])    continue;

         if(v == f)    continue;

         hjt_build(v, u);

     }

 }

 int hjt_query(int l, int r, int x, int y, int lca, int flca, int k) {

     if(l == r)

         return l;

     int mid = (l + r) >> ;

     int sum = node[node[x].l].sum + node[node[y].l].sum - node[node[lca].l].sum - node[node[flca].l].sum;

     if(k <= sum)

         return hjt_query(l, mid, node[x].l, node[y].l, node[lca].l, node[flca].l, k);

     else

         return hjt_query(mid+, r, node[x].r, node[y].r, node[lca].r, node[flca].r, k-sum);

 }

 int main() {

     scanf("%d%d", &n, &m);

     init();

     for(int i=; i<=n; i++) {

         scanf("%d", &a[i]);

         vv.push_back(a[i]);

     }

     sort(vv.begin(), vv.end());

     vv.erase(unique(vv.begin(), vv.end()), vv.end());

     for(int i=; i<n; i++) {

         int u, v;

         scanf("%d%d", &u, &v);

         vec[u].push_back(v);

         vec[v].push_back(u);

     }

     fa[][] = ;

     lca_dfs(, , );

     lca_update();

     hjt_build(, );

     while(m--) {

         int u, v, k;

         scanf("%d%d%d", &u, &v, &k);

         int ans = hjt_query(, n, rt[u], rt[v], rt[lca_query(u, v)], rt[fa[lca_query(u, v)][]], k);

         printf("%d\n", vv[ans-]);

     }

     return ;

 }