BZOJ 4012: [HNOI2015]开店 动态树分治 vector

4012: [HNOI2015]开店

Time Limit: 70 Sec  Memory Limit: 512 MB
Submit: 2182  Solved: 953
[Submit][Status][Discuss]

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

这道题的动态树分治做法挺显然的

维护线段树 下标为点权 权值为到达分治根距离

之后

你就可以和我一样log^2光荣mle了 呵呵呵

至于怎么优化空间 很简单 用vector存一下 每次二分就好了

写这个题是为了锻炼BJ羸弱无比的代码力

mle的时候 除了没开long long都还好 尽管打了一下午。。。靠 太颓了。。。

#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<string>
#include<bitset>
#include<queue>
#include<map>
#include<set>
using namespace std;

typedef long long ll;

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch<='9'&&ch>='0'){x=10*x+ch-'0';ch=getchar();}
	return x*f;
}
void print(ll x)
{if(x<0)putchar('-'),x=-x;if(x>=10)print(x/10);putchar(x%10+'0');}

const int N=150100,inf=0X3f3f3f3f;

int n,maxn,Q,A;

int last[N],ecnt;
struct EDGE{int to,nt,val;}e[N<<1];
inline void add(int u,int v,int val)
{e[++ecnt]=(EDGE){v,last[u],val};last[u]=ecnt;}

namespace bisection_method
{
	int st[N],top;
	
	void initial(int *age)
	{
		memcpy(st,age,sizeof(int)*(n+1));
		sort(st+1,st+1+n);
		register int i;
		top=1;
		for(i=2;i<=n;++i)
			if(st[i]!=st[i-1])
				st[++top]=st[i];
		maxn=top;
	}
	
	inline int lower_bound(int x)
	{
		int l(1),r(top),mid;
		while(l<=r)
		{
			mid=(l+r)>>1;
			st[mid]<=x ? l=mid+1 : r=mid-1;
		}
		return l-1;
	}
	
	inline int upper_bound(int x)
	{
		int l(1),r(top),mid;
		while(l<=r)
		{
			mid=(l+r)>>1;
			st[mid]>=x ? r=mid-1 : l=mid+1;
		}
		return r+1;
	}
}

#define BM bisection_method

int anc[N][20],dep[N],val_dis[N];

void lca_init(int u)
{
	for(int i=1;(1<<i)<=dep[u];++i)
		anc[u][i]=anc[anc[u][i-1]][i-1];
	for(int i=last[u],v;i;i=e[i].nt)
		if((v=e[i].to)!=anc[u][0])
			anc[v][0]=u,
			dep[v]=dep[u]+1,
			val_dis[v]=val_dis[u]+e[i].val,lca_init(v);
}

inline int get_lca(int u,int v)
{
	if(dep[u]<dep[v]) swap(u,v);
	int len=dep[u]-dep[v];
	for(int i=0;(1<<i)<=len;++i)
		if((len>>i)&1)
			u=anc[u][i];
	if(u==v) return u;
	for(int i=18;~i;--i)
		if(anc[u][i]!=anc[v][i])
			u=anc[u][i],v=anc[v][i];
	return anc[u][0];
}

int get_dis(int u,int v)
{
	int lca(get_lca(u,v));
	return val_dis[u]+val_dis[v]-(val_dis[lca]<<1);
}

struct president_tree{int ls,rs,num;ll val;}tr[(N<<7)];
int Root[N][2],sz;

void insert(int &k,int l,int r,int x,int val)
{
	if(!k) k=++sz;
	tr[k].val+=val;tr[k].num++;
	if(l==r) return ;
	int mid=l+r>>1;
	x<=mid ? insert(tr[k].ls,l,mid,x,val) : insert(tr[k].rs,mid+1,r,x,val);
}

ll query_val(int k,int l,int r,int x,int y)
{
	if(!k) return 0;
	if(l>=x && r<=y) return tr[k].val;
	int mid=l+r>>1;ll s(0),t(0);
	if(x<=mid) s=query_val(tr[k].ls,l,mid,x,y);
	if(y>mid) t=query_val(tr[k].rs,mid+1,r,x,y);
	return s+t;
}

int query_num(int k,int l,int r,int x,int y)
{
	if(!k) return 0;
	if(l>=x && r<=y) return tr[k].num;
	int mid=l+r>>1,s(0),t(0);
	if(x<=mid) s=query_num(tr[k].ls,l,mid,x,y);
	if(y>mid) t=query_num(tr[k].rs,mid+1,r,x,y);
	return s+t;
}

int age[N];

bool vis[N];
int size[N],f[N],sum,root;

void getroot(int u,int pre)
{
	size[u]=1;f[u]=0;
	for(int i=last[u],v;i;i=e[i].nt)
		if(!vis[v=e[i].to] && v!=pre)
		{
			getroot(v,u);
			size[u]+=size[v];
			f[u]=max(f[u],size[v]);
		}
	f[u]=max(f[u],sum-size[u]);
	if(f[u]<f[root]) root=u;
}

void seek(int rt,int u,int pre,int dis,int opt)
{
	insert(Root[rt][opt],1,maxn,age[u],dis);
	for(int i=last[u],v;i;i=e[i].nt)
		if(!vis[v=e[i].to] && v!=pre)
			seek(rt,v,u,dis+e[i].val,opt);
}

int fa[N];

void init(int u)
{
	vis[u]=1;
	seek(u,u,0,0,0);
	for(int i=last[u],v;i;i=e[i].nt)
		if(!vis[v=e[i].to])
		{
			sum=size[v];root=0;getroot(v,u);
			seek(root,v,0,e[i].val,1);
			fa[root]=u;init(root);
		}
}

ll solve(int u,int l,int r)
{
	if(l>r) return 0;
	int pos=u;ll res(0);
	res+=query_val(Root[u][0],1,maxn,l,r);
	while(fa[u])
	{
		res+=query_val(Root[fa[u]][0],1,maxn,l,r)-query_val(Root[u][1],1,maxn,l,r);
		res+=1ll*get_dis(fa[u],pos)*(query_num(Root[fa[u]][0],1,maxn,l,r)-query_num(Root[u][1],1,maxn,l,r));
		u=fa[u];
	}
	return res;
}

int main()
{
	n=read();Q=read();A=read();
	register int i,u,v,val;
	for(i=1;i<=n;++i) age[i]=read();
	for(i=1;i<n;++i)
		u=read(),v=read(),val=read(),
		add(u,v,val),add(v,u,val);
	
	BM::initial(age);
	for(i=1;i<=n;++i) age[i]=BM::lower_bound(age[i]);
	
	f[0]=inf,sum=n;
	lca_init(1);getroot(1,0);init(1);
	
	register int l,r;
	ll ans(0);
	while(Q--)
	{
		u=read();l=(read()+ans)%A;r=(read()+ans)%A;
		if(l>r) swap(l,r);
		l=BM::upper_bound(l),r=BM::lower_bound(r);
		ans=solve(u,l,r);
		print(ans);puts("");
	}
	return 0;
}