CF1004F Sonya and Bitwise OR （线段树+暴力区间合并）

题目链接

题意 ：给定序列a ， q次操作，包括单点修改和区间询问， 每次询问一个区间[l,r]内 ，有多少对[L,R]满足a[L,R]所有数的按位或运算结果不小于给定的x 。

分析：
序列a的每个数都小于2^20。那么每个区间的前缀（以及后缀） 扫过去进行或运算，显然这个过程中结果是递增的，但是结果变化不会超过20次。 所以我们可以用一个vector记录前缀（以及后缀）扫描过程中或运算的结果以及个数 。

所以我们用线段树维护三个信息，区间答案、前缀或运算情况、后缀或运算情况。

细节看注释

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int,int>
const int maxn = 1e5+5;
const int mx = 50;
const int mod = 1e9+5;
const ll inf = 34359738370;
const int INF = 5e5+1;
//给定序列a  q次询问  每次询问一个区间[l,r]内  有对少对[L,R]满足a[L,R]所有数的或运算结果不小于给定的x
//线段树维护区间满足的对数  以及前缀 后缀异或结果  暴力区间合并  异或运算结果是数目log级别的
int n,m,x;
struct node
{
    ll ans;
    vector<pii > st,ed;
    friend node operator + (const node&a,const node&b)
    {
        if(!a.ed.size()) return b;
        if(!b.st.size()) return a;
        node ret;
        ret.ans=a.ans+b.ans;
        //新的答案就产生于左子区间后缀 右子区间前缀 的或运算中
        for(auto &i:a.ed)
        {
            for(auto &j:b.st)
            {
                if((i.first | j.first) >=x) ret.ans+=1ll*i.second*j.second;
            }
        }
        //维护前缀异或值序列  可以看出vector中是按first递增的
        ret.st=a.st;
        int temp=a.st.back().first;
        for(auto &i:b.st)
        {
            if((i.first | temp) == temp)//这个位置和b的i.second个前缀位运算没有变化
            {
                ret.st.back().second+=i.second;
            }
            else 
            {
                temp|=i.first;//产生了变化
                ret.st.push_back({temp,i.second});
                //ret.st.push_back({temp,1ll*i.second*ret.st.back().second})   
                //这样的错的  因为前缀异或一定要连续
            }
        }
        ret.ed=b.ed;
        temp=ret.ed.back().first;
        for(auto &i:a.ed)
        {
            if((i.first | temp) == temp)
            {
                ret.ed.back().second+=i.second;
            }
            else 
            {
                temp|=i.first;
                ret.ed.push_back({temp,i.second});
            }
        }
        return ret;
    }
}tree[maxn<<2];
inline int lc(int &rt){return rt<<1;}
inline int rc(int &rt){return rt<<1|1;}
inline void pushup(int &rt)
{
    tree[rt]=tree[lc(rt)]+tree[rc(rt)];
}
//正常的建树
inline void build(int rt,int l,int r)
{
    if(l == r)
    {
        int t;scanf("%d",&t);
        tree[rt].st.push_back({t,1});
        tree[rt].ed.push_back({t,1});
        if(t>=x) tree[rt].ans=1;
        else tree[rt].ans=0;
        return ;
    }
    int mid=(l+r)>>1;
    build(lc(rt),l,mid);
    build(rc(rt),mid+1,r);
    pushup(rt);
}
//正常的单点修改
inline void dupdata(int rt,int l,int r,int pos,int v)
{
    if(l == r)
    {
        tree[rt].ed.clear();
        tree[rt].ed.push_back({v,1});
        tree[rt].st.clear();
        tree[rt].st.push_back({v,1});
        if(v>=x) tree[rt].ans=1;
        else tree[rt].ans=0;
        return ;
    }
    int mid=(l+r)>>1;
    if(pos<=mid) dupdata(lc(rt),l,mid,pos,v);
    else dupdata(rc(rt),mid+1,r,pos,v);
    pushup(rt);
}
//返回过程是区间合并 必须返回node
inline node query(int rt,int l,int r,int vl,int vr)
{
    if(vl<=l && r<=vr) return tree[rt];
    int mid=(l+r)>>1;
    if(vr<=mid) return query(lc(rt),l,mid,vl,vr);
    else if(vl>mid) return query(rc(rt),mid+1,r,vl,vr);
    return query(lc(rt),l,mid,vl,vr)+query(rc(rt),mid+1,r,vl,vr);
}
int main()
{
    scanf("%d %d %d",&n,&m,&x);
    build(1,1,n);
    while(m--)
    {
        int f,l,r;
        scanf("%d %d %d",&f,&l,&r);
        if(f==2)
        printf("%I64d\n",query(1,1,n,l,r).ans);
        else dupdata(1,1,n,l,r);
    }
    return 0;
}