CF283E Cow Tennis Tournament

题意：

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

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

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

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

题解：

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

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

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

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

于是问题转化成了求每个点的出度，然后C[n][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[N];
int a[N],d[N];
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;
}