[bzoj4009][HNOI2015]接水果

　　论不会整体二分的悲伤。。代码长度感人。。然而似乎并不慢。。

　　看到树上路径之间的各种关系大概都会想到dfs序吧。。

　　然而还是看了题解= =：http://blog.csdn.net/thy_asdf/article/details/50363672

　　题解说得很清晰了。。就是将盘子弄成矩形，水果就看成点。询问覆盖某个点的矩形中，第k小的权值。

引用一下：“

分情况：如果u!=lca(u,v)

那么水果的两端点(a,b)就在盘子两端点的子树中

用dfs序来表示，就是dfn[u]<=a<=last[u],dfn[v]<=b<=last[v]

last[i]表示i的子树的最大 dfn

如果u==lca(u,v)

这时稍微有一些区别，w表示u的儿子且是v的祖先的点，注意不是u

那么b还是在v子树中，a在除了w子树之外的所有点中

dfn[v]<=b<=last[v]，1<=a<=dfn[w]-1||last[w]+1<=a<=n  ”

 　　注：原文各不等式中的a和b应该是dfn[a]和dfn[b]....

　　求w的话。。首先用last值判断u是否是v的祖先。然后用链剖搞。。

　　注意一下，当u是v的祖先时，假如盘子(u,v)是水果(a,b)的子路径，那么有两种可能：（令dfn[u]<dfn[v],dfn[a]<dfn[b]）

　　　　1、dfn[v]<=dfn[b]<=last[v],并且1<=dfn[a]<=dfn[w]-1;（路径：a->w->v->b）

　　　　2、last[w]+1<=dfn[b]<=n,并且dfn[v]<=dfn[a]<=last[v]。（路径：b->w->v->a）

　　实现的时候，我们可以把每个盘子，按照它的第一个不等式的左边的值升序排序一下。（dfn[v]或者last[w]+1,记为v），把水果也按dfn[b]升序排序一下。

　　树套树的部分，外层是1~n的区间，表示右边那个不等式（也就是第二维），内层记录对应区间内的各个权值

　　外层就是区间修改，单点查询了。。（我写了线段树来把修改的区间拆成logn个小区间= =。。）内层用平衡树或者线段树。。随意。

　　每次把符合v<=dfn[b]的盘子插进树套树里面，优先队列关键字为第一个不等式右边的值（小根堆）。。。插入完再把不符合的盘子删掉。。。（语死早TAT

　　这样就保证当前树套树里面的盘子都是符合第一个不等式的了。。。

　　时间复杂度和空间复杂度都是O(n log²n)。。。

注。。代码里面用的是size。。last[x]==dfn[x]+size[x]-1;

#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn=66233;
const int maxm=maxn*18*18;
struct zs{int too,pre;}e[maxn<<1];
struct zs1{int id,V;};
struct zs2{int a,b,K,id;}ask[maxn];
struct zs3{int num,id;}A[maxn<<1];
struct poi{
    int l1,r1,l2,r2,val;
}p[maxn<<1];int pnum;//盘子s 
int last[maxn],tot;
int dfn[maxn],size[maxn],bel[maxn],fa[maxn],next[maxn],dep[maxn],tim;
int l[maxm],r[maxm],sz[maxm],tt;
int rt[65539<<1];
int i,j,n,m,Q,x,y,a,b,nowans,zkw;
priority_queue<zs1>q;
int C[maxn],cnt;
int ans[maxn];

inline void insert(int a,int b){
    e[++tot].too=b,e[tot].pre=last[a],last[a]=tot;
    e[++tot].too=a,e[tot].pre=last[b],last[b]=tot;
}
void dfs1(int x){
    size[x]=1,dfn[x]=++tim,dep[x]=dep[fa[x]]+1;
    for(register int i=last[x],to=e[i].too;i;to=e[i=e[i].pre].too)if(to!=fa[x])
        fa[to]=x,dfs1(to),size[x]+=size[to];
}
void dfs2(int x,int chain){
    register int i,mx=0;
    for(bel[x]=chain,i=last[x];i;i=e[i].pre)if(e[i].too!=fa[x]&&size[e[i].too]>=size[mx])mx=e[i].too;
    if(!mx)return;
    next[x]=mx,dfs2(mx,chain);
    for(i=last[x];i;i=e[i].pre)if(e[i].too!=fa[x]&&e[i].too!=mx)dfs2(e[i].too,e[i].too);
}
int getnext(int x,int y){
    int pre=0;
    while(bel[x]!=bel[y]){
        pre=bel[y],y=fa[bel[y]];
    }
    return y==x?pre:next[x];
}//-----------------------------链剖 

