Hrbust 2224 逆序对问题【归并排序/离散化树状数组】

逆序对问题
Time Limit: 500 MS Memory Limit: 32768 K
Total Submit: 386(94 users) Total Accepted: 78(59 users) Rating: Special Judge: No
Description
给定 n 个数组成的数组，求其逆序对的总数。

逆序对定义为，存在 (i, j) 满足 i < j 且 A[i] > A[j] 的二元组的数目。

Input
第一行包含一个整数，表示数组的项数。

接下来的一行，包含 n 个数（2 <= n <= 100000），依次表示 A[i](A[i] <= 10^9)。

Output
输出一行表示对应的答案。。
Sample Input
5

1 3 2 5 4

Sample Output
2
Source
“诚德软件杯”哈尔滨理工大学第四届ACM程序设计团队赛

 一：利用归并排序的特性求逆序数的对数。

#include <stdio.h>
#include <iostream>
using namespace std;
#define MAX 1000010
#define MN 1000000050
#define LL long long
LL sum;
int a[MAX];
int L[MAX/2],R[MAX/2];

void merge(int A[],int p,int q,int r)
{
    int n1=q-p+1,n2=r-q,i,j;
    for (i=1; i<=n1; i++)
        L[i]=A[p+i-1];
    for (i=1; i<=n2; i++)
        R[i]=A[q+i];
    R[n2+1]=L[n1+1]=MN;
    i=j=1;
    for (int k=p; k<=r; k++)
    {
        if(L[i]<=R[j])
            A[k]=L[i++];
        else
        {
            A[k]=R[j++];
            sum+=n1-i+1;
        }
    }
}

void merge_sort(int A[],int p,int r)
{
    int q;
    if(p<r)
    {
        q=(p+r)>>1;
        merge_sort(A,p,q);
        merge_sort(A,q+1,r);
        merge(A,p,q,r);
    }
}

int main()
{
    int t,i,n,num,k;
    while(~scanf("%d",&n))
    {

        sum=0;
        for(i=1; i<=n; i++)
        {
            scanf("%d",&a[i]);
        }
        merge_sort(a,1,n);
        printf("%lld\n",sum);
    }
    return 0;
}

二：使用树状数组动态改变逆序对的值、数据范围到10^9,但是n的范围是10^5、直接开树的数组开不到10^9，所以需要离散化、

关于离散化：因为题目中a[i]可以到999,999,999之多，在运用树状数组操作的时候，用到的树状数组C[i]是建立在一个有点像位存储的数组的基础之上的，不是单纯的建立在输入数组之上。
比如输入一个9 1 0 5 4（最大9），那么C[i]树状数组的建立是在：
下标 0 1 2 3 4 5 6 7 8 9 –下标就要建立到9
数组 1 1 0 0 1 1 0 0 0 1 –通过1来表示存在
现在由于999999999这个数字相对于500000这个数字来说是很大的，所以如果用数组位存储的话，那么需要999999999的空间来存储输入的数据。 这样是很浪费空间的，题目也是不允许的，所以这里想通过离散化操作。

那么怎么离散化操作呢？离散化是一种常用的技巧，有时数据范围太大，可以用来放缩到我们能处理的范围，必要的是建立一个结构体a[n]，v表示输入的值，order表示原i值，再用一个数组aa[n]存储离散化后的值
例如：
i：1 2 3 4 5
v: 9 0 1 5 4
排序后:0 1 4 5 9
order:2 3 5 4 1 如果建立映射：aa[a[i].order]=i;
aa:5 1 2 4 3
即原本的9经过排序应该在第5位，现在aa[1]=5，对应原来的9，大小次序不变，只是将9缩小到了5

关于最终求逆序对：

我们把离散化后的数据每次都入树，同时统计之前入树的有多少个元素比他大，加和即可。

#include<stdio.h>  
#include<string.h>  
#include<iostream>  
#include<algorithm>  
using namespace std;  
struct zuobiao  
{  
    int date,pos;  
}a[121212];  
int tree[1000005];  
int aa[121212];  
int n;  
int lowbit(int x)  
{  
    return x&(-x);  
}  
int sum(int x)  
    int sum=0;  
    while(x>0)  
    {  
        sum+=tree[x];  
        x-=lowbit(x);  
    }  
    return sum;  
}  
void add(int x,int c)//加数据。  
{  
    while(x<=n)  
    {  
        tree[x]+=c;  
        x+=lowbit(x);  
    }  
}  
int cmp(zuobiao a,zuobiao b)  
{  
    if(a.date==b.date)  
    return a.pos<b.pos;  
    else  
    return a.date<b.date;  
}  
int main()  
{  
    while(~scanf("%d",&n))  
    {  
        if(n==0)break;  
        memset(tree,0,sizeof(tree));  
        long long int  output=0;  
        for(int i=1;i<=n;i++)  
        {  
            scanf("%d",&a[i].date);  
            a[i].pos=i;  
        }  
        sort(a+1,a+n+1,cmp);  
        for(int i=1;i<=n;i++)  
        {  
            aa[a[i].pos]=i;  
        }  
        for(int i=1;i<=n;i++)  
        {  
            add(aa[i],1);  
            output+=(i-sum(aa[i]));  
        }  
        printf("%lld\n",output);  
    }  
}