BZOJ4012 [HNOI2015]开店

本文版权归ljh2000和博客园共有，欢迎转载，但须保留此声明，并给出原文链接，谢谢合作。

 

 

本文作者：ljh2000
作者博客：http://www.cnblogs.com/ljh2000-jump/
转载请注明出处，侵权必究，保留最终解释权！

 

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

 

 

正解：动态树分治

解题报告：

　　考虑动态树分治做法。

　　题目求的是所有点权在给定区间内的点到询问点的距离之和，那么我先不考虑点权要求，只求所有点到询问点的距离之和。

　　每次分治，我先找出重心，预处理出每个点到重心在分治结构上的父亲的距离（这个可以在往下分治的时候顺便做，下面会讲），以及每个点到重心的距离（包括一些祖先节点）。

　　那么我每次处理询问的时候，就可以先找到以这个点为重心的块，块内的贡献可以直接算，然后我沿着分治结构的父亲往上跳，每次处理一个点的子树中到询问点的距离。

　　考虑我每次会再算一次我之前做过的某个分治结构中的子树，所以我在往上跳的时候就可以预先减掉当前重心的子树中到分治结构的父亲的距离和，那么在上面在算的时候就可以抵消。　　

　　还需要加上分治结构中除了上次处理的那棵子树之外的子树节点个数*上次重心到这次重心的距离，注意这个距离不是简单的一条边的边权，分治结构中的父子关系并非真正的父子关系，需要直接调用两点之间的距离，才能保证正确性。

　　这道题还要保证点权的限定，那么就把点权存下来，每个重心保存其子树内的所有情况，按点权排序，每次就求[1,R]-[1,L-1]，相当于是每次求一个前缀和。

 

 

//It is made by ljh2000
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long LL;
const int MAXN = 150011;
const int MAXM = 300011;
int n,Q,ecnt,a[MAXN],first[MAXN],next[MAXM],to[MAXM],w[MAXM],A,quan[MAXN],qn;
int size[MAXN],father[MAXN],size2[MAXN];//father[x]表示x在分治结构中的父亲节点
bool vis[MAXN];
LL ans,D[MAXN],dis[MAXN];
inline void link(int x,int y,int z){ next[++ecnt]=first[x]; first[x]=ecnt; to[ecnt]=y; w[ecnt]=z; }
inline int getint(){
    int w=0,q=0; char c=getchar(); while((c<'0'||c>'9') && c!='-') c=getchar();
    if(c=='-') q=1,c=getchar(); while (c>='0'&&c<='9') w=w*10+c-'0',c=getchar(); return q?-w:w;
}

inline LL getlong(){
    LL w=0,q=0; char c=getchar(); while((c<'0'||c>'9') && c!='-') c=getchar();
    if(c=='-') q=1,c=getchar(); while (c>='0'&&c<='9') w=w*10+c-'0',c=getchar(); return q?-w:w;
}

struct node{ int val; LL dis,dis2; }tmp;
inline bool cmp(node q,node qq){ return q.val<qq.val; }
vector<node>ljh[MAXN];
struct Node{ int x; LL dis; }xzy;
vector<Node>wyh[MAXN];
inline bool ccmp(Node q,Node qq){ return q.x<qq.x; }

inline void dp(int x,int fa,int &rt,int &minl,int S){
	int nows=0; size[x]=1;
	for(int i=first[x];i;i=next[i]) {
		int v=to[i]; if(v==fa || vis[v]) continue;
		dp(v,x,rt,minl,S); size[x]+=size[v]; if(size[v]>nows) nows=size[v];
	}
	nows=max(nows,S-size[x]);
	if(minl==0 || nows<minl) rt=x,minl=nows/*!!!*/;
}

inline int getrt(int x,int S){
	int rt=0,mm=0;
	dp(x,0,rt,mm,S);
	return rt;
}

