CF283E Cow Tennis Tournament

题意：

给出n个牛，每个牛有一个互不相同的能力值；

对于每对牛(x,y)之间都有一场比赛，能力值大的牛将赢过能力值小的牛；

现在FJ要更改比赛的结果，每次操作使能力值在[li,ri]中所有牛之间的比赛结果反转 (就是说如果更改两次相当于没改)；

求最后的比赛结果中有多少个三元环；

题解：

像这样在竞赛图中找三元环的问题，经常要搞一个补集转化；

这个图中一共有C
[3]个三元组，然后再减去不是三元环的三元组；

不是三元环的三元组中一定有一个点有指向另外两个点的边，也就是说这个点在它们三个的导出子图中的度数是2；

因为这个图是一个竞赛图，所以我们任意找两个相同起点的边，就相当于找到了一个不是三元环的三元组；

于是问题转化成了求每个点的出度，然后C
[3]-∑C[deg[i]][2]就是答案了；

因为每个牛之间没有顺序的关系，所以可以把所有牛排序，定义能力值小的在前面；

因为每个操作之间没有顺序的关系，所以考虑离线操作，然后按照左端点排序；

按这个顺序用线段树进行每次操作，每次将[li,ri]区间0/1反转，维护区间求和答案；

在过程中从小到大更新每个牛，当最后一个覆盖i的操作完成时，更新牛i到能力值比i大的牛的边的度数；

为什么能这么更新呢？因为如果一个操作不覆盖i显然对i没有影响，并且这时线段树中比它大的牛的0/1值的和恰好等于了它的出度；

感受一下之后，我们就求出了出度的一部分，另一部分按右端点排序再搞一遍就可以了；

然后更新答案，注意long long= =；

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define N 110000
#define lson l,mid,no<<1
#define rson mid+1,r,no<<1|1
using namespace std;
typedef long long ll;
struct node
{
int l,r;

}c
;
int a
,d
;
int sum[N<<2];
bool is[N<<2],cov[N<<2];
bool cmp1(const node &a,const node &b)
{
if(a.l!=b.l)
return a.l<b.l;
return a.r<b.r;
}
bool cmp2(const node &a,const node &b)
{
if(a.r!=b.r)
return a.r>b.r;
return a.l>b.l;
}
void Pushup(int no)
{
sum[no]=sum[no<<1]+sum[no<<1|1];
}
void Pushdown(int no,int len)
{
if(cov[no])
{
is[no<<1]^=1;
cov[no<<1]^=1;
is[no<<1|1]^=1;
cov[no<<1|1]^=1;
sum[no<<1]=(len-(len>>1))-sum[no<<1];
sum[no<<1|1]=(len>>1)-sum[no<<1|1];
cov[no]=0;
}
}
void update(int l,int r,int no,int st,int en)
{
if(st<=l&&r<=en)
{
is[no]^=1;
cov[no]^=1;
sum[no]=r-l+1-sum[no];
}
else
{
int mid=l+r>>1;
Pushdown(no,r-l+1);
if(en<=mid) update(lson,st,en);
else if(st>mid) update(rson,st,en);
else update(lson,st,en),update(rson,st,en);
Pushup(no);
}
}
int query(int l,int r,int no,int st,int en)
{
if(st<=l&&r<=en)
return sum[no];
else
{
int mid=l+r>>1;
Pushdown(no,r-l+1);
if(en<=mid) return query(lson,st,en);
else if(st>mid) return query(rson,st,en);
else return query(lson,st,en)+query(rson,st,en);
}
}
int main()
{
int n,m,i,j,k,l,r;
ll ans;
scanf("%d%d",&n,&m);
for(i=1;i<=n;i++)
scanf("%d",a+i);
sort(a+1,a+n+1);
for(i=1;i<=m;i++)
{
scanf("%d%d",&c[i].l,&c[i].r);
c[i].l=lower_bound(a+1,a+n+1,c[i].l)-a;
c[i].r=upper_bound(a+1,a+n+1,c[i].r)-a-1;
}
sort(c+1,c+m+1,cmp1);
for(i=1,j=1;i<=m;i++)
{
while(j!=n&&j<c[i].l)
{
d[j]=query(1,n,1,j+1,n);
j++;
}
if(c[i].l<=c[i].r)
update(1,n,1,c[i].l,c[i].r);
}
while(j!=n)
{
d[j]=query(1,n,1,j+1,n);
j++;
}
memset(is,0,sizeof(is));
memset(sum,0,sizeof(sum));
memset(cov,0,sizeof(cov));
sort(c+1,c+m+1,cmp2);
for(i=1,j=n;i<=m;i++)
{
while(j!=1&&j>c[i].r)
{
d[j]+=j-1-query(1,n,1,1,j-1);
j--;
}
if(c[i].l<=c[i].r)
update(1,n,1,c[i].l,c[i].r);
}
while(j!=1)
{
d[j]+=j-1-query(1,n,1,1,j-1);
j--;
}
for(i=1,ans=(ll)n*(n-1)*(n-2)/6;i<=n;i++)
{
ans-=(ll)d[i]*(d[i]-1)/2;
}
printf("%I64d\n",ans);
return 0;
}