大致题意： 给你一棵线段树，两种操作。一种操作将每棵线段树复制成两个，然后在这两个线段树中的一个上面进行\(Modify(l,r)\)。另一种操作询问所有线段树的\(tag\)总和。
大力分类讨论
我们考虑用线段树来进行维护。
定义一个\(f_{rt}\)，表示在当前所有线段树中编号为\(rt\)的节点上的\(tag\)之和。
然后对于每次修改，就需要大力分类讨论，来计算新增加的\(2^{t-1}\)棵树对\(f_x\)的贡献。
-
当这个节点未被访问到
显然，就相当于此次操作对该节点没有任何影响，也就是新产生的\(2^{t-1}\)棵树中\(tag\)不会发生任何变化，因此直接将\(f_{rt}*=2\)即可。
-
当这个节点是被修改的节点
如果这个节点是被修改的节点，则显然新产生的\(2^{t-1}\)棵树中这个点会被赋值为\(1\)，因此将\(f_{rt}+=2^{t-1}\)即可。
-
当这个节点被访问到且进行过\(PushDown\)操作
由于进行过了\(PushDown\)，则显然新产生的\(2^{t-1}\)棵树中这个点会被赋值为\(0\)，因此\(f_{rt}\)不会发生任何变化。
-
当这个节点被访问到但未进行任何操作
如果这个节点被访问到但未进行任何操作，那么这个点的\(tag\)值就取决于这个节点到根节点的路径上（包括这个节点）是否存在至少一个节点\(tag\)值为\(1\)，因为这样就能经过若干次\(PushDown\)影响到这一位上了。
而这也是最复杂的一种情况，下面会单独对这种情况进行进一步的讨论。
处理被访问到但未进行任何操作的节点
考虑再记录一个\(g_{rt}\)，表示当前所有线段树中编号为\(rt\)的节点到根节点的路径上（包括该节点）存在至少一个节点\(tag\)值为\(1\)的方案数。
则这样一来在这种情况下我们就可以直接将\(f_{rt}+=g_{rt}\)了。
但就有了一个新的问题，如何维护\(g_{rt}\)？
于是又要进行一波与先前类似的分类讨论。
-
当这个节点未被访问到
同样，就相当于此次操作对该节点没有任何影响，因此直接将\(g_{rt}*=2\)即可。
-
当这个节点是被修改的节点
如果这个节点是被修改的节点，则显然新产生的\(2^{t-1}\)棵树中这个点会被赋值为\(1\)，因此新产生的\(2^{t-1}\)棵树中这个点到根节点的路径上必然存在\(tag\)值为\(1\)的点（即这个点本身），因此将\(g_{rt}+=2^{t-1}\)即可。
-
当这个节点被访问到且进行过\(PushDown\)操作
由于进行过了\(PushDown\)，则显然这个点到根的路径上的所有节点全都\(PushDown\)过，因此新产生的\(2^{t-1}\)棵树中这个点到根节点的路径上不存在\(tag\)值为\(1\)的点，因此\(g_{rt}\)不会发生任何变化。
-
当这个节点被访问到但未进行任何操作
将\(g_{rt}*=2\)即可。
整理+优化
接下来，我们来整理一下上面的内容：
| 情况 | \(f_{rt}\) | \(g_{rt}\) |
|---|---|---|
| 当这个节点未被访问到 | \(f_{rt}*=2\) | \(g_{rt}*=2\) |
| 当这个节点是被修改的节点 | \(f_{rt}+=2^{t-1}\) | \(g_{rt}+=2^{t-1}\) |
| 当这个节点被访问到且进行过\(PushDown\)操作 | 无变化 | 无变化 |
| 当这个节点被访问到但未进行任何操作 | \(f_{rt}+=g_{rt}\) | \(g_{rt}*=2\) |
考虑到对于未访问到的节点，我们一律都是将答案乘\(2\)的。
那么，我们能不能换一种思维，即每次不修改未被访问到的节点，而是把其余三种情况时的\(f_{rt}\)和\(g_{rt}\)除以\(2\)，然后在输出答案时把答案乘上\(2^t\)。
则就得到了这样一个新表格：
| 情况 | \(f_{rt}\) | \(g_{rt}\) |
|---|---|---|
| 当这个节点未被访问到 | 无变化 | 无变化 |
| 当这个节点是被修改的节点 | \(f_{rt}=\frac{f_{rt}+1}2\) | \(g_{rt}=\frac{g_{rt}+1}2\) |
| 当这个节点被访问到且进行过\(PushDown\)操作 | 无变化 | 无变化 |
| 当这个节点被访问到但未进行任何操作 | \(f_{rt}=\frac{f_{rt}+g_{rt}}2\) | 无变化 |
这样就方便许多。
维护\(g\)的修改
但是，我们还是要注意，要在\(PushDown\)的同时维护\(g\)的修改。
我们用\(tag_{rt}\)来记录当前节点的\(g\)在上一次\(PushDown\)后被修改过多少次。
则我们需要将\(rt<<1\)和\(rt<<1|1\)的\(g\)分别进行\(tag_{rt}\)次\(g=\frac{g+1}2\)。
设要进行\(tag_{rt}\)次\(g=\frac{g+1}2\)的点为\(k\)，易得最终结果为：
\[\frac {g_k+2^{tag_{rt}-1}+2^{tag_{rt}-2}+...+2^{tag_{rt}}}{2^{tag_{rt}}}\]
式子的后半部分显然可以用等底数列求和公式化简，得到：
\[\frac {g_k+{2^{tag_{rt}}-1}}{2^{tag_{rt}}}=\frac {g_k}{2^{tag_{rt}}}+1-\frac 1{2^{tag_{rt}}}\]
分母可以预处理\(2\)的幂的逆元，然后就差不多了。
代码
#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 100000
#define X 998244353
#define Inc(x,y) ((x+=(y))>=X&&(x-=X))
#define Dec(x,y) ((x-=(y))<0&&(x+=X))
#define Shl(x) ((x<<=1)>=X&&(x-=X))
using namespace std;
int n;
class FastIO
{
private:
#define FS 100000
#define tc() (A==B&&(B=(A=FI)+fread(FI,1,FS,stdin),A==B)?EOF:*A++)
#define pc(c) (C^FS?FO[C++]=c:(fwrite(FO,1,C,stdout),FO[(C=0)++]=c))
#define tn (x<<3)+(x<<1)
#define D isdigit(c=tc())
int T,C;char c,*A,*B,FI[FS],FO[FS],S[FS];
public:
I FastIO() {A=B=FI;}
Tp I void read(Ty& x) {x=0;W(!D);W(x=tn+(c&15),D);}
Tp I void write(Ty x) {W(S[++T]=x%10+48,x/=10);W(T) pc(S[T--]);}
Ts I void read(Ty& x,Ar&... y) {read(x),read(y...);}
Tp I void writeln(Con Ty& x) {write(x),pc('\n');}
I void clear() {fwrite(FO,1,C,stdout),C=0;}
}F;
class SegmentTree//线段树
{
private:
#define PD(x) O[x].t&&\//下传标记
(\
O[x<<1].g=((1LL*O[x<<1].g*I2[O[x].t]%X+1-I2[O[x].t])%X+X)%X,\//更新左儿子g值
O[x<<1|1].g=((1LL*O[x<<1|1].g*I2[O[x].t]%X+1-I2[O[x].t])%X+X)%X,\//更新右儿子g值
O[x<<1].t+=O[x].t,O[x<<1|1].t+=O[x].t,O[x].t=0\//下传修改次数
)
int ans,pw,I2[N+5];struct node {int f,g,t;}O[N<<2];
I void upt(CI l,CI r,CI rt,CI tl,CI tr)//修改
{
Dec(ans,O[rt].f),O[rt].f=1LL*O[rt].f*I2[1]%X,O[rt].g=1LL*O[rt].g*I2[1]%X;//先删除原来贡献，并将当前f,g除以2
if(tl<=l&&r<=tr) Inc(O[rt].f,I2[1]),Inc(O[rt].g,I2[1]);//分类讨论
else if(tr<l||r<tl) Inc(O[rt].f,O[rt].g),Shl(O[rt].g);
if(Inc(ans,O[rt].f),tr<l||r<tl) return;if(tl<=l&&r<=tr) return (void)(++O[rt].t);//加回新答案，然后模拟线段树过程
PD(rt);RI mid=l+r>>1;upt(l,mid,rt<<1,tl,tr),upt(mid+1,r,rt<<1|1,tl,tr);
}
public:
I SegmentTree() {pw=I2[0]=1,I2[1]=X+1>>1;}
I void Init(CI x) {for(RI i=2;i<=x;++i) I2[i]=1LL*I2[i-1]*I2[1]%X;}//预处理2的幂的逆元
I void Update(CI x,CI y) {upt(1,n,1,x,y),Shl(pw);}
I int GetAns() {return 1LL*ans*pw%X;}//最后答案乘上2^t
}S;
int main()
{
RI Qtot,op,x,y;F.read(n,Qtot),S.Init(Qtot);
W(Qtot--) F.read(op),op^2?(F.read(x,y),S.Update(x,y)):F.writeln(S.GetAns());
return F.clear(),0;
}