ZJOI 2017 树状数组（线段树套线段树）

题意

http://uoj.ac/problem/291

思路

不难发现，九条カレン醬所写的树状数组，在查询区间 \([1,r]\) 的时候，其实在查询后缀 \([r,n]\) ；在查询 \([l,r](l\neq1)\) 的时候，则是在查询 \([l-1,r-1]\) 。那么在查询 \([1,r]\) 的时候，只需要询问 \(r\) 的前后缀异或是否相等；在查询 \([l,r](l\neq 1)\) 的时候，只需要询问 \(a[l-1],a[r]\) 是否相等。

考虑 \(O(n^2)\) 的暴力。我们把询问分成上述的两类。第一类询问如果修改到了点 \(r\) ，则无影响，否则就是相等变不相等的转化，分询问区间盖住 \(r\) 和不盖住 \(r\) 两种情况考虑。设原来相等的概率为 \(p\) ，再进行修改不影响的概率为 \(q\) ，那么修改后相等的概率就是 \(pq+(1-p)(1-q)\) 。对于第二类询问也是一样的，分区间覆盖 \(l-1\) 点和 \(r\) 点、覆盖其中一个点、都不覆盖三种情况考虑。代码中有切了这一档分，方便和正解对照。

我们可以同时维护住所有答案，然后只接回答询问。用一个一维数据结构维护每个点 \(x\) 的前缀或者后缀是否相等，一个二维数据结构用来维护 \(a[x],a[y]\) 的值是否相等。修改和上面的暴力是同理的，是对一个区间（一维或二维）的点附上一个修改后相等的概率，对于修改显然是交换结合都没什么关系。那这个一维数据结构选择线段树，二维数据结构选择线段树套线段树即可。

二维线段树比较好写的写法是静点套动点，不过动点套动点也可以写的。而且这道题其实空间是不够的，但比较难卡，一般卡不满。

代码

#include<bits/stdc++.h>
#define FOR(i,x,y) for(int i=(x),i##END=(y);i<=i##END;++i)
#define DOR(i,x,y) for(int i=(x),i##END=(y);i>=i##END;--i)
template<typename T,typename _T>inline bool chk_min(T &x,const _T y){return y<x?x=y,1:0;}
template<typename T,typename _T>inline bool chk_max(T &x,const _T y){return x<y?x=y,1:0;}
typedef long long ll;
const int P=998244353;
const int N=1e5+5;
int op[N],ql[N],qr[N];
int n,m;
void exgcd(int a,int b,int &x,int &y)
{
    if(!b){x=1,y=0;return;}
    exgcd(b,a%b,y,x),y-=a/b*x;
}
int inv(int a)
{
    int x,y;
    exgcd(a,P,x,y);
    return (x%P+P)%P;
}
namespace Subtask1
{
    int merge(int x,int y)
    {
        return ((1ll*x*y+1ll*(1-x)*(1-y))%P+P)%P;
    }
    void Solve()
    {
        FOR(i,1,m)if(op[i]==2)
        {
            int l=ql[i],r=qr[i];
            int p=1;
            if(l==1)
            {
                FOR(j,1,i-1)if(op[j]==1)
                {
                    int len=qr[j]-ql[j]+1;
                    if(ql[j]<=r&&r<=qr[j])
                        p=merge(p,inv(len));
                    else p=merge(p,0);
                }
            }
            else
            {
                l--;
                FOR(j,1,i-1)if(op[j]==1)
                {
                    int len=qr[j]-ql[j]+1;
                    if(ql[j]<=l&&r<=qr[j])
                        p=merge(p,1ll*(len-2)*inv(len)%P);
                    else if((ql[j]<=l&&l<=qr[j])||(ql[j]<=r&&r<=qr[j]))
                        p=merge(p,1ll*(len-1)*inv(len)%P);
                }
            }
            printf("%d\n",p);
        }
    }
};

