bzoj4012: [HNOI2015]开店

 

人生哲学。最近她们灵机一动，打算在幻想乡开一家小店来做生意赚点钱。这样的

想法当然非常好啦，但是她们也发现她们面临着一个问题，那就是店开在哪里，面

向什么样的人群。很神奇的是，幻想乡的地图是一个树形结构，幻想乡一共有 n

个地方，编号为 1 到 n，被 n-1 条带权的边连接起来。每个地方都住着一个妖怪，

其中第 i 个地方的妖怪年龄是 x_i。妖怪都是些比较喜欢安静的家伙，所以它们并

不希望和很多妖怪相邻。所以这个树所有顶点的度数都小于或等于 3。妖怪和人一

样，兴趣点随着年龄的变化自然就会变化，比如我们的 18 岁少女幽香和八云紫就

比较喜欢可爱的东西。幽香通过研究发现，基本上妖怪的兴趣只跟年龄有关，所以

幽香打算选择一个地方 u（u为编号），然后在 u开一家面向年龄在 L到R 之间（即

年龄大于等于 L、小于等于 R）的妖怪的店。也有可能 u这个地方离这些妖怪比较

远，于是幽香就想要知道所有年龄在 L 到 R 之间的妖怪，到点 u 的距离的和是多

少（妖怪到 u 的距离是该妖怪所在地方到 u 的路径上的边的权之和） ，幽香把这个

称为这个开店方案的方便值。幽香她们还没有决定要把店开在哪里，八云紫倒是准

备了很多方案，于是幽香想要知道，对于每个方案，方便值是多少呢。

 

Input

 第一行三个用空格分开的数 n、Q和A，表示树的大小、开店的方案个数和妖

怪的年龄上限。 

第二行n个用空格分开的数 x_1、x_2、…、x_n，x_i 表示第i 个地点妖怪的年

龄，满足0<=x_i<A。(年龄是可以为 0的，例如刚出生的妖怪的年龄为 0。) 

接下来 n-1 行，每行三个用空格分开的数 a、b、c，表示树上的顶点 a 和 b 之

间有一条权为c(1 <= c <= 1000)的边，a和b 是顶点编号。 

接下来Q行，每行三个用空格分开的数 u、 a、 b。对于这 Q行的每一行，用 a、

b、A计算出 L和R，表示询问“在地方 u开店，面向妖怪的年龄区间为[L,R]的方

案的方便值是多少”。对于其中第 1 行，L 和 R 的计算方法为：L=min(a%A,b%A), 

R=max(a%A,b%A)。对于第 2到第 Q行，假设前一行得到的方便值为 ans，那么当

前行的 L 和 R 计算方法为： L=min((a+ans)%A,(b+ans)%A), 

R=max((a+ans)%A,(b+ans)%A)。 

 

Output

对于每个方案，输出一行表示方便值。 

 

Sample Input

10 10 10
0 0 7 2 1 4 7 7 7 9
1 2 270
2 3 217
1 4 326
2 5 361
4 6 116
3 7 38
1 8 800
6 9 210
7 10 278
8 9 8
2 8 0
9 3 1
8 0 8
4 2 7
9 7 3
4 7 0
2 2 7
3 2 1
2 3 4

Sample Output

1603
957
7161
9466
3232
5223
1879
1669
1282
0

HINT

 

 满足 n<=150000,Q<=200000。对于所有数据，满足 A<=10^9

 

题解

　　其实就是动态点分治的模板题……但是如果是动态点分套线段树的话看起来会mle，于是我们可以开个数组对于每个子树按权值从小到大记录在当前子树里点的信息（是的我知道你们c++有vector不用那么麻烦），然后算个前缀和在上面二分查找一减就行了……

　　其实还挺好写的……

program j01;
const maxn=300086;
var head:array[0..maxn]of longint;
    data:array[0..2*maxn]of int64;
    q,next:array[0..2*maxn]of longint;
    size,now,maxu:array[0..maxn]of longint;
    st:array[0..22,0..2*maxn]of longint;
    fa:array[0..maxn]of longint;
    dep:array[0..maxn]of int64;
    sum1,sum2:array[0..20*maxn]of int64;
    root,rosize,mnsize:longint;
    fir:array[0..maxn]of longint;
    vis:array[0..maxn]of boolean;
    bin:array[0..2*maxn]of longint;
    u,v,w,n,m,tt,aa,i,time,tot,j:longint;
    a,ps:array[0..maxn]of longint;
    line:array[0..20*maxn]of longint;
    bg,ed:array[0..maxn]of longint;
    ax,bx,ll,rr,ans:int64;


function max(a,b:int64):int64;inline;begin if a>b then exit(a) else exit(b);end;
function min(a,b:int64):int64;inline;begin if a<b then exit(a) else exit(b);end;

procedure swap(var a,b:longint);
var c:longint;
begin
  c:=a;a:=b;b:=c;
end;

procedure addd(u,v,w:longint);
begin
  inc(tt);q[tt]:=v;data[tt]:=w;next[tt]:=head[u];head[u]:=tt;
end;

procedure sort(l,r:longint);
var i,j,x,y:longint;
begin
  i:=l;j:=r;x:=a[ps[(i+j)div 2]];
  repeat
    while a[ps[i]]<x do inc(i);
    while x<a[ps[j]] do dec(j);
    if i<=j then
    begin
      swap(ps[i],ps[j]);
      inc(i);dec(j);
    end;
  until i>j;
  if i<r then sort(i,r);
  if l<j then sort(l,j);
