中国石油大学（华东）暑期集训--二进制（BZOJ5294）【线段树】

问题 C: 二进制

时间限制: 1 Sec  内存限制: 128 MB
提交: 8  解决: 2
[提交] [状态] [讨论版] [命题人:]

题目描述

pupil发现对于一个十进制数，无论怎么将其的数字重新排列，均不影响其是不是3的倍数。他想研究对于二进制，是否也有类似的性质。于是他生成了一个长为n的二进制串，希望你对于这个二进制串的一个子区间，能求出其有多少位置不同的连续子串，满足在重新排列后（可包含前导0）是一个3的倍数。两个位置不同的子区间指开始位置不同或结束位置不同。由于他想尝试尽量多的情况，他有时会修改串中的一个位置，并且会进行多次询问。

输入

输入第一行包含一个正整数n，表示二进制数的长度。
之后一行n个空格隔开的整数，保证均是0或1，表示该二进制串。
之后一行一个整数m，表示询问和修改的总次数。
之后m行每行为1 i，表示pupil修改了串的第i个位置（0变成1或1变成0），或2 l r，表示pupil询问的子区间是[l,r]。
串的下标从1开始。

输出

对于每次询问，输出一行一个整数表示对应该询问的结果。

样例输入

4
1 0 1 0
3
2 1 3
1 3
2 3 4

样例输出

2
3

提示

对于第一个询问，区间[2,2]只有数字0，是3的倍数，区间[1,3]可以重排成011₍₂₎=3₍₁₀₎，是3的倍数，其他区间均不能重排成3的倍数。
对于第二个询问，全部三个区间均能重排成3的倍数（注意00也是合法的）。

对于20%的数据，1≤n,m≤100；
对于50%的数据，1≤n,m≤5000；
对于100%的数据，1≤n,m≤100000，l≤r。

Solution：

设cnt0，cnt1分别为[l,r]区间内的1和0的个数，易得：

　　1. if cnt1==1 => 不可整除3

　　2. if cnt1&1 and cnt0<2 => 不可整除3

　　简单证明上述结论：

　　　　显然结论1是成立的（1<<n不可能整除3），当cnt1为偶数时，显然也一定可以整除3，而当cnt1&1时：

　　　　先考虑这种情况，将一个二进制数将其两位两位拆分并求和得到sum，显然如果 sum%3==0 ，则该二进制数的十进制一定可以整除3。

　　　　如：111010001=>(01,11,01,00,01)，sum=1+3+1+0+1=6。

　　　　那么，对于奇数个1，从中挑出cnt1-3个“1”两两组合，确保对sum%3的结果无贡献后，再看剩下的3个“1”的情况：

　　　　　　①、sum(111)=4 无法整除。【区间内无0】

　　　　　　②、sum(1101)=4,sum(1011)=5 无法整除。【区间内只含有一个0】

　　　　　　③、sum(10101)=3 可整除。【区间内至少含有两个0】

　　综上：

　　　　我们用线段树去维护上述两种不合法情况，再用【总数-不合法数=合法数】来得到答案。

　　　　其中，dl/dr[2][2] 代表经过左右节点后：cnt0=0/1，cnt1&1?1:0。

　　　　fl/fr[3] 代表经过左右节点后：满足（cnt1==1 and cnt0==0/1）的方案数。

　　　　L/R表示经过左右节点后，连续0的长度。

