HDU 5792 World is Exploding （容斥原理＋离散化＋树状数组）

World is Exploding

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 330    Accepted Submission(s): 151

Problem Description

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,Aa<Ab,Ac>Ad .

 

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⋯An .
1≤n≤50000
0≤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
  
  

 

Author

ZSTU

 

Source

2016 Multi-University Training Contest 5

 

Recommend

wange2014   |   We have carefully selected several similar problems for you:   5791  5790  5789  5788  5787

题目大意：
    给出一个数字序列，求所有的四元组（a,b,c,d）满足 a≠b≠c≠d,1≤a<b≤n,1≤c<d≤n,Aa<Ab,Ac>Ad 。求满足条件的四元组的个数。

解题思路：
    由容斥原理可以得满足条件的四元组的个数就是上升的数对的个数乘上下降的数对的个数再减去四种有端点重叠的情况。至于这几种情况的数目的计算，用树状数组就可以高效的求出，这不是本题难点。此外由于a[i]的范围非常大，为了保证树状数组求值的高效还应该对a[i]进行离散化处理。

附AC代码：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <queue>
#include <vector>
#include <map>
using namespace std;
#define LL long long
#define fi first
#define se second

const int maxn=50000+3;
int N,a[maxn];
LL left_up[maxn],left_down[maxn];
int bit[maxn+1];//树状数组
pair<int,int> to_index[maxn];//值，原下标（用来离散化）

int sum(int i)
{
    int s=0;
    while(i>0)
    {
        s+=bit[i];
        i-=i&-i;
    }
    return s;
}

void add(int i,int x)
{
    while(i<=N)
    {
        bit[i]+=x;
        i+=i&-i;
    }
}

int main()
{
    while(~scanf("%d",&N))
    {
        memset(bit,0,sizeof bit);
        LL up=0,down=0,case1=0,case2=0,case3=0,case4=0;
        for(int i=1;i<=N;++i)
        {
            scanf("%d",&a[i]);
            to_index[i].fi=a[i];
            to_index[i].se=i;
        }
        sort(to_index+1,to_index+N+1);
        int cnt=1;
        a[to_index[1].se]=1;
        for(int i=2;i<=N;++i)//离散化
        {
            if(to_index[i].fi!=to_index[i-1].fi)
                ++cnt;
            a[to_index[i].se]=cnt;
        }
        for(int i=1;i<=N;++i)
        {
            left_up[i]=sum(a[i]-1);//前面比它小的
            left_down[i]=sum(N)-sum(a[i]);//前面比它大的
            up+=left_up[i];
            down+=left_down[i];
            add(a[i],1);
        }
        memset(bit,0,sizeof bit);//再次初始化树状数组
        for(int i=N;i>0;--i)
        {
            LL right_down=sum(a[i]-1);
            LL right_up=sum(N)-sum(a[i]);
            add(a[i],1);
            case1+=left_up[i]*right_down;//上图四种情况
            case2+=left_down[i]*right_up;
            case3+=right_up*right_down;
            case4+=left_up[i]*left_down[i];
        }
        printf("%lld\n",up*down-case1-case2-case3-case4);
    }
    
    return 0;
}