[关闭]
@Junlier 2018-10-09T06:49:22.000000Z 字数 8090 阅读 2019

天天爱跑步题解(Noip2016)(桶+树上差分 ^ 树剖+主席树)

比较综合的题？
阅读体验：https://zybuluo.com/Junlier/note/1303550

综合整理自：洛谷P1600 天天爱跑步 题解
提供两种方法，因为网上讲的很详细，我也就不需要再多说了
因为自己的代码不是完全按下面任意一种方法来的（有不同的地方）
所以代码也是复制的，不要介意。。。
可能以后再写一遍的时候放上自己的代码吧（或者那天心血来潮把自己更复杂的方法讲一遍）

桶&树上差分

分算法

直接暴力，跟着人走，当发现当前节点满足条件就统计

为根节点部分分

为根节点，如果节点可以观测到人，那么首先要满足w[i]==deep[i]，然后以i为根节点的子树包含多少个终点，节点的答案就是几

为根节点

对于i节点，深度为deep[i]+w[i]的起点才会产生贡献。那就树上统计呗：

  1. 开一个桶bac[x]表示当前深度为的起点有多少个
  2. 对于节点，访问时先记录当时的bac[deep[i]+w[i]]，再往下递归，递归完后检查bac[deep[i]+w[i]]，增加了就说明它的子树有个这样的起点，的答案就是

退化为链部分分

退化为链你能想到什么？
所有的路径要么左走要么右走
我们只考虑右走【左走类似】
右走时，对于节点，只有节点i-w[i]为起点时才会产生贡献。
那就向右扫一遍：

  1. 同样开一个桶bac[x]表示扫到现在以为起点的还未走完的路径有多少个
  2. 记录当前点的答案bac[i-w[i]]
  3. 对于在该点结束的路径的bac[S]--

满分算法

满分算法其实就是综上所述。。
先把树进行，路径分为向上和向下走

  1. 对于向上走的路径，在i节点，当deep[i]+w[i]==deep[S]时才会产生贡献
    借用以T为根节点的思想，开一个桶来差分统计就好了
  2. 对于向下走的路径，在i节点，当deep[i]-w[i]==deep[T]-dis[S,T]-pret[T]时才会产生贡献
    （dis表示路径长，pret表示若该路径起点为lca,则走到lca时是什么时刻，若该路径起点为自然起点，则xpret=0）
  3. 进行同样的统计，到i节点时把向上路径的起点S_up和向下路径的终点T_up（起点在上面的终点）的对应的bac[ ]++
    （例如T_up就是bac[deep[T]-dis[S,T]-pret[T]]++），在访问结束时将向下路径的起点S_down和向上路径的终点T_up对应的另一个端点的统计撤销（类似于链状部分分的算法，看不明白可以参照一下）
  4. 若该点为lca且该点产生了贡献，贡献值应该-1，因为统计了两次

