[HNOI2015]接水果

题目描述

风见幽香非常喜欢玩一个叫做 osu!的游戏，其中她最喜欢玩的模式就是接水果。由于她已经DT FC 了The big black, 她觉得这个游戏太简单了，于是发明了一个更加难的版本。

首先有一个地图，是一棵由 n 个顶点、n-1 条边组成的树（例如图 1给出的树包含 8 个顶点、7 条边）。

这颗树上有 P 个盘子，每个盘子实际上是一条路径（例如图 1 中顶点 6 到顶点 8 的路径），并且每个盘子还有一个权值。第 i 个盘子就是顶点a_i到顶点b_i的路径(由于是树，所以从a_i到b_i的路径是唯一的)，权值为c_i。

接下来依次会有Q个水果掉下来，每个水果本质上也是一条路径，第i 个水果是从顶点 u_i 到顶点v_i 的路径。

幽香每次需要选择一个盘子去接当前的水果：一个盘子能接住一个水果，当且仅当盘子的路径是水果的路径的子路径（例如图1中从 3到7 的路径是从1到8的路径的子路径）。这里规定:从a 到b的路径与从b到 a的路径是同一条路径。

当然为了提高难度，对于第 i 个水果，你需要选择能接住它的所有盘子中，权值第 k_i 小的那个盘子，每个盘子可重复使用（没有使用次数的上限：一个盘子接完一个水果后，后面还可继续接其他水果，只要它是水果路径的子路径）。幽香认为这个游戏很难，你能轻松解决给她看吗？ < width="395" height="212" alt="" />

输入输出格式

输入格式：

第一行三个数 n和P 和Q，表示树的大小和盘子的个数和水果的个数。 接下来n-1 行，每行两个数 a、b，表示树上的a和b
之间有一条边。树中顶点按1到 n标号。 接下来 P 行，每行三个数 a、b、c，表示路径为 a 到 b、权值为 c
的盘子，其中0<=c<=10^9，a不等于b。 接下来Q行，每行三个数 u、v、k，表示路径为 u到 v的水果，其中
u不等于v，你需要选择第 k小的盘子，第k 小一定存在。

输出格式：

对于每个果子，输出一行表示选择的盘子的权值。

输入输出样例

输入样例#1： 复制

10 10 10
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
3 2 217394434
10 7 13022269
6 7 283254485
6 8 333042360
4 6 442139372
8 3 225045590
10 4 922205209
10 8 808296330
9 2 486331361
4 9 551176338
1 8 5
3 8 3
3 8 4
1 8 3
4 8 1
2 3 1
2 3 1
2 3 1
2 4 1
1 4 1

输出样例#1： 复制