int num[maxn],sum;
inline void getkth(int L,int R,int K){
    if(L==R){nowans=C[L];/*printf("              %d
",L);*/return;}
    int mid=(L+R)>>1,lsz=0;register int i;
    for(i=sum;i;i--)lsz+=sz[l[num[i]]];
    if(K<=lsz){
        for(i=sum;i;i--)num[i]=l[num[i]];
        getkth(L,mid,K);
    }else{
        for(i=sum;i;i--)num[i]=r[num[i]];
        getkth(mid+1,R,K-lsz);
    }
}
inline void ins(int &x,int L,int R,int v){
    if(!x)x=++tt;sz[x]++;
    if(L==R)return;int mid=(L+R)>>1;
    if(v<=mid)ins(l[x],L,mid,v);else ins(r[x],mid+1,R,v);
}
inline void del(int x,int L,int R,int v){
    sz[x]--;
    if(L==R)return;int mid=(L+R)>>1;
    if(v<=mid)del(l[x],L,mid,v);else del(r[x],mid+1,R,v);
}//-----------------------------sgt inside

inline void add(int x,int L,int R,int c,int d,int v){
    if(c>d)return;
    if(c<=L&&d>=R){ins(rt[x],1,cnt,v);/*printf("add:   %d--%d %d
",L,R,v);*/return;}
    int mid=(L+R)>>1;
    if(c<=mid)add(x<<1,L,mid,c,d,v);
    if(d>mid) add(x<<1|1,mid+1,R,c,d,v);
}
inline void dec(int x,int L,int R,int c,int d,int v){
    if(c>d)return;
    if(c<=L&&d>=R){del(rt[x],1,cnt,v);/*printf("del:   %d--%d %d
",L,R,v);*/return;}
    int mid=(L+R)>>1;
    if(c<=mid)dec(x<<1,L,mid,c,d,v);
    if(d>mid) dec(x<<1|1,mid+1,R,c,d,v);
}//-----------------------------sgt outside//可以合成一个过程然而太懒 

inline void change(int id,bool ADD){
    int v=p[id].val,l=p[id].l2,r=p[id].r2;
    if(ADD)add(1,1,zkw+1,l,r,v);else dec(1,1,zkw+1,l,r,v);
}
inline int kth(int dfna,int K){int tmp=0;
    sum=0;for(int x=dfna+zkw;x;x>>=1)num[++sum]=rt[x],tmp+=sz[rt[x]];
    if(tmp<K)return -1;
    getkth(1,cnt,K);
    return nowans;
}
int ra,fh;char rx;
inline int read(){
    rx=getchar(),ra=0,fh=1;
    while((rx<'0'||rx>'9')&&rx!='-')rx=getchar();
    if(rx=='-')fh=-1,rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra*fh;
}
bool cmp(poi a,poi b){return a.l1<b.l1;}
bool cmp1(zs2 x,zs2 y){return dfn[x.b]<dfn[y.b];}
bool cmp2(zs3 a,zs3 b){return a.num<b.num;}
bool operator <(zs1 a,zs1 b){return a.V>b.V;}
inline void insert_p(int l1,int r1,int l2,int r2,int v){
    p[++pnum].l1=l1,p[pnum].r1=r1,p[pnum].val=v,p[pnum].l2=l2,p[pnum].r2=r2,A[pnum].id=pnum,A[pnum].num=v;
}
int main(){
    n=read(),m=read(),Q=read();
    for(zkw=1;zkw<=n;zkw<<=1);zkw--;
    for(i=1;i<n;i++)x=read(),y=read(),insert(x,y);
    dfs1(1);dfs2(1,1);
    for(i=1;i<=m;i++){
        int u=read(),v=read(),val=read();
        if(dfn[u]>dfn[v])swap(u,v);
        bool flag=(dfn[v]<dfn[u]+size[u]);
        if(!flag)insert_p(dfn[v],dfn[v]+size[v]-1,dfn[u],dfn[u]+size[u]-1,val);
        else{
            int z=getnext(u,v);
            if(dfn[z]>1)insert_p(dfn[v],dfn[v]+size[v]-1,1,dfn[z]-1,val);
            if(dfn[z]+size[z]<=n)insert_p(dfn[z]+size[z],n,dfn[v],dfn[v]+size[v]-1,val);
        }
    }
    sort(A+1,A+1+pnum,cmp2);
    for(i=1;i<=pnum;i++){
        if(i==1||A[i].num!=A[i-1].num)C[++cnt]=A[i].num;
        p[A[i].id].val=cnt;
    }
    sort(p+1,p+1+pnum,cmp);
    for(i=1;i<=Q;i++){
        ask[i].a=read(),ask[i].b=read(),ask[i].K=read(),ask[i].id=i;
        if(dfn[ask[i].a]>dfn[ask[i].b])swap(ask[i].a,ask[i].b);
    }
    sort(ask+1,ask+1+Q,cmp1);
    int now=0;
    for(i=1;i<=Q;i++){
        a=ask[i].a,b=ask[i].b;

        while(now<pnum&&p[now+1].l1<=dfn[b])++now,change(now,1),q.push((zs1){now,p[now].r1});
        while(!q.empty()&&q.top().V<dfn[b])change(q.top().id,0),q.pop();
    

        ans[ask[i].id]=kth(dfn[a],ask[i].K);
    }
    for(i=1;i<=Q;i++)printf("%d
",ans[i]);
    return 0;
}