inline void dfs(int x,int fa,LL lei,int gen){
	tmp.val=a[x]; tmp.dis2=dis[x];//直接计算到上一个重心的距离
	tmp.dis=dis[x]=lei; ljh[gen].push_back(tmp);
	xzy.x=x; xzy.dis=dis[x]; wyh[gen].push_back(xzy);
	for(int i=first[x];i;i=next[i]) {
		int v=to[i]; if(v==fa || vis[v]) continue;
		dfs(v,x,lei+w[i],gen);
	}
}

inline void DFS(int x,int fa){ 
	size[x]=1;
	for(int i=first[x];i;i=next[i]) { 
		int v=to[i]; if(v==fa || vis[v]) continue;
		DFS(v,x); size[x]+=size[v];
	}
}

inline int solve(int x,int S){
	x=getrt(x,S); int gen=x; size2[x]=S; vis[x]=1;
	D[x]=dis[x]; tmp.dis=0; tmp.dis2=D[x]; tmp.val=a[x]; ljh[x].push_back(tmp);
	DFS(x,0); xzy.x=x; xzy.dis=0; wyh[x].push_back(xzy);
	for(int i=first[x];i;i=next[i]) {
		int v=to[i]; if(vis[v]) continue;
		dfs(v,x,w[i],gen);
	}
	for(int i=first[x];i;i=next[i]) {
		int v=to[i]; if(vis[v]) continue;
		father[solve(v,size[v])]=x;
	}
	tmp.val=-1; tmp.dis=0; tmp.dis2=0;
	ljh[x].push_back(tmp);
	sort(ljh[x].begin(),ljh[x].end(),cmp);
	for(int i=1,ss=ljh[x].size();i<ss;i++) ljh[x][i].dis+=ljh[x][i-1].dis,ljh[x][i].dis2+=ljh[x][i-1].dis2;
	sort(wyh[x].begin(),wyh[x].end(),ccmp);
	return x;
}

inline LL query(int x,int vv){
	if(x==0) return 0; LL tot=0,lei=0;
	int r,ss,ll,rr,mid,last_size=0,cun=x;
	for(;x;x=father[x]) {
		ss=ljh[x].size();
		ll=0; rr=ss-1; r=ss-1;
		while(ll<=rr) {
			mid=(ll+rr)>>1;
			if(ljh[x][mid].val<=vv) r=mid,ll=mid+1;
			else rr=mid-1;
		}

		ll=0; rr=wyh[x].size()-1;
		while(ll<=rr) {
			mid=(ll+rr)>>1;
			if(wyh[x][mid].x==cun) { lei=wyh[x][mid].dis; break; }
			if(wyh[x][mid].x<cun) ll=mid+1;
			else rr=mid-1;
		} 

		//lei+=D[last];不能直接累加！树的形态并不是分治结构中的那样！
		if(r>=1) {/*!!!*/
			tot+=ljh[x][r].dis;
			tot+=(r-last_size)*lei;
		}
		if(father[x]!=0) tot-=ljh[x][r].dis2;
		last_size=r;
	}
	return tot;
}

inline void work(){
	n=getint(); Q=getint(); A=getint(); int x,y,z; 
	for(int i=1;i<=n;i++) quan[i]=a[i]=getint(); quan[n+1]=A+1; sort(quan+1,quan+n+2); qn=unique(quan+1,quan+n+2)-quan-1;
	for(int i=1;i<=n;i++) a[i]=lower_bound(quan+1,quan+qn+1,a[i])-quan;
	for(int i=1;i<n;i++) {	x=getint(); y=getint(); z=getint();	link(x,y,z); link(y,x,z); }
	solve(1,n);
	LL L,R; ans=0;
	while(Q--) {
		x=getint(); L=getlong(); R=getlong(); L+=ans; L%=A; R+=ans; R%=A;
		if(L>R) swap(L,R);
		L=lower_bound(quan+1,quan+qn+1,L)-quan;
		R=upper_bound(quan+1,quan+qn+1,R)-quan; R--;
		ans=query(x,R)-query(x,L-1);
		printf("%lld\n",ans);
	}
}

int main()
{
    work();
    return 0;
}