CF788E：New task

n个数字中，每个数有数字A和属性B，每次操作将某个点x的属性B改变为0或1，求满足这样要求的子序列的个数：

下标a<b<c<d<e，而Aa<=Ab=Ac=Ad>=Ae且Bb=Bc=Bd=1。

区间操作，首推线段树！（然后就不会了，跑去看别人的代码）

是这样的，重点在于中间那三个点，因为我们的修改操作只会影响修改的点的值的答案。

直接维护一个这样的子序列不太容易，所以多维护Aa<=Ab和Aa<=Ab=Ac和Ac=Ad>=Ae和Ad>=Ae的序列，然后线段树up的时候才可以左右合并答案。

大体思路就这样，由于线段树是要按照值来建的，也就是给每个值一棵线段树，为方便调值先离散化。

Aa<=Ab和Ad>=Ae即每个点左边<=它和右边<=它的数，可以用树状数组预处理，详见代码。

线段树中的信息用到“当前这棵子线段树的数的个数”size，以及上面提到的四个序列长度A，AB，BC，C，还有答案ABC。

在线段树叶子节点只算A，C和size，其他数组慢慢合并，详见代码中up。

 #include<cstdio>
 #include<cstdlib>
 #include<algorithm>
 #include<cstdlib>
 #include<cstring>
 //#include<iostream>
 using namespace std;

 int n;
 #define maxn 200011
 struct BIT
 {
     int a[maxn];
     void clear() {memset(a,,sizeof(a));}
     int lowbit(int x) {return x&-x;}
     void add(int x,int v)
     {
         for (;x<=n;x+=lowbit(x)) a[x]+=v;
     }
     int query(int x)
     {
         int ans=;
         for (;x;x-=lowbit(x)) ans+=a[x];
         return ans;
     }
 }bit;
 const int mod=;
 int Left[maxn],Right[maxn];
 #define maxs 2000011
 struct segmenttree
 {
     struct Node
     {
         int size,A,C,AB,BC,ABC;
         int son[];
     }a[maxs];
     int size;
     segmenttree() {size=;}
     void up(int x)
     {
         const int &p=a[x].son[],&q=a[x].son[];
         a[x].size=a[p].size+a[q].size;
         a[x].A=(a[p].A+a[q].A)%mod;
         a[x].C=(a[p].C+a[q].C)%mod;
         a[x].AB=(a[p].AB+a[q].AB+a[p].A*1ll*a[q].size)%mod;
         a[x].BC=(a[p].BC+a[q].BC+a[p].size*1ll*a[q].C)%mod;
         a[x].ABC=(a[p].ABC+a[q].ABC+1ll*a[p].A*a[q].BC+1ll*a[p].AB*a[q].C)%mod;
     }
     void modify(int &x,int L,int R,int id,int v)
     {
         if (!x) x=++size;
         if (L==R)
         {
             a[x].size=v*;
             a[x].A=v*Left[id];
             a[x].C=v*Right[id];
             a[x].AB=a[x].BC=a[x].ABC=;
             a[x].son[]=a[x].son[]=;
         }
         else
         {
             const int mid=(L+R)>>;
             if (id<=mid) modify(a[x].son[],L,mid,id,v);
             else modify(a[x].son[],mid+,R,id,v);
             up(x);
         }
     }
 }seg;
 struct Point
 {
     int v,id;
     bool operator < (const Point &b) const {return v<b.v;}
 }b[maxn];
 int a[maxn],cnt=;
 int root[maxn];
 int main()
 {
     scanf("%d",&n);
     for (int i=;i<=n;i++) scanf("%d",&b[b[i].id=i].v);
     sort(b+,b++n);
     a[b[].id]=cnt=;
     for (int i=;i<=n;i++)
     {
         if (b[i].v!=b[i-].v) cnt++;
         a[b[i].id]=cnt;
     }
     memset(Left,,sizeof(Left));
     memset(Right,,sizeof(Right));
     bit.clear();
     for (int i=;i<=n;i++)
     {
         Left[i]=bit.query(a[i]);
         bit.add(a[i],);
     }
     bit.clear();
     for (int i=n;i>=;i--)
     {
         Right[i]=bit.query(a[i]);
         bit.add(a[i],);
     }
     int ans=;
     memset(root,,sizeof(root));
     for (int i=;i<=n;i++)
     {
         ans=(ans-seg.a[root[a[i]]].ABC+mod)%mod;
         seg.modify(root[a[i]],,n,i,);
         ans=(ans+seg.a[root[a[i]]].ABC)%mod;
     }
     int m,x,y;
     scanf("%d",&m);
     for (int i=;i<=m;i++)
     {
         scanf("%d%d",&x,&y);
         ans=(ans-seg.a[root[a[y]]].ABC+mod)%mod;
         seg.modify(root[a[y]],,n,y,x-);
         ans=(ans+seg.a[root[a[y]]].ABC)%mod;
         printf("%d\n",ans);
     }
     return ;
 }