end;

procedure dfsst(i,pre:longint);
var j:longint;
begin
  inc(time);fir[i]:=time;st[0,time]:=i;
  j:=head[i];
  while j>0 do
  begin
    if q[j]<>pre then
    begin
      dep[q[j]]:=dep[i]+data[j];dfsst(q[j],i);
      inc(time);st[0,time]:=i;
    end;
    j:=next[j];
  end;
end;

function min_st(a,b:longint):longint;
begin
  if fir[a]<fir[b] then exit(a) else exit(b);
end;

procedure getst;
var i,j:longint;
begin
  bin[1]:=0;
  for i:=2 to time do
    if i and(i-1)=0 then bin[i]:=bin[i-1]+1 else bin[i]:=bin[i-1];
  for i:=1 to bin[time] do
    for j:=1 to time+1-(1 shl i) do
      st[i,j]:=min_st(st[i-1,j],st[i-1,j+(1 shl(i-1))]);
end;

function lca(u,v:longint):longint;
var k:longint;
begin
  u:=fir[u];v:=fir[v];if u>v then swap(u,v);k:=bin[v-u+1];
  exit(min_st(st[k,u],st[k,v+1-(1 shl k)]));
end;

function dist(u,v:longint):int64;
begin
  exit(dep[u]+dep[v]-2*dep[lca(u,v)]);
end;

procedure dfssize(i,pre:longint);
var j:longint;
begin
  size[i]:=1;maxu[i]:=0;j:=head[i];
  while j>0 do
  begin
    if(vis[q[j]]=false)and(q[j]<>pre)then
    begin
      dfssize(q[j],i);inc(size[i],size[q[j]]);
      maxu[i]:=max(maxu[i],size[q[j]]);
    end;
    j:=next[j];
  end;
end;

procedure dfsroot(i,pre:longint);
var j:longint;
begin
  maxu[i]:=max(maxu[i],rosize-size[i]);
  if maxu[i]<mnsize then begin root:=i;mnsize:=maxu[i]; end;
  j:=head[i];
  while j>0 do
  begin
    if(vis[q[j]]=false)and(q[j]<>pre)then dfsroot(q[j],i);
    j:=next[j];
  end;
end;

procedure dfstree(i,pre:longint);
var j,ro:longint;
begin
  dfssize(i,0);mnsize:=maxlongint;rosize:=size[i];
  dfsroot(i,0);ro:=root;now[ro]:=tot;bg[ro]:=tot;tot:=tot+rosize;ed[ro]:=tot-1;
  vis[ro]:=true;fa[ro]:=pre;
  j:=head[ro];
  while j>0 do
  begin
    if(vis[q[j]]=false)then dfstree(q[j],ro);
    j:=next[j];
  end;
end;

procedure ins(x:longint);
var u,f:longint;d:int64;
begin
  u:=x;sum1[now[u]]:=0;
  while fa[u]<>0 do
  begin
    f:=fa[u];d:=dist(x,f);
    sum1[now[f]]:=d;sum2[now[u]]:=d;
    u:=f;
  end;
  u:=x;
  while u>0 do
  begin
    line[now[u]]:=x;inc(now[u]);u:=fa[u];
  end;
end;

function finddown(l,r,x:longint):longint;
var mid:longint;
begin
  if x<=a[line[l]] then exit(l-1);
  while l<r do
  begin
    mid:=(l+r)div 2;
    if a[line[mid+1]]>=x then r:=mid else l:=mid+1;
  end;
  exit(l);
end;

function findup(l,r,x:longint):longint;
var mid:longint;
begin
  if x<a[line[l]] then exit(l-1);
  if x>=a[line[r]] then exit(r);
  while l<r do
  begin
    mid:=(l+r)div 2;
    if a[line[mid+1]]>x then r:=mid else l:=mid+1;
  end;
  exit(l);
end;

procedure solve(x:longint);
var u,f,l,r,pl,pr:longint;d:int64;
begin
  l:=finddown(bg[x],ed[x],ll);r:=findup(bg[x],ed[x],rr);
  inc(ans,sum1[r]-sum1[l]);u:=x;pl:=l;pr:=r;
  while fa[u]<>0 do
  begin
    f:=fa[u];d:=dist(x,f);
    l:=finddown(bg[f],ed[f],ll);r:=findup(bg[f],ed[f],rr);
    ans:=ans+sum1[r]-sum1[l]+d*(r-l);
    ans:=ans-(sum2[pr]-sum2[pl])-d*(pr-pl);
    u:=f;pl:=l;pr:=r;
  end;
end;

begin
  readln(n,m,aa);
  for i:=1 to n do begin read(a[i]);ps[i]:=i; end;
  sort(1,n);
  for i:=1 to n-1 do
  begin
    readln(u,v,w);addd(u,v,w);addd(v,u,w);
  end;
  dfsst(1,0);getst;
  tot:=1;dfstree(1,0);
  for i:=1 to n do ins(ps[i]);
  for i:=1 to tot do
  begin
    inc(sum1[i],sum1[i-1]);inc(sum2[i],sum2[i-1]);
  end;
  for i:=1 to m do
  begin
    readln(u,ax,bx);
    ll:=min((ax+ans)mod aa,(bx+ans)mod aa);
    rr:=max((ax+ans)mod aa,(bx+ans)mod aa);
    ans:=0;solve(u);writeln(ans);
  end;
end.