HDU 5792：World is Exploding（树状数组求逆序对）

http://acm.hdu.edu.cn/showproblem.php?pid=5792

World is Exploding

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

 

Insipired by http://blog.csdn.net/libin66/article/details/52098019

题意：比较简单直接看。

思路：分别求出在 i 的时候前面有多少比它小的（即像Aa，Ab这样升序的有多少对），用up记录，后面有多少比它小的（像Ac，Ad这样降序的有多少对），用down记录，然后ans = up * down，因为有很多重复。用树状数组维护四个数组，ls —— 在[1,i-1]有多少比a[i]小的，rs —— 在[i+1,n]有多少比a[i]小的，lb —— 在[1,i-1]有多少比a[i]大的，rb —— 在[i+1,n]有多少比a[i]大的。由容斥原理要减去 (  ls * lb + rs * rb + ls * rs + lb * rb )。

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
#define N 50005
#define MOD 1000000007
typedef long long LL;
LL ls[N], lb[N], rs[N], rb[N], bit[N];
int a[N], num[N], n, m;

/*
ls和lb是[1,i-1]中比a[i]小的数的数量，比a[i]大的数的数量
rs和rb是[i+1, n]中比a[i]小的数的数量，比a[i]大的数的数量
这些都可以通过树状数组实现
由于答案会多算进去a=c || a=d || b=c || b=d的情况，那么枚举这四种情况减去就可以了(a=c那么必定b!=d，同理其他
a=c：ans-=rs[i]*rb[i]
a=d：ans-=lb[i]*rb[i]
b=c：ans-=ls[i]*rs[i]
b=d：ans-=lb[i]*ls[i]
*/

void init()
{
    memset(ls, 0, sizeof(ls));
    memset(lb, 0, sizeof(lb));
    memset(rs, 0, sizeof(rs));
    memset(rb, 0, sizeof(rb));
    memset(sum, 0, sizeof(sum));
}

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

void update(int pos)
{
    while(pos <= m) {
        bit[pos]++;
        pos += lowbit(pos);
    }
}

LL query(int pos)
{
    LL ans = 0;
    while(pos > 0) {
        ans += bit[pos];
        pos -= lowbit(pos);
    }
    return ans;
}

int main()
{
    while(~scanf("%d", &n)) {
        init();
        for(int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
            num[i] = a[i];
        }
        sort(a+1, a+1+n);
        m = unique(a+1, a+1+n) - (a+1);
        for(int i = 1; i <= n; i++)
            num[i] = lower_bound(a+1, a+1+m, num[i]) - a;

        LL up = 0, down = 0;
        memset(bit, 0, sizeof(bit));
        for(int i = 1; i <= n; i++) {
            ls[i] = query(num[i] - 1);
            lb[i] = query(m) - query(num[i]);
            up += ls[i];
            update(num[i]);
        }

        memset(bit, 0, sizeof(bit));
        for(int i = n; i >= 1; i--) {
            rs[i] = query(num[i] - 1);
            rb[i] = query(m) - query(num[i]);
            down += rs[i];
            update(num[i]);
        }

        LL ans = 0;

        for(int i = 1; i <= n; i++) {
            ans -= ls[i] * lb[i];
            ans -= rs[i] * ls[i];
            ans -= rb[i] * lb[i];
            ans -= rb[i] * rs[i];
        }

        printf("%I64d
", up * down + ans);
    }
    return 0;
}