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[N],to[N],nxt[N],c[N];
int deep[N],top[N],F[N],s[N],son[N],dis2[N];
int size[N],f[N],dis[N],FA[N],vis[N];
int cnt,root,SIZE,SON[N][3],num[N];
int X[N];
struct data{
    int dis,w,xh;
    bool operator<(const data&b)const{
	return w<b.w;
    }
};
vector<data>p[N];
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);
    }
}