HDU 1394 Minimum Inversion Number

题目大意：给一个N长度的连续的但无序的数列，数列可以按体重所给的方式变换，

求出在所有变换的过程中，出现的逆序数对最少的个数。

思路：首先用线段树初始化数列的初始状态，线段树的每一个节点记录的是在第i个数输入之前数列存在的区间的数字的数量

比如：样例

  
  

   
   10
1 3 6 9 0 8 5 7 4 2
  
  
  
  


  
  

插入1时，我们就要求1之前比1 大的，此时没有。

再插入3，我们去访问此时3~N-1的数字的数量，也没有。

……

直到我们插入0，我们去访问0~N-1 的数量，找到了4个，所以SUM+=4；

这样当输入结束的时候，我们就记录的初始状态下的逆序数对的数量。

然后我们用递推：

当a0移到队末的时候，它比上一个序列多出来的是这个队列中比他大的，同时，又比它一个序列少 这个序列中比它小的数字的数量。

所以递推公式就是

sum = sum + (n-1-x[i]) - x[i];

因为它是连续的，所以第一个括号内的就是比它大的数，后面那个就是比它小的。

#include <iostream>
#include <cstdio>
#include <algorithm>
#define MAXN 5005
using namespace std;
int x[MAXN];
int tree[MAXN<<2];
void build(int num,int l,int r)
{
    tree[num]=0;
    if(l==r)return;
    int mid=(l+r)>>1;
    build(num<<1,l,mid);
    build(num<<1|1,mid+1,r);
}

void update(int num,int s,int e,int pos)
{
    if(s==e)
    {
        tree[num]++;
        return;
    }
    int mid=(s+e)>>1;
    if(pos<=mid)
    update(num<<1,s,mid,pos);
    else
    update(num<<1|1,mid+1,e,pos);
    tree[num] = tree[num<<1] + tree[num<<1|1];
}


int query(int num,int s,int e,int l,int r)
{
    if(s==l && e==r)
    {
        return tree[num];
    }
    int mid = (s+e)>>1;

    if(r<=mid)
    return query(num<<1,s,mid,l,r);
    else
    {
        if(l>mid)
        return query(num<<1|1,mid+1,e,l,r);
        else
        return query(num<<1,s,mid,l,mid) + query(num<<1|1,mid+1,e,mid+1,r);
    }
}

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        build(1,0,n-1);
        int sum=0;
        for(int i=0;i<n;i++)
        {
            scanf("%d",&x[i]);
            sum+=query(1,0,n-1,x[i],n-1);
            update(1,0,n-1,x[i]);
        }
        int ans=sum;
        for(int i=0;i<n;i++)
        {
            sum+=n-1-x[i]-x[i];
            ans=min(sum,ans);
        }
        printf("%d\n",ans);
    }
    return 0;
}