bzoj4012: [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

 

Orz thy

题解：http://blog.csdn.net/thy_asdf/article/details/50350793

code：

#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstring>
#include<algorithm>
#define maxn 150005
#define maxnode 10000010
using namespace std;
typedef long long int64;
char ch;
bool ok;
inline void read(int &x){
    for (ok=0,ch=getchar();!isdigit(ch);ch=getchar()) if (ch=='-') ok=1;
    for (x=0;isdigit(ch);x=x*10+ch-'0',ch=getchar());
    if (ok) x=-x;
}
int n,q,mod,u,a,b,c,l,r;
int64 ans;
struct Monster{int age,id;}list[maxn];
inline bool operator<(const Monster &a,const Monster &b){return a.age<b.age;}
int tot,now[maxn],son[maxn<<1],pre[maxn<<1],val[maxn<<1];
inline void put(int a,int b,int c){pre[++tot]=now[a],now[a]=tot,son[tot]=b,val[tot]=c;}
int idx,hson[maxn],top[maxn],num[maxn],fa[maxn],dep[maxn],siz[maxn],side[maxn],dis[maxn];
int64 sum[maxn],sumdis[maxn];
inline void dfs1(int u){
    int ans1=0,ans2=0,ans3=0; siz[u]=1;
    for (int p=now[u],v=son[p];p;p=pre[p],v=son[p])
        if (v!=fa[u]){
            fa[v]=u,dep[v]=dep[u]+1,dis[v]=dis[u]+val[p],dfs1(v),siz[u]+=siz[v];
            if (ans1<siz[v]) ans1=siz[v],ans2=v,ans3=p;
        }
    hson[u]=ans2,side[u]=ans3;
}
inline void dfs2(int u){
    int p=side[u],v=hson[u];
    if (v) top[v]=top[u],num[v]=++idx,sum[idx]=val[p],dfs2(v);
    for (p=now[u],v=son[p];p;p=pre[p],v=son[p])
        if (v!=fa[u]&&v!=hson[u]) top[v]=v,num[v]=++idx,sum[idx]=val[p],dfs2(v);
}
int root[maxn];
struct chairman_tree{
    struct Node{
        int64 val;
        int son[2],tim;
    }node[maxnode];
    int tot;
    inline void modify(int &p,int k,int l,int r,int a,int b){
        p=++tot,node[p]=node[k];
        if (l==a&&r==b){node[p].tim++;return;}
        node[p].val+=sum[b]-sum[a-1];
        int m=(l+r)>>1;
        if (b<=m) modify(node[p].son[0],node[k].son[0],l,m,a,b);
        else if (a<=m) modify(node[p].son[0],node[k].son[0],l,m,a,m),modify(node[p].son[1],node[k].son[1],m+1,r,m+1,b);
        else modify(node[p].son[1],node[k].son[1],m+1,r,a,b);
    }
    inline int64 query(int p,int l,int r,int a,int b){
        int64 res=1LL*(sum[b]-sum[a-1])*node[p].tim;
        if (l==a&&r==b) return res+node[p].val;
        int m=(l+r)>>1;
        if (b<=m) return res+query(node[p].son[0],l,m,a,b);
        else if (a<=m) return res+query(node[p].son[0],l,m,a,m)+query(node[p].son[1],m+1,r,m+1,b);
        else return res+query(node[p].son[1],m+1,r,a,b);
    }
}T;
inline void modify(int &rt,int u){
    int f1=top[u];
    while (f1!=1) T.modify(rt,rt,1,n-1,num[f1],num[u]),u=fa[f1],f1=top[u];
    if (u!=1) T.modify(rt,rt,1,n-1,num[hson[1]],num[u]);
}
inline int64 query(int rt,int u){
    int f1=top[u];
    int64 ans=0;
    while (f1!=1) ans+=T.query(rt,1,n-1,num[f1],num[u]),u=fa[f1],f1=top[u];
    if (u!=1) ans+=T.query(rt,1,n-1,num[hson[1]],num[u]);
    return ans;
}
int main(){
    read(n),read(q),read(mod);
    for (int i=1;i<=n;i++) read(list[i].age),list[i].id=i;
    sort(list+1,list+n+1);
    for (int i=1;i<n;i++) read(a),read(b),read(c),put(a,b,c),put(b,a,c);
    dfs1(1),top[1]=1,dfs2(1);
    for (int i=1;i<=n;i++) sum[i]+=sum[i-1];
    for (int i=1;i<=n;i++) sumdis[i]=sumdis[i-1]+dis[list[i].id];
    for (int i=1;i<=n;i++) modify(root[i]=root[i-1],list[i].id);
    while (q--){
        read(u),read(a),read(b);
        l=min((a+ans)%mod,(b+ans)%mod),r=max((a+ans)%mod,(b+ans)%mod);
        a=upper_bound(list+1,list+n+1,(Monster){l-1,0})-list,b=lower_bound(list+1,list+n+1,(Monster){r+1,0})-list-1;
        ans=1LL*(b-a+1)*dis[u]+(sumdis[b]-sumdis[a-1])-2LL*(query(root[b],u)-query(root[a-1],u));
        printf("%lld\n",ans);
    }
    return 0;
}