SPOJ Count on a tree 树上第k大。

Description

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
uv,which describes an edge (u,v).

In the next M lines,each line contains three integers
uvk,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 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

给定一棵树n个节点的权值，n-1条边，求路径上第k大

同样是可持久化线段树，只是这一次我们用它来维护树上的信息。我们之前已经知道，可持久化线段树实际上是维护的一个前缀和，而前缀和不一定要出现在一个线性表上。

比如说我们从一棵树的根节点进行DFS，得到根节点到各节点的距离dist[x]——这是一个根-x路径上点与根节点距离的前缀和。

利用这个前缀和，我们可以解决一些树上任意路径的问题，比如在线询问[a,b]点对的距离——答案自然是dist[a]+dist[b]-2*dist[lca(a,b)]。

同理，我们可以利用可持久化线段树来解决树上任意路径的问题。

DFS遍历整棵树，然后在每个节点上建立一棵线段树，某一棵线段树的“前一版本”是位于该节点父亲节点fa的线段树。

利用与之前类似的方法插入点权(排序离散)。那么对于询问[a,b]，答案就是root[a]+root[b]-root[lca(a,b)]-root[fa[lca(a,b)]]上的第k大。

一个地方写错，苦苦折腾了几个小时，悲剧呀。

代码：

/* ***********************************************
Author :rabbit
Created Time :2014/4/11 18:01:43
File Name :10.cpp
************************************************ */
#pragma comment(linker, "/STACK:102400000,102400000")
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <string>
#include <time.h>
#include <math.h>
#include <queue>
#include <stack>
#include <set>
#include <map>
using namespace std;
#define INF 0x3f3f3f3f
#define eps 1e-8
#define pi acos(-1.0)
typedef long long ll;
const int maxn=100100;
int head[maxn],tol;
int dep[maxn],fa[maxn][20],pre[maxn],q[maxn];
int a[maxn],lisan[maxn];
int root[30*maxn],L[30*maxn],R[30*maxn],cnt,sum[30*maxn];
struct Edge{
int next,to;
}edge[4*maxn];
void addedge(int u,int v){
edge[tol].to=v;
edge[tol].next=head[u];
head[u]=tol++;
}
void bfs(int s){
int l=1,r=1;q[r++]=s;
dep[s]=0;fa[s][0]=0;pre[s]=0;
while(l!=r){
int u=q[l++];
for(int i=1;i<20;i++)fa[u][i]=fa[fa[u][i-1]][i-1];
for(int i=head[u];i!=-1;i=edge[i].next){
int v=edge[i].to;if(v==pre[u])continue;
pre[v]=u;fa[v][0]=u;dep[v]=dep[u]+1;
q[r++]=v;
}
}
}
int LCA(int x,int y){
if(dep[x]<dep[y])swap(x,y);
for(int i=0;i<20;i++)if((dep[x]-dep[y])&(1<<i))x=fa[x][i];
if(x==y)return x;
for(int i=19;i>=0;i--)if(fa[x][i]!=fa[y][i])x=fa[x][i],y=fa[y][i];
return fa[x][0];
}
void build(int l,int r,int &p){
p=++cnt;
sum[p]=0;
if(l>=r)return;
int m=(l+r)/2;
build(l,m,L[p]);
build(m+1,r,R[p]);
}
void ins(int last,int &x,int l,int r,int val){
x=++cnt;
sum[x]=sum[last]+1;
L[x]=L[last];
R[x]=R[last];
if(l==r)return;
int mid=(l+r)/2;
if(val<=mid)ins(L[last],L[x],l,mid,val);
else ins(R[last],R[x],mid+1,r,val);
}
int ask(int l,int r,int k,int nl,int nr,int l1,int l2){
if(l==r)return lisan[l];
int mid=(l+r)/2;
if(sum[L[nl]]+sum[L[nr]]-sum[L[l1]]-sum[L[l2]]<k){
k-=sum[L[nl]]+sum[L[nr]]-sum[L[l1]]-sum[L[l2]];
return ask(mid+1,r,k,R[nl],R[nr],R[l1],R[l2]);
}
return ask(l,mid,k,L[nl],L[nr],L[l1],L[l2]);
}
int main()
{
//freopen("data.in","r",stdin);
//freopen("data.out","w",stdout);
int n,m;
while(~scanf("%d%d",&n,&m)){
memset(head,-1,sizeof(head));tol=0;
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
lisan[i]=a[i];
}
sort(lisan+1,lisan+1+n);
int SZ=unique(lisan+1,lisan+n+1)-lisan-1;
for(int i=1;i<=n;i++)a[i]=lower_bound(lisan+1,lisan+SZ+1,a[i])-lisan;
for(int i=1;i<n;i++){
int u,v;
scanf("%d%d",&u,&v);
addedge(u,v);
addedge(v,u);
}
bfs(1);cnt=0;
build(1,SZ,root[0]);
for(int i=1;i<=n;i++)ins(root[pre[q[i]]],root[q[i]],1,SZ,a[q[i]]);
while(m--){
int l,r,k,lca;
scanf("%d%d%d",&l,&r,&k);
lca=LCA(l,r);
printf("%d\n",ask(1,SZ,k,root[l],root[r],root[lca],root[pre[lca]]));
}
}
return 0;
}