442139372
333042360
442139372
283254485
283254485
217394434
217394434
217394434
217394434
217394434
http://www.cnblogs.com/NaVi-Awson/p/8150418.html

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 using namespace std;
 struct Node
 {
   int next,to;
 }edge[];
 struct FFF
 {
   int x1,x2,y1,y2,k;
 }opt[];
 struct ZYYS
 {
   int x,y,k,id;
 }query[],qa[],qb[];
 struct ALUGE
 {
   int x,y1,y2,d,id;
 }event[];
 int head[],num,dfn[],cnt,size[],n,son[],dep[],pa[],last[],top[];
 int c[],ans[],sum[],p,q,cntp;
 bool cmpe(ALUGE a,ALUGE b)
 {
   if (a.x==b.x) return a.id<b.id;
   return a.x<b.x;
 }
 bool cmpp(FFF a,FFF b)
 {
   return a.k<b.k;
 }
 bool cmpq(ZYYS a,ZYYS b)
 {
   return a.x<b.x;
 }
 void add(int u,int v)
 {
   num++;
   edge[num].next=head[u];
   head[u]=num;
   edge[num].to=v;
 }
 void dfs1(int x,int fa)
 {int i;
   size[x]=;
   son[x]=;
   for (i=head[x];i;i=edge[i].next)
     {
       int v=edge[i].to;
       if (v!=fa)
     {
       dep[v]=dep[x]+;pa[v]=x;
       dfs1(v,x);
       size[x]+=size[v];
       if (size[v]>=size[son[x]]) son[x]=v;
     }
     }
   last[x]=cnt;
 }
 void dfs2(int x,int tp,int fa)
 {int i;
   top[x]=tp;
   dfn[x]=++cnt;
   if (son[x]) dfs2(son[x],tp,x);
   for (i=head[x];i;i=edge[i].next)
     {
       int v=edge[i].to;
       if (v!=son[x]&&v!=fa)
     dfs2(v,v,x);
     }
   last[x]=cnt;
 }
 int LCA(int u,int v)
 {
   while (top[u]!=top[v])
     {
       if (dep[top[u]]<dep[top[v]]) swap(u,v);
       u=pa[top[u]];
     }
   if (dep[u]<dep[v]) return u;
   else return v;
 }
 int getson(int u,int v)
 {
   int last=;
   while (top[v]!=top[u])
     {
       last=top[v];
       v=pa[last];
     }
   if (u==v) return last;
   return son[u];
 }
 void update(int x,int d1,int y,int d2)
 {
   while (x<=n)
     {
       c[x]+=d1;
       x+=(x&(-x));
     }
   y++;
   while (y<=n)
     {
       c[y]+=d2;
       y+=(y&(-y));
     }
 }
 int get_sum(int x)
 {
   int s=;
   while (x)
     {
       s+=c[x];
       x-=x&(-x);
     }
   return s;
 }
 void solve(int l,int r,int st,int ed)
 {int i;
   if (st>ed) return;
   if (l==r)
     {
       for (i=st;i<=ed;i++)
     ans[query[i].id]=opt[l].k;
       return;
     }
   int mid=(l+r)/;
   int siz=;
   for (i=l;i<=mid;i++)
     {
       event[++siz]=(ALUGE){opt[i].x1,opt[i].y1,opt[i].y2,,};
       event[++siz]=(ALUGE){opt[i].x2,opt[i].y1,opt[i].y2,-,n+};
     }
   for (i=st;i<=ed;i++)
     {
       event[++siz]=(ALUGE){query[i].x,query[i].y,,,i};
     }
   sort(event+,event+siz+,cmpe);
   memset(c,,sizeof(c));
   for (i=;i<=siz;i++)
     {
       if (event[i].id<=ed&&event[i].id>=st) sum[event[i].id]=get_sum(event[i].y1);
       else update(event[i].y1,event[i].d,event[i].y2,-event[i].d);
     }
   int cnta=,cntb=;
   for (i=st;i<=ed;i++)
     {
       if (sum[i]>=query[i].k) qa[++cnta]=query[i];
       else qb[++cntb]=query[i],qb[cntb].k-=sum[i];
     }
   for (i=st;i<=st+cnta-;i++)
     query[i]=qa[i-st+];
   for (i=st+cnta;i<=ed;i++)
     query[i]=qb[i-st-cnta+];
   solve(l,mid,st,st+cnta-);
   solve(mid+,r,st+cnta,ed);
 }
 int main()
 {
   int i,u,v,d;
   cin>>n>>p>>q;
   for (i=;i<=n-;i++)
     {
       scanf("%d%d",&u,&v);
       add(u,v);add(v,u);
     }
   dfs1(,);dfs2(,,);
   for (i=;i<=p;i++)
     {
       scanf("%d%d%d",&u,&v,&d);
       if (dfn[u]>dfn[v]) swap(u,v);
       int w=LCA(u,v);
       if (u==w)
     {
       w=getson(u,v);
       if (dfn[w]>) opt[++cntp]=(FFF){,dfn[w]-,dfn[v],last[v],d};
       if (last[w]<n) opt[++cntp]=(FFF){dfn[v],last[v],last[w]+,n,d};
     }
       else
     {
       opt[++cntp]=(FFF){dfn[u],last[u],dfn[v],last[v],d};
     }
     }
   p=cntp;
   for (i=;i<=q;i++)
     {
       scanf("%d%d%d",&u,&v,&d);
       if (dfn[u]>dfn[v]) swap(u,v);
       query[i]=(ZYYS){dfn[u],dfn[v],d,i};
     }
   sort(opt+,opt+p+,cmpp);
   sort(query+,query+q+,cmpq);
   solve(,p,,q);
   for (i=;i<=q;i++)
     printf("%d\n",ans[i]);
 }