代码：

 #include <iostream>
 #include <string>
 #include <cstdio>
 #include <cmath>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <deque>
 #include <map>
 #include <set>
 #define range(i,a,b) for(auto i=a;i<=b;++i)
 #define LL long long
 #define ULL unsigned long long
 #define elif else if
 #define itrange(i,a,b) for(auto i=a;i!=b;++i)
 #define rerange(i,a,b) for(auto i=a;i>=b;--i)
 #define fill(arr,tmp) memset(arr,tmp,sizeof(arr))
 #define IOS ios::sync_with_stdio(false);cin.tie(0)
 using namespace std;
 int n,m,op,l,r,A[int(1e5+)];
 class SegTree{
 private:
     struct node{
         LL s,dl[][],dr[][],fl[],fr[],L,R;
         int cnt0,cnt1;
         void reset(){
             range(i,,)range(j,,)dl[i][j]=dr[i][j]=;
             fl[]=fl[]=fr[]=fr[]=fl[]=fr[]=L=R=s=cnt0=cnt1=;
         }
         node(){reset();}
     }tree[int(1e5+)<<];
     node comb(node A,node B){
         node tmp;
         range(i,,)range(j,,){
             tmp.dl[i][j]+=A.dl[i][j];
             tmp.dr[i][j]+=B.dr[i][j];
             if(i>=A.cnt0)tmp.dl[i][j]+=B.dl[i-A.cnt0][j^(A.cnt1&)];
             if(i>=B.cnt0)tmp.dr[i][j]+=A.dr[i-B.cnt0][j^(B.cnt1&)];
         }
         range(i,,){
             tmp.fl[i]+=A.fl[i];
             tmp.fr[i]+=B.fr[i];
             if(!A.cnt1)tmp.fl[min(,i+A.cnt0)]+=B.fl[i];
             if(!B.cnt1)tmp.fr[min(,i+B.cnt0)]+=A.fr[i];
         }
         if(A.cnt1== and B.L){
             ++tmp.fl[min(2LL,A.cnt0+B.L)];
             tmp.fl[]+=B.L-;
         }
         if(B.cnt1== and A.R){
             ++tmp.fr[min(2LL,B.cnt0+A.R)];
             tmp.fr[]+=A.R-;
         }
         tmp.L=(!A.cnt1?A.cnt0+B.L:A.L);tmp.R=(!B.cnt1?B.cnt0+A.R:B.R);
         tmp.cnt0=A.cnt0+B.cnt0;tmp.cnt1=A.cnt1+B.cnt1;tmp.s+=A.s+B.s;
         tmp.s+=A.dr[][]*(B.dl[][]+B.dl[][])+A.dr[][]*B.dl[][];
         tmp.s+=A.dr[][]*(B.dl[][]+B.dl[][])+A.dr[][]*B.dl[][];
         if(B.L)tmp.s+=(A.fr[]+A.fr[])*B.L+A.fr[]*(B.L-);
         if(A.R)tmp.s+=(B.fl[]+B.fl[])*A.R+B.fl[]*(A.R-);
         return tmp;
     }
     void pushup(node &tmp,int x){
         tmp.reset();
         if(x)tmp.s=tmp.fl[]=tmp.fr[]=tmp.dl[][]=tmp.dr[][]=tmp.cnt1=;
         else tmp.dl[][]=tmp.dr[][]=tmp.L=tmp.R=tmp.cnt0=;
     };
 public:
     void build(int l,int r,int rt=){
         if(l==r){
             pushup(tree[rt],A[l]);
             return;
         }
         int m=(l+r)>>;
         build(l,m,rt<<);
         build(m+,r,rt<<|);
         tree[rt]=comb(tree[rt<<],tree[rt<<|]);
     }
     void update(int l,int r,int rt,int L){
         if(l==r){
             pushup(tree[rt],A[l]);
             return;
         }
         int m=(l+r)>>;
         if(L<=m)update(l,m,rt<<,L);
         else update(m+,r,rt<<|,L);
         tree[rt]=comb(tree[rt<<],tree[rt<<|]);
     }
     node query(int l,int r,int rt,int L,int R){
         if(L<=l and r<=R)return tree[rt];
         int m=(l+r)>>;
         if(R<=m)return query(l,m,rt<<,L,R);
         if(L>m)return query(m+,r,rt<<|,L,R);
         return comb(query(l,m,rt<<,L,m),query(m+,r,rt<<|,m+,R));
     }
 }segTree;
 void init(){
     scanf("%d",&n);
     range(i,,n)scanf("%d",A+i);
     segTree.build(,n);
     scanf("%d",&m);
 }
 void solve(){
     while(m--){
         scanf("%d%d",&op,&l);
         if(op&)A[l]^=,segTree.update(,n,,l);
         else{
             scanf("%d",&r);
             printf("%lld\n",1LL*(r-l+)*(r-l+)/-segTree.query(,n,,l,r).s);
         }
     }
 }
 int main() {
     init();
     solve();
     return ;
 }