namespace Subtask2
{
    int merge(int x,int y)
    {
        return ((1ll*x*y+1ll*(1-x)*(1-y))%P+P)%P;
    }
    struct SegmentTree
    {
        int pw[N<<2];
        void build(int k,int l,int r)
        {
            pw[k]=1;
            if(l==r)return;
            int mid=(l+r)>>1;
            build(k<<1,l,mid);
            build(k<<1|1,mid+1,r);
        }
        void update(int k,int L,int R,int val,int l,int r)
        {
            if(L<=l&&r<=R)
            {
                pw[k]=merge(pw[k],val);
                return;
            }
            int mid=(l+r)>>1;
            if(L<=mid)update(k<<1,L,R,val,l,mid);
            if(R>mid)update(k<<1|1,L,R,val,mid+1,r);
        }
        int query(int k,int x,int l,int r)
        {
            if(l==r)return pw[k];
            int mid=(l+r)>>1;
            if(x<=mid)return merge(pw[k],query(k<<1,x,l,mid));
            else return merge(pw[k],query(k<<1|1,x,mid+1,r));
        }
    };
    struct SegmentTree2D
    {
        int lson[N*450],rson[N*450],pw[N*450];
        int rt[N<<2],tot;
        void build()
        {
            memset(rt,0,sizeof(rt));
            tot=0;
        }
        void create(int &k)
        {
            k=++tot;
            lson[k]=rson[k]=0;
            pw[k]=1;
        }
        void update(int &k,int L,int R,int val,int l,int r)
        {
            if(!k)create(k);
            if(L<=l&&r<=R)
            {
                pw[k]=merge(pw[k],val);
                return;
            }
            int mid=(l+r)>>1;
            if(L<=mid)update(lson[k],L,R,val,l,mid);
            if(R>mid)update(rson[k],L,R,val,mid+1,r);
        }
        int query(int k,int x,int l,int r)
        {
            if(!k)return 1;
            if(l==r)return pw[k];
            int mid=(l+r)>>1;
            if(x<=mid)return merge(pw[k],query(lson[k],x,l,mid));
            else return merge(pw[k],query(rson[k],x,mid+1,r));
        }
        void Update(int k,int U,int D,int L,int R,int val,int u,int d,int l,int r)
        {
            if(U<=u&&d<=D)
            {
                update(rt[k],L,R,val,l,r);
                return;
            }
            int mid=(u+d)>>1;
            if(U<=mid)Update(k<<1,U,D,L,R,val,u,mid,l,r);
            if(D>mid)Update(k<<1|1,U,D,L,R,val,mid+1,d,l,r);
        }
        int Query(int k,int x,int y,int u,int d,int l,int r)
        {
            if(u==d)return query(rt[k],y,l,r);
            int mid=(u+d)>>1;
            if(x<=mid)return merge(query(rt[k],y,l,r),Query(k<<1,x,y,u,mid,l,r));
            else return merge(query(rt[k],y,l,r),Query(k<<1|1,x,y,mid+1,d,l,r));
        }
    };
    SegmentTree ST;
    SegmentTree2D ST2;
    void Solve()
    {
        ST.build(1,1,n);
        ST2.build();
        FOR(i,1,m)
        {
            if(op[i]==1)
            {
                int len=qr[i]-ql[i]+1;
                ST.update(1,ql[i],qr[i],inv(len),1,n);
                if(ql[i]>1)ST.update(1,1,ql[i]-1,0,1,n);
                if(qr[i]<n)ST.update(1,qr[i]+1,n,0,1,n);
                ST2.Update(1,ql[i],qr[i],ql[i],qr[i],1ll*(len-2)*inv(len)%P,1,n,1,n);
                if(ql[i]>1)ST2.Update(1,1,ql[i]-1,ql[i],qr[i],1ll*(len-1)*inv(len)%P,1,n,1,n);
                if(qr[i]<n)ST2.Update(1,ql[i],qr[i],qr[i]+1,n,1ll*(len-1)*inv(len)%P,1,n,1,n);
            }
            else if(op[i]==2)
            {
                if(ql[i]==1)printf("%d\n",ST.query(1,qr[i],1,n));
                else printf("%d\n",ST2.Query(1,ql[i]-1,qr[i],1,n,1,n));
            }
        }
    }
};

int main()
{
    scanf("%d%d",&n,&m);
    FOR(i,1,m)scanf("%d%d%d",&op[i],&ql[i],&qr[i]);
    if(n<=3000&&m<=3000)
    {
        Subtask1::Solve();
        return 0;
    }
    Subtask2::Solve();
    return 0;
}