总的来说要注意的地方还是很多的，细节处理要特别注意

  1. #include<iostream>
  2. #include<cstdio>
  3. #include<cstring>
  4. #include<vector>
  5. #include<algorithm>
  6. #define LL long long int
  7. using namespace std;
  8. const int maxn=700005,maxm=2000100,INF=2000000000,P=1000000007;
  9. //快速读入
  10. inline int read(){
  11.     int out=0,flag=1;char c=getchar();
  12.     while(c<48||c>57) {if(c=='-') flag=-1;c=getchar();}
  13.     while(c>=48&&c<=57){out=out*10+c-48;c=getchar();}
  14.     return out*flag;
  15. }
  16. //边信息建立
  17. int head[maxn],nedge=0;
  18. struct EDGE{
  19.     int to,next;
  20. }edge[maxm];
  21. inline void build(int a,int b){
  22.     edge[nedge]=(EDGE){b,head[a]};
  23.     head[a]=nedge++;
  24.     edge[nedge]=(EDGE){a,head[b]};
  25.     head[b]=nedge++;
  26. }
  27. //lca询问信息建立
  28. int Head[maxn],nlca=0;
  29. struct LCA{
  30.     int to,flag,next;
  31. }Lca[maxm];
  32. inline void link(int a,int b){
  33.     Lca[nlca]=(LCA){b,0,Head[a]};
  34.     Head[a]=nlca++;
  35.     Lca[nlca]=(LCA){a,0,Head[b]};
  36.     Head[b]=nlca++;
  37. }
  38. int N,M,w[maxn],rt=0,Siz[maxn],disrt=INF;
  39. //数据读入
  40. void init(){
  41.     fill(head,head+maxn,-1);
  42.     fill(Head,Head+maxn,-1);
  43.     N=read();M=read();
  44.     int a,b;
  45.     for(int i=1;i<N;i++) build(read(),read());
  46.     for(int i=1;i<=N;i++) w[i]=read();
  47.     for(int i=1;i<=M;i++){a=read();b=read();link(a,b);}
  48. }
  49. //重心为根
  50. void dfs1(int u,int f){
  51.     int to,Min=INF,Max=-INF;
  52.     Siz[u]=1;
  53.     for(int k=head[u];k!=-1;k=edge[k].next)
  54.         if((to=edge[k].to)!=f){
  55.             dfs1(to,u);
  56.             Siz[u]+=Siz[to];
  57.             if(Siz[to]<Min) Min=Siz[to];
  58.             if(Siz[to]>Max) Max=Siz[to];
  59.         }
  60.     if(Min==INF) return;
  61.     if(N-Siz[u]<Min&&f) Min=N-Siz[u];
  62.     if(N-Siz[u]>Max) Max=N-Siz[u];
  63.     if(Max-Min<disrt){disrt=Max-Min;rt=u;}
  64. }
  65. void focus(){
  66.     dfs1(1,0);
  67.     if(!rt) rt=1;
  68.     //cout<<rt<<endl;
  69. }
  70. vector<int> Su[maxn],Sd[maxn],Tu[maxn],Td[maxn];
  71. int pre[maxn],dep[maxn],dis[maxn],S[maxn],T[maxn],pret[maxn],pathi=0,temp;
  72. int lca0[maxn];
  73. bool vis[maxn];
  74. inline int find(int u){
  75.     return u==pre[u] ? u:pre[u]=find(pre[u]);
  76. }
  77. //tarjan_lca算法割路径
  78. void dfs2(int u,int f){
  79.     int to;
  80.     pre[u]=u;
  81.     dep[u]=dep[f]+1;
  82.     vis[u]=true;
  83.     for(int k=head[u];k!=-1;k=edge[k].next){
  84.         if((to=edge[k].to)!=f){
  85.             dfs2(to,u);
  86.             pre[to]=u;
  87.         }
  88.     }
  89.     for(int k=Head[u];k!=-1;k=Lca[k].next){
  90.         if(!Lca[k].flag&&vis[to=Lca[k].to]){
  91.             Lca[k].flag=Lca[k^1].flag=true;
  92.             int flag=0,m=find(to);
  93.             if(!(k&1)) {flag=1;to^=u^=to^=u;}
  94.             pathi++;
  95.             if(to==m){
  96.                 S[pathi]=to;T[pathi]=u;dis[pathi]=dep[u]-dep[to];
  97.                 pret[pathi]=0;
  98.                 Sd[to].push_back(pathi);Tu[u].push_back(pathi);
  99.             }else if(u==m){
  100.                 S[pathi]=to;T[pathi]=u;dis[pathi]=dep[to]-dep[u];
  101.                 Td[u].push_back(pathi);Su[to].push_back(pathi);
  102.             }else{
  103.                 lca0[pathi]=m;
  104.                 S[pathi]=to;T[pathi]=m;dis[pathi]=dep[to]-dep[m];
  105.                 Su[to].push_back(pathi);Td[m].push_back(pathi);
  106.                 S[++pathi]=m;T[pathi]=u;dis[pathi]=dep[u]-dep[m];
  107.                 pret[pathi]=dep[to]-dep[m];
  108.                 Sd[m].push_back(pathi);Tu[u].push_back(pathi);
  109.             }
  110.             if(flag) u=to;
  111.         }
  112.     }
  113. }
  114. void tarjan_lca(){
  115.     dfs2(rt,0);
  116.     /*for(int i=1;i<=pathi;i++){
  117.         printf("%d %d %d\n",S[i],T[i],dis[i]);
  118.     }*/
  119. }
  120. int cntS[maxm],cntT[maxm],ans[maxn];
  121. //树上统计
  122. void dfs(int u,int f){
  123.     int dS=dep[u]+w[u]+maxn,oriS=cntS[dS],dT=dep[u]-w[u]+maxn,oriT=cntT[dT],to;
  124.     for(unsigned i=0;i<Su[u].size();i++){
  125.         cntS[dep[S[Su[u][i]]]+maxn]++;
  126.     }
  127.     for(unsigned i=0;i<Tu[u].size();i++){
  128.         cntT[dep[T[Tu[u][i]]]-dis[Tu[u][i]]-pret[Tu[u][i]]+maxn]++;
  129.     }
  130.     for(int k=head[u];k!=-1;k=edge[k].next){
  131.         if((to=edge[k].to)!=f){
  132.             dfs(to,u);
  133.         }
  134.     }
  135.     ans[u]=cntS[dS]-oriS+cntT[dT]-oriT;
  136.     for(unsigned i=0;i<Td[u].size();i++){
  137.         cntS[dep[S[Td[u][i]]]+maxn]--;
  138.         //if(u==2) cout<<"lca:"<<lca0[Td[u][i]]<<endl;
  139.         if(lca0[Td[u][i]]==u&&dep[S[Td[u][i]]]+maxn==dS) ans[u]--;
  140.     }
  141.     for(unsigned i=0;i<Sd[u].size();i++){
  142.         cntT[dep[T[Sd[u][i]]]-dis[Sd[u][i]]-pret[Sd[u][i]]+maxn]--;
  143.     }
  144. }
  145. //打印答案
  146. void print(){
  147.     printf("%d",ans[1]);
  148.     for(int i=2;i<=N;i++) printf(" %d",ans[i]);
  149.     printf("\n");
  150. }
  151. int main(){
  152.     init();
  153.     focus();
  154.     tarjan_lca();
  155.     dfs(rt,0);
  156.     print();
  157.     return 0;
  158. }

