洛谷P5280 [ZJOI2019]线段树

 

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

省选的时候后一半时间开这题，想了接近两个小时的各种假做法，之后想的做法已经接近正解了，但是有一些细节问题理不清楚（事实证明出来后再给我2个小时也还是没理清楚，只能说自己naive），而且也码不完，打了个20分暴力

参考资料：题解

首先，可以分开考虑各个点

对于每个点，考虑对于t次修改，每一次标记为启用或不启用（共有$2^t$种标记方案），其中有多少种标记方案使得这个点最后有tag

询问的答案就是每个点的答案之和

对于每个点：

f[i]表示i点自身有tag的方案数

g[i]表示i或其祖先有tag的方案数(状态里必须是i或其祖先，如果只是祖先(或者只是父亲)就没法做了，以前卡在这个坑里了...)

设这一次是第k次修改

考虑根到某个节点u的链a1,a2,a3,..,at,u

可以发现，这次修改对这个节点的影响分5类：（具体可以参考上面的“参考资料”）

如果"把a1,a2,..,at之一节点直接打tag"（对应参考资料里第4类），则f[u]*=2,g[u]+=$2^{k-1}$

如果"把u直接打tag"（对应第2类），则f[u]+=$2^{k-1}$,g[u]+=$2^{k-1}$

如果"删掉a1,a2,..,at,u的全部tag"（对应第1类），则(啥也没)

如果"删掉a1,a2,..,at的全部tag，如果删掉了至少1个tag就让u加上tag"（对应第3类），则f[u]+=g[u],g[u]*=2

如果"删掉a1,a2,..,ap(p<t)的全部tag（如果删掉了至少1个tag就让a[p+1]加上tag）"（对应第5类），则f[u]*=2,g[u]*=2

这一堆东西是可以用线段树直接维护的，其中第1,2,3类的直接暴力修改，4,5类用懒标记

可以把方案数转换为概率，相当于每次做以上修改时加上的常数都要除以$2^{k-1}$，做完以上修改后再将所有点f和g都除以2，这样可以少记标记，减小常数

这样的话，第4类就是g[u]=g[u]/2+1/2，第5类就是啥也没，剩下几类不需要lazytag比较容易，因此可以只记g的加法和乘法tag

剩下几类：第1类f[u]/=2,g[u]/=2，第2类f[u]=(f[u]+1)/2,g[u]=(g[u]+1)/2，第3类f[u]=(f[u]+g[u])/2

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 using namespace std;
 #define fi first
 #define se second
 #define mp make_pair
 #define pb push_back
 typedef long long ll;
 typedef unsigned long long ull;
 const int md=;
 #define addto(a,b) ((a)+=(b),((a)>=md)&&((a)-=md))
 #define multo(a,b) ((a)=ull(a)*(b)%md)
 namespace S
 {
     struct Nd
     {
         int f,g,addg,mulg;
         int sumf;
     }d[];
 #define LC (u<<1)
 #define RC (u<<1|1)
     inline void upd(int l,int r,int u)
     {
         d[u].sumf=d[u].f;
         if(l==r)    return;
         addto(d[u].sumf,d[LC].sumf);
         addto(d[u].sumf,d[RC].sumf);
     }
     inline void doAddg(int u,int x)
     {
         addto(d[u].g,x);
         addto(d[u].addg,x);
     }
     inline void doMulg(int u,int x)
     {
         multo(d[u].g,x);
         multo(d[u].addg,x);
         multo(d[u].mulg,x);
     }
     inline void pd(int l,int r,int u)
     {
         if(l==r)    return;
         if(d[u].mulg!=)
         {
             doMulg(LC,d[u].mulg);
             doMulg(RC,d[u].mulg);
             d[u].mulg=;
         }
         if(d[u].addg)
         {
             doAddg(LC,d[u].addg);
             doAddg(RC,d[u].addg);
             d[u].addg=;
         }
     }
     void build(int l,int r,int u)
     {
         if(l==r)
         {
             d[u].mulg=;
             return;
         }
         int mid=(l+r)>>;
         build(l,mid,LC);build(mid+,r,RC);
         d[u].mulg=;
     }
     void setx(int L,int R,int l,int r,int u)//X=2^{k-2}
     {
         pd(l,r,u);
         if(L<=l && r<=R)
         {
             //4类,u的任意后代节点
             multo(d[u].addg,);
             multo(d[u].mulg,);
             addto(d[u].addg,);
             //2类,u自身
             d[u].f=ull(d[u].f+)*%md;
             d[u].g=ull(d[u].g+)*%md;
             upd(l,r,u);
             return;
         }
         int mid=(l+r)>>;
         if(L<=mid && mid<R)
         {
             setx(L,R,l,mid,LC);
             setx(L,R,mid+,r,RC);
         }
         else if(L<=mid)
         {
             setx(L,R,l,mid,LC);
             //3类,RC
             pd(mid+,r,RC);
             d[RC].f=ull(d[RC].f+d[RC].g)*%md;
             upd(mid+,r,RC);
             //5类,RC的任意后代节点(啥也不干)
         }
         else if(mid<R)
         {
             setx(L,R,mid+,r,RC);
             //3类,LC
             pd(l,mid,LC);
             d[LC].f=ull(d[LC].f+d[LC].g)*%md;
             upd(l,mid,LC);
             //5类,LC的任意后代节点(啥也不干)
         }
         //1类,u自身
         multo(d[u].f,);
         multo(d[u].g,);
         upd(l,r,u);
     }
 }
 int pw2[];//pw2[i]=2^{i-2}
 int n,m,mm;
 int main()
 {
     int i,idx,l,r;
     pw2[]=;
     for(i=;i<=;++i)
         pw2[i]=ull(pw2[i-])*%md;
     scanf("%d%d",&n,&m);
     S::build(,n,);
     while(m--)
     {
         scanf("%d",&idx);
         if(idx==)
         {
             scanf("%d%d",&l,&r);
             ++mm;
             S::setx(l,r,,n,);
         }
         else
         {
             printf("%llu\n",ull(S::d[].sumf)*pw2[mm+]%md);
         }
     }
     return ;
 }