[ZJOI2019]线段树

ZJOI2019最水的一道题，考场上想出了正解却死活调不出来。。

然后就一直咕到了现在(逃

题目求的那个东西可以转化为这样一个东西。

有一些操作，你可以决定每个操作是否执行，动态查询所有可能的情况中线段树上权值为1的节点个数的总和。

然后很自然的（虽然看起来有点奇怪，但真的就很自然的能想到！）想到把维护方案数变成维护期望。

然后根据期望的线性性，等价于维护每个点权值为1的概率。

这样的好处是，如果维护方案数的话，那些不受影响的节点每次操作需要乘上2，维护概率的话则不需要改变。

然后经过一波毒瘤的分类套路，你大概需要设计这样一个dp状态,dp[o][0/1][0/1]表示o这个点，是否为0/1，它到根的路径是否有0/1的概率。

转移方程很普及组，就是有点繁琐。

然后你可以把所有点按照不同的转移方式划分为4类。

1.optset时会被遍历到的点。

2.不会被遍历到但却会被pushdown到的点

3.遍历到的点中最底端，也就是ql<=l&&r<=qr的点

4.第3种点的子树

前三种都可以直接修改，第四种可以通过打标记实现修改。

#include<bits/stdc++.h>
#define N 220000
#define eps 1e-7
#define inf 1e9+7
#define db double
#define ll long long
#define ldb long double
using namespace std;
inline int read()
{
    char ch=0;
    int x=0,flag=1;
    while(!isdigit(ch)){ch=getchar();if(ch=='-')flag=-1;}
    while(isdigit(ch)){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return x*flag;
}
const int mo=998244353;
int ksm(int x,int k)
{
    int ans=1;
    while(k){if(k&1)ans=1ll*ans*x%mo;k>>=1;x=1ll*x*x%mo;}
    return ans;
}
int inv(int x){return ksm(x,mo-2);}
int v,mi[N],mv[N];
struct Segment_Tree
{
    #define lson o<<1
    #define rson o<<1|1
    #define mid ((l+r)>>1)
    int lx[N*4],rx[N*4];
    int sumv[N*4],tagv[N*4],f[N*4][2][2],g[N*4][2][2];
    inline void pushup(int o)
    {
        sumv[o]=(sumv[lson]+sumv[rson])%mo;
        sumv[o]=(sumv[o]+((f[o][1][0]+f[o][1][1])%mo))%mo;
    }
    inline void update(int o,int t)
    {
    	int k=mv[t];tagv[o]+=t;
        for(int i=0;i<=1;i++)
        {
            f[o][i][1]=(f[o][i][1]+(1ll*f[o][i][0]*(1-k)%mo))%mo;
            f[o][i][0]=1ll*f[o][i][0]*k%mo;
        }
    }
    inline void pushdown(int o)
    {
        update(lson,tagv[o]);
		update(rson,tagv[o]);
		tagv[o]=0;
    }
    void build(int o,int l,int r)
    {
    	lx[o]=l;rx[o]=r;
        f[o][0][0]=1;
        if(l==r)return;
        build(lson,l,mid);build(rson,mid+1,r);
    }
    void print(int o)
    {
    	cout<<lx[o]<<"--"<<rx[o]<<endl;
    	for(int i=0;i<=1;i++)for(int j=0;j<=1;j++)
    	cout<<(f[o][i][j]%mo+mo)%mo<<" ";cout<<endl<<sumv[o]<<endl<<endl;
    }
    void copy(int o)
    {
    	for(int i=0;i<=1;i++)
		for(int j=0;j<=1;j++)
		g[o][i][j]=f[o][i][j];
    }
    void solve(int o,int l,int r,int ql,int qr)
	{
		copy(o);
		if(ql<=l&&r<=qr)return;
		pushdown(o);
		if(ql<=mid)solve(lson,l,mid,ql,qr);else copy(lson);
		if(qr>mid)solve(rson,mid+1,r,ql,qr);else copy(rson);
	}
	void opt(int o,int l,int r)//被pushdown到的节点 
    {
    	f[o][0][0]=g[o][0][0];
    	f[o][0][1]=1ll*v*g[o][0][1]%mo;
    	f[o][1][0]=(g[o][1][0]+(1ll*(g[o][0][1]+g[o][1][1])%mo*v%mo))%mo;
    	f[o][1][1]=1ll*v*g[o][1][1]%mo;
    	sumv[o]=(f[o][1][0]+f[o][1][1])%mo;
    	if(l!=r)sumv[o]=(sumv[o]+((sumv[lson]+sumv[rson])%mo))%mo;
    }
    void optset(int o,int l,int r,int ql,int qr)
    {
    	if(ql<=l&&r<=qr)
    	{
    		//边界点
    		f[o][0][0]=1ll*v*g[o][0][0]%mo;
    		f[o][0][1]=1ll*v*g[o][0][1]%mo;
    		f[o][1][0]=1ll*v*(1+g[o][1][0])%mo;
    		f[o][1][1]=1ll*v*g[o][1][1]%mo;
    		sumv[o]=(f[o][1][0]+f[o][1][1])%mo;
			if(l!=r)//边界点的子树
			{
				update(lson,1),update(rson,1);
				sumv[o]=(sumv[o]+((sumv[lson]+sumv[rson])%mo))%mo;
			}
			return;
    	}
    	if(ql<=mid)optset(lson,l,mid,ql,qr);else opt(lson,l,mid);
		if(qr>mid)optset(rson,mid+1,r,ql,qr);else opt(rson,mid+1,r);
		//被访问到的点 
		f[o][0][0]=1ll*v*(1+g[o][0][0])%mo;
		f[o][0][1]=1ll*v*g[o][0][1]%mo;
		f[o][1][0]=1ll*v*g[o][1][0]%mo;
		f[o][1][1]=1ll*v*g[o][1][1]%mo;
		pushup(o);
    }
    int query(){return sumv[1];}
}T;
int main()
{
    int n=read(),m=read();
    v=inv(2);mi[0]=mv[0]=1;T.build(1,1,n);
    for(int i=1;i<=n+m;i++)
    {
    	mi[i]=1ll*mi[i-1]*2%mo;
    	mv[i]=1ll*mv[i-1]*v%mo;
    }
	for(int i=1,cnt=0;i<=m;i++)
    {
        int flag=read();
        if(flag==1)
        {
        	cnt++;
            int l=read(),r=read();
            T.solve(1,1,n,l,r);
            T.optset(1,1,n,l,r);
        }
        if(flag==2)
        {
            int ans=1ll*T.query()*mi[cnt]%mo;
            printf("%d\n",(ans%mo+mo)%mo);
        }
    }
    return 0;
}