洛谷 P1600 天天爱跑步

https://www.luogu.org/problemnew/show/P1600

（仅做记录）

自己的假方法：

每一次跑从a到b：
设l=lca(a,b)
对于以下产生贡献：

a到l的链上所有的点(x)满足
dep[x]+w[x]==dep[a]

l到b的链上（不含l）所有的点(x)满足
dep[x]-dep[l]+dep[a]-dep[l]==w[x]
即dep[x]-w[x]==2*dep[l]-dep[a]

于是每一个点记两个map<int,int>，其中键值对(p,q)表示

“从该点到根的路径上所有满足 dep[x]+w[x]==p（第一个map） / dep[x]-w[x]==p（第二个map） 的点的答案都要加上q"

每一次跑，就是树上差分，乱搞一下。。。

最后每个点x的答案就是以其为根的子树中所有点的两个map分别合并起来后（两个map里面分别有(p,q1)和(p,q2)，则合并后有(p,q1+q2)），

在这两个map里面分别查询dep[x]+w[x]和dep[x]-w[x]得到答案的和

因此可以启发式合并处理一下

把平衡树换成值域线段树，启发式合并换成线段树合并就是一个log了。。。。。

曾经错误：线段树节点作死不开垃圾回收，空间可能算不太对了，原来开7000000都RE了

 #include<cstdio>
 #include<algorithm>
 using namespace std;
 int ll=-,rr=;
 namespace SegT
 {
 int dat[],lc[],rc[],mem;
 int L,x;
 #define mid (l+((r-l)>>1))
 void _addx(int l,int r,int &num)
 {
     if(!num)    num=++mem;
     if(l==r)    {dat[num]+=x;return;}
     if(L<=mid)    _addx(l,mid,lc[num]);
     else    _addx(mid+,r,rc[num]);
     dat[num]=dat[lc[num]]+dat[rc[num]];
 }
 int merge(int a,int b)
 {
     if(!a||!b)    return a+b;
     dat[a]+=dat[b];
     lc[a]=merge(lc[a],lc[b]);
     rc[a]=merge(rc[a],rc[b]);
     //delnode(b)
     return a;
 }
 int _query(int l,int r,int num)
 {
     if(l==r)    return dat[num];
     if(L<=mid)    return _query(l,mid,lc[num]);
     else    return _query(mid+,r,rc[num]);
 }
 void addx(int pos,int dat,int &num)
 {
     L=pos;x=dat;_addx(ll,rr,num);
 }
 int query(int pos,int &num)
 {
     L=pos;return _query(ll,rr,num);
 }
 #undef mid
 }
 using SegT::addx;using SegT::query;using SegT::merge;
 struct E
 {
     int to,nxt;
 }e[];
 int f1[],ne;
 int w[],rt1[],rt2[];
 int n,m;
 namespace LCA
 {
     int anc[][],log2n,dep[];
     void dfs(int u,int fa)
     {
         int i,k;
         anc[u][]=fa;
         for(i=;i<=log2n;i++)    anc[u][i]=anc[anc[u][i-]][i-];
         for(k=f1[u];k;k=e[k].nxt)
             if(e[k].to!=fa)
             {
                 dep[e[k].to]=dep[u]+;
                 dfs(e[k].to,u);
             }
     }
     int lca(int a,int b)
     {
         if(dep[a]<dep[b])    swap(a,b);
         int t=dep[a]-dep[b],i;
         for(i=log2n;i>=;i--)
             if((<<i)<=t)
                 t-=(<<i),a=anc[a][i];
         if(a==b)    return a;
         for(i=log2n;i>=;i--)
             if(anc[a][i]!=anc[b][i])
                 a=anc[a][i],b=anc[b][i];
         return anc[a][];
     }
 }
 using LCA::lca;using LCA::dep;
 int ans[];
 void dfs(int u,int fa)
 {
     int k;
     for(k=f1[u];k;k=e[k].nxt)
         if(e[k].to!=fa)
         {
             dfs(e[k].to,u);
             rt1[u]=merge(rt1[u],rt1[e[k].to]);
             rt2[u]=merge(rt2[u],rt2[e[k].to]);
         }
     ans[u]=query(dep[u]+w[u],rt1[u])+query(dep[u]-w[u],rt2[u]);
 }
 int main()
 {
     int i,a,b,l;
     scanf("%d%d",&n,&m);
     for(i=;i<n;i++)
     {
         scanf("%d%d",&a,&b);
         e[++ne].to=b;e[ne].nxt=f1[a];f1[a]=ne;
         e[++ne].to=a;e[ne].nxt=f1[b];f1[b]=ne;
     }
     for(i=;i<=n;i++)    scanf("%d",&w[i]);
     while((<<(LCA::log2n+))<=n)    LCA::log2n++;
     LCA::dfs(,);
     while(m--)
     {
         scanf("%d%d",&a,&b);l=lca(a,b);
         addx(dep[a],,rt1[a]);addx(dep[a],-,rt1[LCA::anc[l][]]);
         addx(*dep[l]-dep[a],,rt2[b]);addx(*dep[l]-dep[a],-,rt2[l]);
     }
     dfs(,);
     for(i=;i<=n;i++)    printf("%d ",ans[i]);
     return ;
 }

---

别人的做法（大概写一下）：

先把每个点x答案换一下形式:"以x为根的子树中有多少个起点/终点满足对应条件"

dfs(x)时，先dfs(所有子节点)，然后统计自身答案，然后把自身点满足的性质（比如，是起点，是终点，是某一对起点与终点的lca，是某一对起点与终点的lca的父亲）（可以预处理出来）产生的贡献加进一个全局的贡献数组里面