BZOJ 4012 [HNOI2015]开店 (树分治+二分)

题目大意：

给你一棵树，边有边权，点有点权，有很多次询问，求点权$\in[l,r]$的所有节点到某点$x$的距离之和，强制在线

感觉这个题应该放在动态点分之前做= =

套路方法和动态点分是一样的

每次询问，从$x$开始，沿着点分树的树链向上统计，计算当前点的点分树的答案，然后去掉包含$x$的那棵点分子树的答案

$x$节点在点分树内的 所有祖先节点 对于答案的贡献都有两个部分

1.除了包含$x$的点分子树 的所有权值$\in[l,r]$的节点到 当前祖先节点 的距离

2.合法节点数量*当前祖先节点到$x$的距离

而这道题是静态的，不用每个节点都开线段树，改成$vector$，每次都在上面二分就好了

具体实现

每个节点都开一个$vector$，设当前的点分节点是$x$，把$x$点分树内的所有子节点推进去，按照点权排序，再统计一下到$x$距离的前缀和

统计$[l,r]$的答案时，只需要在$vector$里二分出右端点查询dis的前缀和，还要加上点数总和(即右端点下标) *当前 点分树节点 到 询问节点 的距离，再利用前缀和容斥$calc(r)-calc(l-1)$即可

时间仍然是$O(nlog^{2}n)$，但空间变成了$O(nlogn)$

由于用了$vector$常数大的一批但我也懒得优化了

 #include <vector>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #define N1 150100
 #define ll long long
 #define dd double
 #define inf 0x3f3f3f3f3f3f3f3fll
 using namespace std;

 int gint()
 {
     int ret=,fh=;char c=getchar();
     while(c<''||c>''){if(c=='-')fh=-;c=getchar();}
     while(c>=''&&c<=''){ret=ret*+c-'';c=getchar();}
     return ret*fh;
 }

 struct Edge{
 int to[N1<<],nxt[N1<<],val[N1<<],head[N1],cte;
 void ae(int u,int v,int w){
     cte++;to[cte]=v;val[cte]=w;
     nxt[cte]=head[u];head[u]=cte;}
 }e;
 namespace tr{
 ll dis[N1];int dep[N1],ff[N1<<][],lg[N1<<],st[N1<<],tot;
 void dfs1(int u,int dad)
 {
     st[u]=++tot; ff[tot][]=u;
     for(int j=e.head[u];j;j=e.nxt[j])
     {
         int v=e.to[j]; if(v==dad) continue;
         dis[v]=dis[u]+e.val[j]; dep[v]=dep[u]+;
         dfs1(v,u); ff[++tot][]=u;
     }
 }
 void get_st()
 {
     int i,j;
     for(lg[]=,i=;i<=tot;i++) lg[i]=lg[i>>]+;
     for(j=;j<=lg[tot];j++)
         for(i=;i+(<<j)-<=tot;i++)
         ff[i][j]=dep[ ff[i][j-] ] < dep[ ff[i+(<<(j-))][j-] ] ? ff[i][j-] : ff[i+(<<(j-))][j-];
 }
 ll Dis(int x,int y)
 {
     int tx=min(st[x],st[y]),ty=max(st[x],st[y]),L=ty-tx+;
     int fa=dep[ ff[tx][lg[L]] ] < dep[ ff[ty-(<<lg[L])+][lg[L]] ] ? ff[tx][lg[L]] : ff[ty-(<<lg[L])+][lg[L]];
     return dis[x]+dis[y]-2ll*dis[fa];
 }
 void init(){dfs1(,-);get_st();}
 };
 int n,m,ma;
 int ms[N1],sz[N1],use[N1],fr[N1],fa[N1],a[N1],tsz,G;
 void gra(int u,int dad)
 {
     sz[u]=; ms[u]=;
     for(int j=e.head[u];j;j=e.nxt[j])
     {
         int v=e.to[j]; if(v==dad||use[v]) continue;
         gra(v,u);
         sz[u]+=sz[v]; ms[u]=max(ms[u],sz[v]);
     }
     ms[u]=max(ms[u],tsz-sz[u]);
     if(ms[u]<ms[G]) G=u;
 }
 int que[N1],hd,tl;
 ll dis[N1];
 struct node{int id;ll sum;};
 vector<node>rm[N1],rf[N1];
 int cmp(node x,node y){return a[x.id]<a[y.id];}
 void bfs_add(int u,int g)
 {
     int j,v; hd=tl=; que[hd]=u; fr[u]=; dis[u]=;
     while(hd<=tl)
     {
         u=que[hd++]; rm[g].push_back((node){u,dis[u]});
         for(j=e.head[u];j;j=e.nxt[j])
         {
             v=e.to[j]; if(use[v]||v==fr[u]) continue;
             fr[v]=u; dis[v]=dis[u]+e.val[j];
             que[++tl]=v;
         }
     }
     sort(rm[g].begin(),rm[g].end(),cmp);
     for(j=;j<rm[g].size();j++)
         rm[g][j].sum+=rm[g][j-].sum;
 }
 void bfs_sub(int u,int g)
 {
     int j,v; hd=tl=; que[hd]=u;
     while(hd<=tl)
     {
         u=que[hd++]; rf[g].push_back((node){u,dis[u]});
         for(j=e.head[u];j;j=e.nxt[j])
         {
             v=e.to[j]; if(use[v]||v==fr[u]) continue;
             que[++tl]=v;
         }
     }
     sort(rf[g].begin(),rf[g].end(),cmp);
     for(j=;j<rf[g].size();j++)
         rf[g][j].sum+=rf[g][j-].sum;
 }
 void main_dfs(int u)
 {
     use[u]=; bfs_add(u,u);
     for(int j=e.head[u];j;j=e.nxt[j])
     {
         int v=e.to[j]; if(use[v]) continue;
         G=; tsz=sz[v]; gra(v,-); bfs_sub(v,G); fa[G]=u;
         main_dfs(G);
     }
 }
 using tr::Dis;
 ll calc(vector<node>&s,int lim,int &sum,int type)
 {
     int l=,r=s.size()-,mid,ans=-;
     while(l<=r)
     {
         mid=(l+r)>>;
         if(a[s[mid].id]<=lim) l=mid+,ans=mid;
         else r=mid-;
     }
     if(ans==-) return ;
     sum+=type*(ans+);
     return s[ans].sum;
 }
 ll solve(int x,int L,int R)
 {
     ll ans=;int sum;
     for(int i=x;i;i=fa[i])
     {
         sum=;
         ans+=calc(rm[i],R,sum,)-calc(rm[i],L-,sum,-);
         ans+=sum*Dis(x,i);
         if(!fa[i]) continue;
         sum=;
         ans-=calc(rf[i],R,sum,)-calc(rf[i],L-,sum,-);
         ans-=sum*Dis(x,fa[i]);
     }
     return ans;
 }

 int main()
 {
     scanf("%d%d%d",&n,&m,&ma);
     int i,j,x,y,w,A,B,l,r;ll ans=;
     for(i=;i<=n;i++) a[i]=gint();
     for(i=;i<n;i++) x=gint(), y=gint(), w=gint(), e.ae(x,y,w), e.ae(y,x,w);
     tr::init();
     tsz=ms[]=n; G=; gra(,-); gra(G,-);
     main_dfs(G);
     for(j=;j<=m;j++)
     {
         x=gint(); A=gint(); B=gint();
         l=(ans+A)%ma; r=(ans+B)%ma; if(l>r) swap(l,r);
         ans=solve(x,l,r);
         printf("%lld\n",ans);
     }
     return ;
 }