树剖&主席树（哇，大佬Tyher）

下面那些式子就不推到了，看了上面的题解你就会发现其实桶的做法是比较难维护的因为树上差分这种东西毕竟思维难度还是比较高
因为桶做法的本质还是在过程中到节点，看节点的子树中的桶有多少个起点满足要求，终点满足要求
然后在考虑取不取，去重复之类的巴拉巴拉
所以智商不够数据结构来凑
因为桶做法之所以麻烦就是因为在计算当前节点时会把其他子树中深度相同的点也算进来
为了方便，开颗线段树，每颗线段树代表某一深度的点的集合，动态开点
然后考虑某一路径上的点能对哪一个深度的点产生影响
对于到的路径，上面已经说的很清楚了，即的深度的点
那么就在root[de[s]]这个线段树上，从到s的路径上所经过的点
这个路径的处理是可以树剖搞定的，也可以用树剖顺便求了
然后是到的路径上，也是一样的道理，注意右移位
注意最后在de[s]线段树中单点减去的贡献，会重复一次的。
修改应当是区间修改，最后查询的时候一定要记得下放
为了方便你可以开两颗主席树，分开考虑到和到
但是，，几个数组可以共用
可以在树剖的时候就把改开的点全部开了
最后附上代码，看不懂可以私信

  1. #include<iostream>
  2. #include<cstdlib>
  3. #include<cstdio>
  4. #include<cstring>
  5. #include<cmath>
  6. #include<algorithm>
  7. #include<vector>
  8. #include<queue>
  9. #define il inline
  10. #define rg register
  11. #define ll long long
  12. #define ld long double
  13. #define N 300000
  14. #define inf 2147483647
  15. using namespace std;
  16. int n,m,u,v,cnt,num;
  17. int hd[N],w[N],s[N],t[N];
  18. int de[N],top[N],son[N],tot[N];
  19. int fa[N],idx[N];
  20. struct Edge{
  21.     int nt,to;
  22. }edge[N<<1];
  23. int rt1[N*2],rt2[N*2],ls[N*40],rs[N*40],val[N*40];
  24. il void re(rg int &x);
  25. il void link(rg int fm,rg int to);
  26. void Dfs1(rg int i,rg int fm);
  27. void Dfs2(rg int i,rg int head);
  28. int lca(rg int x,rg int y);
  29. il void work(rg int s,rg int t);
  30. void add(rg int now,rg int le,rg int ri,rg int pos);
  31. void update(rg int now,rg int le,rg int ri,rg int L,rg int R,rg int w);
  32. int query(rg int now,rg int le,rg int ri,rg int pos);
  33. int main(){
  34.     freopen("s.in","r",stdin);
  35.     re(n),re(m);
  36.     for(rg int i=1;i<n;++i){
  37.         re(u),re(v);
  38.         link(u,v),link(v,u);
  39.     }
  40.     for(rg int i=1;i<=n;++i)
  41.         re(w[i]);
  42.     for(rg int i=1;i<=m;++i)
  43.         re(s[i]),re(t[i]);
  44.     cnt=0,Dfs1(1,0),Dfs2(1,1);
  45.     for(rg int i=1;i<=m;++i)
  46.         work(s[i],t[i]);
  47.     for(rg int i=1;i<=n;++i){
  48.         int ans1=query(rt1[de[i]+w[i]],1,n,idx[i]);
  49.         int ans2=query(rt2[w[i]-de[i]+N],1,n,idx[i]);
  50.         printf("%d ",ans1+ans2);
  51.     }
  52.     return 0;
  53. }
  54. int query(rg int now,rg int le,rg int ri,rg int pos){
  55.     if(!now)return 0;
  56.     if(le==ri)return val[now];
  57.     if(val[now]){
  58.         if(ls[now])val[ls[now]]+=val[now];
  59.         if(rs[now])val[rs[now]]+=val[now];
  60.         val[now]=0;
  61.     }
  62.     rg int mid=((le+ri)>>1);
  63.     if(pos<=mid)return query(ls[now],le,mid,pos);
  64.     else return query(rs[now],mid+1,ri,pos);
  65. }
  66. il void work(rg int s,rg int t){
  67.     rg int Lca=lca(s,t),u=s;
  68.     while(top[u]!=top[Lca]){
  69.         update(rt1[de[s]],1,n,idx[top[u]],idx[u],1);
  70.         u=fa[top[u]];
  71.     }
  72.     update(rt1[de[s]],1,n,idx[Lca],idx[u],1);
  73.     u=t;
  74.     while(top[u]!=top[Lca]){
  75.         update(rt2[de[s]-2*de[Lca]+N],1,n,idx[top[u]],idx[u],1);
  76.         u=fa[top[u]];
  77.     }
  78.     update(rt2[de[s]-2*de[Lca]+N],1,n,idx[Lca],idx[u],1);
  79.     update(rt1[de[s]],1,n,idx[Lca],idx[Lca],-1);
  80. }
  81. void add(rg int now,rg int le,rg int ri,rg int pos){
  82.     if(le==ri)return;
  83.     rg int mid=((le+ri)>>1);
  84.     if(pos<=mid){
  85.         if(!ls[now])ls[now]=(++num);
  86.         add(ls[now],le,mid,pos);
  87.     }
  88.     else{
  89.         if(!rs[now])rs[now]=(++num);
  90.         add(rs[now],mid+1,ri,pos);
  91.     }
  92. }
  93. void update(rg int now,rg int le,rg int ri,rg int L,rg int R,rg int w){
  94.     if(!now)return;
  95.     if(L==le&&R==ri){val[now]+=w;return;}
  96.     rg int mid=((le+ri)>>1);
  97.     if(R<=mid)update(ls[now],le,mid,L,R,w);
  98.     else if(L>mid)update(rs[now],mid+1,ri,L,R,w);
  99.     else update(ls[now],le,mid,L,mid,w),update(rs[now],mid+1,ri,mid+1,R,w);
  100. }
  101. int lca(rg int x,rg int y){
  102.     while(top[x]!=top[y]){
  103.         if(de[top[x]]<de[top[y]])swap(x,y);
  104.         x=fa[top[x]];
  105.     }
  106.     if(de[x]>de[y])return y;
  107.     else return x;
  108. }   
  109. void Dfs1(rg int i,rg int fm){
  110.     de[i]=de[fm]+1,fa[i]=fm;
  111.     tot[i]=1;
  112.     rg int maxn=0;
  113.     for(rg int k=hd[i];k;k=edge[k].nt){
  114.         rg int qw=edge[k].to;
  115.         if(qw==fm)continue;
  116.         Dfs1(qw,i),tot[i]+=tot[qw];
  117.         if(tot[qw]>maxn)maxn=tot[qw],son[i]=qw;
  118.     }
  119. }
  120. void Dfs2(rg int i,rg int head){
  121.     idx[i]=(++cnt),top[i]=head;
  122.     if(!rt1[de[i]+w[i]])rt1[de[i]+w[i]]=(++num);
  123.     add(rt1[de[i]+w[i]],1,n,idx[i]);
  124.     if(!rt2[w[i]-de[i]+N])rt2[w[i]-de[i]+N]=(++num);
  125.     add(rt2[w[i]-de[i]+N],1,n,idx[i]);
  126.     if(!son[i])return;
  127.     Dfs2(son[i],head);
  128.     for(rg int k=hd[i];k;k=edge[k].nt)
  129.         if(!idx[edge[k].to])
  130.             Dfs2(edge[k].to,edge[k].to);
  131. }
  132. il void re(rg int &x){
  133.     rg int res=0;rg int w=1;char c=getchar();
  134.     while((c<'0'||c>'9')&&c!='-')c=getchar();
  135.     if(c=='-')w=-1,c=getchar();
  136.     while(c>='0'&&c<='9')res=(res<<3)+(res<<1)+c-'0',c=getchar();
  137.     x=w*res;
  138. }
  139. il void link(rg int fm,rg int to){
  140.     edge[++cnt].nt=hd[fm];
  141.     edge[cnt].to=to;
  142.     hd[fm]=cnt;
  143. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注