[Bjoi2018]二进制

题解：

首先发现性质

只有1个1的区间 或者 奇数个1且0的个数少于2这个区间是不合法的

然后这个东西暴力是比较好处理的

刚开始写的比较傻逼，分几种情况

先把0,1缩在一起

1.k1个0+1+k2个0

2.k1个1+0+k2个1 其中k1+k2是奇数

3.1之内单独1

4.0+奇数1

然后这样挺烦的

最讨厌写这种很容易漏掉的分类套路了。。

代码：

#include <bits/stdc++.h>
using namespace std;
#define rint register int
#define IL inline
#define dep(i,t,h) for (int i=t;i>=h;i--)
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define ll long long
const int N=2e5;
int a[N],n,m,b[N],c[N],d[N],f[N];
IL ll js(int l)
{
  ll cnt=; int jl=;
  rep(k,,l) if (b[k]==) cnt++;
  b[]=b[]^;
  rep(k,,l)
    if (b[k]!=b[k-]) c[++jl]=b[k],d[jl]=;
    else d[jl]++;
  rep(i,,jl)
    if (c[i]==)
    {
      cnt+=f[d[i]];
      if (i>) cnt+=(d[i]+)/;
      if (i<jl) cnt+=(d[i]+)/;
    }
  d[]=d[jl+]=;
  rep(i,,jl)
    if (c[i]==)
    {
      if (d[i]==) cnt+=1ll*d[i-]*d[i+];
      cnt+=max(d[i-]-,);
      cnt+=max(d[i+]-,);
    }
  rep(i,,jl-)
    if (c[i]==&&d[i]==)
    {
      cnt+=((d[i-]+)/)*(d[i+]/)+(d[i-]/)*((d[i+]+)/);
    }
  return 1ll*l*(l+)/-cnt;
}
int main()
{
  ios::sync_with_stdio(false);
  cin>>n;
  rep(i,,n) cin>>a[i];
  rep(i,,)
    rep(j,,i)
      if (j%==) f[i]+=i-j+;
  cin>>m;
  rep(i,,m)
  {
    int kk,x,y;
    cin>>kk;
    if (kk==)
    {
      cin>>x; a[x]^=;
    } else
    {
      cin>>x>>y;
      int len=y-x+;
      rep(j,x,y) b[j-x+]=a[j];
      cout<<js(len)<<endl;
    }
  }
  return ;
}

我们考虑dp

