bzoj 4012: [HNOI2015]开店

Description

风见幽香有一个好朋友叫八云紫，她们经常一起看星星看月亮从诗词歌赋谈到

人生哲学。最近她们灵机一动，打算在幻想乡开一家小店来做生意赚点钱。这样的
想法当然非常好啦，但是她们也发现她们面临着一个问题，那就是店开在哪里，面
向什么样的人群。很神奇的是，幻想乡的地图是一个树形结构，幻想乡一共有 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

Source

HNOI 2015 DAY2的唯一一道可做题...整体思路来说只有两个点比较关键...

在线主席树的做法与LNOI 2014 LCA 很像...

这个题用动态点分治的思路解决的方向是比较明显的...

用点分治的基本思想,我们先考虑一个点的管辖子树中的贡献是多少:

这个比较简单,把一个点管辖的的连通块中的所有点在getdeep的时候存下来,然后按年龄排序记录一个前缀和,询问时相减即可...

用普通动态点分治的做法就是不断跳重心的爸爸

但不过上层的重心里的答案包括了当前层重心的答案,这样就很尴尬了,不好减去重复的...

题目中有一句很有意思的话:所有顶点的度数都小于等于3...

我一直不知道这句话有什么用,所以就一直卡在query上...

直到在Anson(叶大佬)那里取经回来后我才知道这个东西到底有什么用...

我们不想怎么去减掉重复的答案,而是让所有的答案加起来不重复...

于是那句诡异的话就有用了,一个重心顶多有三个儿子,那么我们考虑这个重心和他的爸爸的所有儿子...

他爸爸的除他之外的所有儿子的贡献显然是可以全部统计进答案的...然后只需要单独判断他的爸爸是否满足条件即可

然后这个题就这样做完了,简直不可思议;(话说动态数组lower_bound返回迭代器指针是真心操...);

附上代码:

// MADE BY QT666
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<iostream>
#include<queue>
#include<set>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#define lson num<<1
#define rson num<<1|1
#define int long long
using namespace std;
typedef long long ll;
const int N=300050;
const int Inf=2147483647;
int gi()
{
int x=0,flag=1;
char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-') flag=-1;ch=getchar();}
while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
return x*flag;
}
int head
,to
,nxt
,c
;
int deep
,top
,F
,s
,son
,dis2
;
int size
,f
,dis
,FA
,vis
;
int cnt,root,SIZE,SON
[3],num
;
int X
;
struct data{
int dis,w,xh;
bool operator<(const data&b)const{
return w<b.w;
}
};
vector<data>p
;
void lnk(int x,int y,int v){
to[++cnt]=y,c[cnt]=v,nxt[cnt]=head[x],head[x]=cnt;
to[++cnt]=x,c[cnt]=v,nxt[cnt]=head[y],head[y]=cnt;
}
void dfs1(int x,int fa){
deep[x]=deep[fa]+1;s[x]=1;
for(int i=head[x];i;i=nxt[i]){
int y=to[i];
if(y!=fa){
dis2[y]=dis2[x]+c[i];
dfs1(y,x);F[y]=x;s[x]+=s[y];
if(s[y]>s[son[x]]) son[x]=y;
}
}
}
void dfs2(int x,int fa){
top[x]=fa;
if(son[x]) dfs2(son[x],fa);
for(int i=head[x];i;i=nxt[i]){
int y=to[i];
if(y!=F[x]&&y!=son[x]) dfs2(y,y);
}
}
int LCA(int u,int v){
int x=u,y=v;
while(top[x]!=top[y]){
if(deep[top[x]]<deep[top[y]]) swap(x,y);
x=F[top[x]];
}
if(deep[x]<deep[y]) swap(x,y);
return dis2[u]+dis2[v]-2*dis2[y];
}
void getroot(int x,int fa){
size[x]=1;f[x]=0;
for(int i=head[x];i;i=nxt[i]){
int y=to[i];
if(y!=fa&&!vis[y]){
getroot(y,x);
size[x]+=size[y];
f[x]=max(f[x],size[y]);
}
}
f[x]=max(f[x],SIZE-size[x]);
if(f[x]<f[root]) root=x;
}
void getdeep(int x,int fa){
p[root].push_back((data){dis[x],X[x],0});
for(int i=head[x];i;i=nxt[i]){
int y=to[i];
if(y!=fa&&!vis[y]){
dis[y]=dis[x]+c[i];
getdeep(y,x);
}
}
}
void work2(int x,int y){
root=0,SIZE=size[x];
getroot(x,0),dis[x]=y;getdeep(x,0);
sort(p[root].begin(),p[root].end());
int ret=0;
for(int k=0;k<p[root].size();k++){
ret+=p[root][k].dis;
p[root][k].dis=ret;p[root][k].xh=k+1;
}
}
void work(int x) {
vis[x]=1;
for(int i=head[x];i;i=nxt[i]) {
int y=to[i];
if(!vis[y]) {
work2(y,c[i]);
FA[root]=x; SON[x][++num[x]]=root;
work(root);
}
}
}
int query(int x,int l,int r) {
int ret=0, y2=0;
for(int i=x;i;i=FA[i]) {
int dis1=LCA(x,i);
if(X[i]>=l&&X[i]<=r) ret+=dis1;
for(int j=1;j<=num[i];j++) {
int y=SON[i][j];
if(y!=y2) {
vector <data> :: iterator L;
vector <data> :: iterator R;
L=lower_bound(p[y].begin(),p[y].end(),(data){0,l,0});
R=upper_bound(p[y].begin(),p[y].end(),(data){0,r,0});
L--;R--;
int x1,x2,num1,num2;
if(L<p[y].begin()) x1=num1=0;
else x1=L->dis,num1=L->xh;
if(R<p[y].begin()) x2=num2=0;
else x2=R->dis,num2=R->xh;
ret+=x2-x1+(num2-num1)*dis1;
}
}
y2=i;
}
return ret;
}
main(){
int n=gi(),Q=gi(),A=gi(),x,y,z;
for(int i=1;i<=n;i++) X[i]=gi();
for(int i=1;i<n;i++){
x=gi(),y=gi(),z=gi();
lnk(x,y,z);
}
dfs1(1,0);dfs2(1,1);
root=0;f[0]=Inf;SIZE=n;getroot(1,0);
work(root);int u,a,b,ans,l,r;
for(int i=1;i<=Q;i++){
u=gi(),a=gi(),b=gi();
if(i==1){
l=min(a%A,b%A),r=max(a%A,b%A);
}
else{
l=min((a+ans)%A,(b+ans)%A),r=max((a+ans)%A,(b+ans)%A);
}
ans=query(u,l,r);
printf("%lld\n",ans);
}
}