World is Exploding HDU - 5792 (离散化+树状数组）

Given a sequence A with length n,count how many quadruple (a,b,c,d) satisfies: $a≠b≠c≠d,1≤a<b≤n,1≤c<d≤n,A_a<A_b,A_c>A_d$.
Input
The input consists of multiple test cases.
Each test case begin with an integer n in a single line.

The next line contains n integers$A1,A2⋯AnA1,A2⋯An$.
1≤n≤500001≤n≤50000
0≤Ai≤1e90≤Ai≤1e9
Output
For each test case,output a line contains an integer.
Sample Input
4
2 4 1 3
4
1 2 3 4
Sample Output
1
0
最近总是做到这个类型的题，发现离散化和树状数组捆绑的很紧密，如果发现题目的要求之和数于数之间的大小有关系而非具体的值，那么可以离散化了，
这题的思路是找出数列里的所有的正序对（$num1$）和逆序对的（$num2$）个数相乘，但是里面会有重不合法的情况，不能满足4个index都不相等，会有4种情况

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#define N 50005
using namespace std;
int n;
int a[N];
int id[N];
int c[N];
int Lmin[N],Rmin[N],Lmax[N],Rmax[N];
int lowBit(int x)
{
    return x&-x;
}
int sum(int x)
{
    int ans=0;
    while(x>0)
    {
        ans+=c[x];
        x-=lowBit(x);
    }
    return ans;
}
void change(int x,int p)
{
    while(x<=n)
    {
        c[x]+=p;
        x+=lowBit(x);
    }
}
int main()
{
    while(scanf("%d",&n)==1)
    {
        memset(Lmin,0,sizeof(Lmin));
        memset(Rmin,0,sizeof(Rmin));
        memset(Lmax,0,sizeof(Lmax));
        memset(Rmax,0,sizeof(Rmax));
        for(int i=0;i<n;i++)
        {
            scanf("%d",a+i);
            id[i]=a[i];
        }
        sort(id,id+n);
        int num=unique(id,id+n)-id;
        for(int i=0;i<n;i++)
        a[i]=lower_bound(id,id+num,a[i])-id+1;
        int num1=0,num2=0;
        memset(c,0,sizeof(c));
        for(int i=0;i<n;i++)
        {
            Lmin[i]=sum(a[i]-1);
            num1+=Lmin[i];
            Lmax[i]=sum(n)-sum(a[i]);
            num2+=Lmax[i];
            change(a[i],1);
        }
        memset(c,0,sizeof(c));
        for(int i=n-1;i>=0;i--)
        {
            Rmin[i]=sum(a[i]-1);
            Rmax[i]=sum(n)-sum(a[i]);       
            change(a[i],1);
        }
        long long ans=(long long)num1*num2;
        for(int i=0;i<n;i++)
        {
            ans-=Lmin[i]*Rmin[i];
            ans-=Lmax[i]*Rmax[i];
            ans-=Lmax[i]*Lmin[i];
            ans-=Rmax[i]*Rmin[i];
        }
        printf("%lld\n",ans);
    }
}