POJ 3928 & HDU 2492 Ping pong（树状数组求逆序数） - Binary Index Tree

http://poj.org/problem?id=3928

N(3<=N<=20000) ping pong players live along a west-east street(consider the street as a line segment). Each player has a unique skill rank. To improve their skill rank, they often compete with each other. If two players want to compete, they must choose a referee among other ping pong players and hold the game in the referee's house. For some reason, the contestants can't choose a referee whose skill rank is higher or lower than both of theirs. The contestants have to walk to the referee's house, and because they are lazy, they want to make their total walking distance no more than the distance between their houses. Of course all players live in different houses and the position of their houses are all different. If the referee or any of the two contestants is different, we call two games different. Now is the problem: how many different games can be held in this ping pong street?

Input

The first line of the input contains an integer T(1<=T<=20), indicating the number of test cases, followed by T lines each of which describes a test case.
Every test case consists of N + 1 integers. The first integer is N, the number of players. Then N distinct integers a1, a2 ... aN follow, indicating the skill rank of each player, in the order of west to east. (1 <= ai <= 100000, i = 1 ... N).

Output

For each test case, output a single line contains an integer, the total number of different games. 

Sample Input

1 
3 1 2 3

Sample Output

1

http://blog.csdn.net/u012860063/article/details/40155563

分别求每一个数的左右两边比它大的个数和小的个数！最后再交叉相乘即可！

const int maxn=100017;
int n;
int a[maxn], c[maxn];
int leftMax[maxn], leftMin[maxn];
int rightMax[maxn], rightMin[maxn];
typedef __int64 LL;

int Lowbit(int x) //2^k
{
    return x&(-x);
}

void update(int i, int x)//i点增量为x
{
    while(i <= maxn)//注意此处
    {
        c[i] += x;
        i += Lowbit(i);
    }
}
int sum(int x)//区间求和 [1,x]
{
    int sum=0;
    while(x>0)
    {
        sum+=c[x];
        x-=Lowbit(x);
    }
    return sum;
}

int main()
{
    int t;
    int n;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i = 1; i <= n; i++)
        {
            scanf("%d",&a[i]);
        }
        memset(c,0,sizeof(c));
        for(int i = 1; i <= n; i++)
        {
            leftMin[i] = sum(a[i]);//计算左边小的个数
            leftMax[i] = i-leftMin[i]-1;//计算左边大的个数
            update(a[i],1);
        }
        memset(c,0,sizeof(c));//再次清零
        for(int i = n,j = 1; i >= 1; i--,j++)
        {
            rightMin[i] = sum(a[i]);
            rightMax[i] = j-rightMin[i]-1;
            update(a[i],1);
        }
        LL ans = 0;
        for(int i = 1; i <= n; i++)
        {
            ans+=leftMax[i]*rightMin[i] + leftMin[i]*rightMax[i];//交叉相乘取和
        }
        printf("%I64d\n",ans);
    }
    return 0;
}

http://blog.csdn.net/acmore_xiong/article/details/47451455

有N个人从左到右排成一排，每个人有一个唯一的技能值，选出三个人——两名比赛选手还有一名裁判，裁判的技能值不能比这两个人都高，也不能比这两个人都低，并且这两个人到裁判的距离总和不能大于他们之间的距离。不同的人比赛或者比赛时候的裁判不同算不同的比赛，求一共能比几场。

分析

将题意抽象出来，就是已知数列{aN}(3<=N<=20000)其中ai，从左往右取三个不同的数（可以不相邻），求使这三个数排成升序或降序的取法数。

设L为第i个人左边的人中，技能值小于他的人数, R为第i个人左边的人中，技能值小于他的人数,那么选第i个人作为裁判的方法数Ans[i]等于(L[i] * (N - i - R[i]) +(i - 1 - L[i]) * R[i])，最终输出的答案就是枚举N个人,对Ans[i]求和。那么现在的问题就是如何求L和R数组，那么很清晰，直接树状数组对区间求和即可，方法类似于求逆序数。

TODO: http://lyeec.me/blog/binary-index-tree-outline/