您將獲得一個包含N個節點的樹。樹節點的編號從1到?。每個節點都有一個整數權重。

我們會要求您執行以下操作：

• uvk：詢問從節點u到節點v的路徑上的第k個最小權重

輸入

在第一行中有兩個整數?和中號。（N，M <= 100000）

在第二行中有N個整數。第i個整數表示第i個節點的權重。

在接下來的N-1行中，每行包含兩個整數u v，它描述了一個邊（u，v）。

在接下來的M行中，每行包含三個整數u v k，這意味著要求從節點u到節點v的路徑上的第k個最小權重的操作。

解題思路:
首先對於求第K小的問題 我們可以用主席樹搞 ,沒有問題,
但是對於一個樹形結構,我們需要將其轉化為線性,然後需要樹剖才能做.

然後考慮鏈上的第k值怎麽維護 ,
發現如果樹剖計算的話 維護不了啊
因為(u,v)的路 可能在很多個鏈上,那麽不能對每個求第K值,這樣明顯是錯誤的啊,

然後我們知道主席樹其實就是維護了一個前綴和

那麽我們可以對每一個節點到根節點建立前綴和,就能找任意一個節點到根節點的第K值,
那麽根據主席樹的性質,我們就能夠計算(u,v)的路上的第K值了
只要在查詢的時候稍改變一下就行了

cnt = sum[ls[u]]+sum[ls[v]]-sum[ls[lca(u,v)]]-sum[ls[fa[lca(u,v)]]];

#include<iostream>
#include<algorithm>
#include
 
<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<map>
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5+100;
typedef long long LL;
int rt[N*20], ls[N*20], rs[N*20], sum[N*20];
int fa[2*N][30], dep[2*N], vis[N];
int a[N], b[N], tot, cnt, head[N], len;
 
struct node
{
    int to, next;
} p[2*N];
void init()
{
    memset(head,-1,sizeof(head));
    memset(vis,0,sizeof(vis));
    cnt=0;
    return ;
}
void add(int u,int v)
{
    p[cnt].to=v,p[cnt].next=head[u];head[u]=cnt++;
    p[cnt].to=u,p[cnt].next=head[v];head[v]=cnt++;
    return ;
}
void build(int &o,int l,int r)
{
    o= ++tot,sum[o]=0;
    if(l==r) return ;
    int mid=(l+r)/2;
    build(ls[o],l,mid);
    build(rs[o],mid+1,r);
    return ;
}
void update(int &o,int l,int r,int last,int p)
{
    o= ++tot;
    ls[o]=ls[last],rs[o]=rs[last];
    sum[o]=sum[last]+1;
    if(l==r) return ;
    int mid=(l+r)/2;
    if(p<=mid) update(ls[o],l,mid,ls[last],p);
    else update(rs[o],mid+1,r,rs[last],p);
    return ;
}
int query(int ss,int tt,int s1,int t1,int l,int r,int cnt)
{
    if(l==r) return l;
    int tmp=sum[ls[tt]]+sum[ls[ss]]-sum[ls[s1]]-sum[ls[t1]];
    int mid=(l+r)/2;
    if(tmp>=cnt) return query(ls[ss],ls[tt],ls[s1],ls[t1],l,mid,cnt);
    else return query(rs[ss],rs[tt],rs[s1],rs[t1],mid+1,r,cnt-tmp);
}
void dfs(int u,int d,int f,int root)
{
    vis[u]=1,dep[u]=d,fa[u][0]=f;
    update(rt[u],1,len,root,a[u]);
    root=rt[u];
    for(int i=head[u];i!=-1;i=p[i].next)
    {
        int v=p[i].to;
        if(vis[v]) continue;
        dfs(v,d+1,u,root);
    }
    return ;
}
void lca(int n)
{
    int k=(int)(log(1.0*n)/log(2.0));
    for(int i=1;i<=k;i++)
    {
        for(int j=1;j<=n;j++)
        {
            fa[j][i]=fa[fa[j][i-1]][i-1];
        }
    }
    return ;
}
int get(int x,int y,int n)
{
    if(dep[x]<dep[y]) swap(x,y);
    int k=(int)(log(1.0*n)/log(2.0));
    int d=dep[x]-dep[y];
    for(int i=0;i<=k;i++)
        if((d&(1<<i))) x=fa[x][i];
    if(x==y) return x;
    for(int i=k;i>=0;i--)
    {
        if(fa[x][i]!=fa[y][i]) x=fa[x][i],y=fa[y][i];
    }
    return fa[x][0];
}
 
int main()
{
    int t, n, q;
    scanf("%d %d", &n, &q);
    for(int i=1; i<=n; i++) scanf("%d", &a[i]), b[i]=a[i];
    sort(b+1,b+n+1);
    len=unique(b+1,b+n+1)-(b+1);
    tot=0;
    build(rt[0],1,len);
    for(int i=1; i<=n; i++)  a[i]=lower_bound(b+1,b+len+1,a[i])-(b);
    init();
    for(int i=0;i<n-1;i++)
    {
        int x, y;
        scanf("%d %d", &x, &y);
        add(x,y);
    }
    dfs(1,1,0,rt[0]);
    lca(n);
    while(q--)
    {
        int l, r, x;
        scanf("%d %d %d", &l, &r, &x);
        int pos=get(l,r,n);
        printf("%d\n",b[query(rt[l],rt[r],rt[pos],rt[fa[pos][0]],1,len,x)]);
    }
    return 0;
}

spoj COT - Count on a tree(主席樹 +lca,樹上第K大)