给出一个序列求满足1<=a<b<=n，1<=c<d<=n，Aa<Ab，Ac>Ad的四元组个数

题目中强调了四元组哦，题目链接：HDOJ5792


先不说这个题，这个题的子问题：1<=c<d<=n，Ac>Ad是什么题？

求逆序对，是吧，所以，这个题就是用树状数组来维护区间中比自己大，比自己小的数，对吧

还需要离散化对吧，因为数字太大了，我们只需要他们的相对大小就好了

逆序对的题目链接：POJ2299

题解在这：逆序对题解


所以呢，这个题：树状数组+离散化是基本思路

需要维护什么呢？四个值：

当前数的左区间比自己小的，称为l【i】

当前数的左区间比自己大的，称为l1【i】

当前数的右区间比自己小的，称为r【i】

当前数的右区间比自己大的，称为r1【i】

然后呢，因为是四元组，肯定会有重复

最终的答案为：ab的所有可能*cd的所有可能-重复的（这就是容斥原理的应用了）

重复的总共是四种情况：ac重复+ad重复+bc重复+bd重复（ab重复和cd重复不可能）

ac重复：是r【i】*r1【i】

剩下的不列举了，一个是看相对位置，一个是看相对大小，来决定选择哪两个数来相乘

先离散化对数值进行处理，然后树状数组维护


代码如下：

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

const int maxn=5*1e4+10;
int n,MAX,tmax;
int c[maxn];
struct node{
	int num,pos;
}a[maxn];

int cmp1(node m,node n){
	if (m.num!=n.num) return m.num<n.num;
	return m.pos<n.pos;
}

int cmp2(node m,node n){
	return m.pos<n.pos;
}

int lowbit(int x){
	return x&(-x);
}

void addnum(int x,int add){
	while(x<=MAX){
		c[x]+=add;
		x+=lowbit(x);
	}
}

int getsum(int x){
	int ret=0;
	while(x){
		ret+=c[x];
		x-=lowbit(x);
	}
	return ret;
}

int l[maxn],l1[maxn],r[maxn],r1[maxn];

int main(){
	//freopen("input.txt","r",stdin);
	while(scanf("%d",&n)!=EOF){
		for(int i=1;i<=n;i++){
			a[i].pos=i;
			scanf("%d",&a[i].num);
		}
		sort(a+1,a+n+1,cmp1);
		tmax=a[1].num;
		MAX=a[1].num=1;
		for(int i=2;i<=n;i++)
			if (a[i].num>tmax){
				tmax=a[i].num;
				a[i].num=++MAX;
			}
			else a[i].num=MAX;
		sort(a+1,a+n+1,cmp2);
		memset(c,0,sizeof(c));
		for(int i=1;i<=n;i++){
			addnum(a[i].num,1);
			l[i]=getsum(a[i].num-1);
			l1[i]=getsum(MAX)-getsum(a[i].num);
		}
		memset(c,0,sizeof(c));
		for(int i=n;i>=1;i--){
			addnum(a[i].num,1);
			r[i]=getsum(a[i].num-1);
			r1[i]=getsum(MAX)-getsum(a[i].num);
		}
		__int64 ans1,ans2,ans3;
		ans1=ans2=ans3=0;
		for(int i=1;i<=n;i++){
			ans3+=1LL*l[i]*r[i];
			ans3+=1LL*l1[i]*r1[i];
			ans3+=1LL*l[i]*l1[i];
			ans3+=1LL*r[i]*r1[i];
			ans1+=l[i];
			ans2+=r[i];
		}
		//cout<<ans1<<" "<<ans2<<" "<<ans3<<endl;
		printf("%I64d\n",ans1*ans2-ans3);
	}
	return 0;
}