$f[i][[6]$分别对应

0：0个0,奇数个1

1：0个0,偶数个0

2：1个0,奇数个0

3：1个0,偶数个0

4：1个1,任意0

5：0个1,任意0

写之前觉得挺烦的 写了发现好像挺好写 比上面那个不知道好写到哪里去了

然后因为带修改，所以是动态dp

链上动态dp用线段树

树上动态dp用动态链分治（怎么随便做做到这么多动态dp。。）

考虑用线段树维护

我们得再用一维 表示这个是左边还是右边还是全部

另外注意一下这样我们重复计数了 就是两种情况都满足的时候

所以我们要01/10 以及1单独出现的

但其实1单独出现的时候值是我们给的 所以直接给1不给2就行了

但我写之前没想这个所以给了2然后用树状数组再维护了一下1的个数

注意维护01/10的时候一个位置能影响两边

除了updata其他都是模板

updata只要思路清晰还是挺好写的

所以这东西好像并不难写？？

代码：

#include <bits/stdc++.h>
using namespace std;
#define rint register int
#define IL inline
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define dep(i,t,h) for (int i=t;i>=h;i--)
#define me(x) memset(x,0,sizeof(x))
#define ll long long
#define mid ((h+t)>>1)
#define lowbit(x) (x&(-x))
namespace IO{
  char ss[<<],*A=ss,*B=ss;
  IL char gc()
  {
      return A==B&&(B=(A=ss)+fread(ss,,<<,stdin),A==B)?EOF:*A++;
  }
  template<class T>void read(T &x)
  {
      rint f=,c; while (c=gc(),c<||c>) if (c=='-') f=-; x=(c^);
      while (c=gc(),c>&&c<) x=(x<<)+(x<<)+(c^); x*=f;
  }
  char sr[<<],z[]; int Z,C=-;
  template<class T>void wer(T x)
  {
      if (x<) sr[++C]='-',x=-x;
      while (z[++Z]=x%+,x/=);
      while (sr[++C]=z[Z],--Z);
  }
  IL void wer1()
  {
      sr[++C]=' ';
  }
  IL void wer2()
  {
      sr[++C]='\n';
  }
  template<class T>IL void maxa(T &x,T y) {if (x<y) x=y;}
  template<class T>IL void mina(T &x,T y) {if (x>y) x=y;}
  template<class T>IL T MAX(T x,T y) {return x>y?x:y;}
  template<class T>IL T MIN(T x,T y) {return x<y?x:y;}
};
const int INF=1e9;
const int N=1e5+1e4;
using namespace IO;
vector<int> ve;
struct re{
    ll a[][],b;
};
struct sgt{
    ll f[N*][][],g[N*];
    re updata(ll x[][],ll y[][])
    {
        ll g[][]={},ans=;
        ans+=x[][]*(y[][]+y[][]);
        ans+=x[][]*(y[][]+y[][]);
        ans+=x[][]*y[][];
        ans+=x[][]*y[][];
        ans+=x[][]*y[][];
        ans+=x[][]*y[][];
        g[][]=x[][]+x[][]*y[][]+x[][]*y[][];
        g[][]=x[][]+x[][]*y[][]+x[][]*y[][];
        g[][]=x[][]+x[][]*y[][]+x[][]*y[][]
        +x[][]*y[][]+x[][]*y[][];
        g[][]=x[][]+x[][]*y[][]+x[][]*y[][]
        +x[][]*y[][]+x[][]*y[][];
        g[][]=x[][]+x[][]*y[][]+x[][]*y[][];
        g[][]=x[][]+x[][]*y[][];
        g[][]=y[][]+y[][]*x[][]+y[][]*x[][];
        g[][]=y[][]+y[][]*x[][]+y[][]*x[][];
        g[][]=y[][]+y[][]*x[][]+y[][]*x[][]
        +y[][]*x[][]+y[][]*x[][];
        g[][]=y[][]+y[][]*x[][]+y[][]*x[][]
        +y[][]*x[][]+y[][]*x[][];
        g[][]=y[][]+y[][]*x[][]+y[][]*x[][];
        g[][]=y[][]+y[][]*x[][];
        g[][]=x[][]*y[][]+x[][]*y[][];
        g[][]=x[][]*y[][]+x[][]*y[][];
        g[][]=x[][]*y[][]+x[][]*y[][]
        +x[][]*y[][]+x[][]*y[][];
        g[][]=x[][]*y[][]+x[][]*y[][]
        +x[][]*y[][]+x[][]*y[][];
        g[][]=x[][]*y[][]+x[][]*y[][];
        g[][]=x[][]*y[][];
        re k;
        memcpy(k.a,g,sizeof(g)); k.b=ans;
        return k;
    }
    void change(int x,int h,int t,int pos,int k)
    {
        if (h==t)
        {
            if (k==)
            {
                rep(i,,)
                {
                  f[x][i][]=f[x][i][]=;
                  f[x][i][]=f[x][i][]=f[x][i][]=f[x][i][]=;
                }
                g[x]=;
            } else
            {
                rep(i,,)
                {
                    f[x][i][]=f[x][i][]=;
                    f[x][i][]=f[x][i][]=f[x][i][]=f[x][i][]=;
                }
                g[x]=;
            }
            return;
        }
        if (pos<=mid) change(x*,h,mid,pos,k);
        else change(x*+,mid+,t,pos,k);
        re kk=updata(f[x*],f[x*+]);
        memcpy(f[x],kk.a,sizeof(kk.a)); g[x]=kk.b+g[x*]+g[x*+];
    }
    void query(int x,int h,int t,int h1,int t1)
    {
        if (h1<=h&&t<=t1)
        {
            ve.push_back(x); return;
        }
        if (h1<=mid) query(x*,h,mid,h1,t1);
        if (mid<t1) query(x*+,mid+,t,h1,t1);
    }
    ll query2(int x,int h,int t,int h1,int t1)
    {
        ve.clear();
        query(x,h,t,h1,t1);
        ll now[][],ans=;
        for (int i=;i<ve.size();i++) ans+=g[ve[i]];
        memcpy(now,f[ve[]],sizeof(f[ve[]]));
        for (int i=;i<ve.size();i++)
        {
            re k=updata(now,f[ve[i]]);
            memcpy(now,k.a,sizeof(k.a)); ans+=k.b;
        }
        return ans;
    }
}S;
int a[N],n,m;
struct sgt2{
    int sum[N];
    IL void c(int x,int t) { for(;x<=n;x+=lowbit(x)) sum[x]+=t;};
    IL int d(int x) {int ans=; for (;x>;x-=lowbit(x)) ans+=sum[x]; return ans;}
    IL int q(int h,int t) {return d(t)-d(h-);}
}S1,S2;
int main()
{
    read(n);
    rep(i,,n) read(a[i]);
    rep(i,,n)
    {
      S.change(,,n,i,a[i]);
      if (a[i]==) S1.c(i,);
      if (i!=n&&a[i]^a[i+]==) S2.c(i,);
    }
    read(m);
    rep(i,,m)
    {
        int kk,x,y;
        read(kk);
        if (kk==)
        {
            read(x); read(y);
            wer(1ll*(y-x+)*(y-x+)/-(S.query2(,,n,x,y)-S1.q(x,y)-S2.q(x,y-)));
            wer2();
        } else
        {
            read(x);
            if (x!=n&&a[x]^a[x+]==) S2.c(x,-);
            if (a[x]==) S1.c(x,-);
            if (x!=&&a[x-]^a[x]==) S2.c(x-,-);
            a[x]^=;
            if (a[x]==) S1.c(x,);
            if (x!=n&&a[x]^a[x+]==) S2.c(x,);
            if (x!=&&a[x-]^a[x]==) S2.c(x-,);
            S.change(,,n,x,a[x]);
        }
    }
    fwrite(sr,,C+,stdout);
    return ;
}