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, , sizeof(ls));
     memset(lb, , sizeof(lb));
     memset(rs, , sizeof(rs));
     memset(rb, , sizeof(rb));
     memset(sum, , 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 = ;
     while(pos > ) {
         ans += bit[pos];
         pos -= lowbit(pos);
     }
     return ans;
 }

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

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

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

         LL ans = ;

         for(int i = ; 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\n", up * down + ans);
     }
     return ;
 }