poj 2299 Ultra-QuickSort（归并排序）||（树状数组+离散化）

Ultra-QuickSort

Description

In this problem, you have to analyze a particular sorting algorithm. The algorithm processes a sequence of n distinct integers by swapping two adjacent sequence elements until the sequence is sorted in ascending order. For the input sequence
9 1 0 5 4 ,

Ultra-QuickSort produces the output
0 1 4 5 9 .

Your task is to determine how many swap operations Ultra-QuickSort needs to perform in order to sort a given input sequence.
Input

The input contains several test cases. Every test case begins with a line that contains a single integer n < 500,000 – the length of the input sequence. Each of the the following n lines contains a single integer 0 ≤ a[i] ≤ 999,999,999, the i-th input sequence element. Input is terminated by a sequence of length n = 0. This sequence must not be processed.
Output

For every input sequence, your program prints a single line containing an integer number op, the minimum number of swap operations necessary to sort the given input sequence.
Sample Input

5
9
1
0
5
4
3
1
2
3
0
Sample Output

6
0

方法一：归并排序
归并排序博主貌似只懂得这一个套路。。。
代码：

#include<stdio.h>#define LL long long int#define maxn 500000+10LL s[maxn],temp[maxn];LL cont;void merge_array(LL a[],int st,int mid,int ed){    int i=st,j=mid+1,k=st;    while(i<=mid&&j<=ed)    {        if(a[i]<=a[j])            temp[k++]=a[i++];        else        {            cont+=j-k;            temp[k++]=a[j++];        }    }    while(i<=mid)        temp[k++]=a[i++];    while(j<=ed)        temp[k++]=a[j++];    for(i=st;i<=ed; i++)        a[i]=temp[i];}void merge_sort(LL a[],int st,int ed){    if(st<ed)    {        int mid=(st+ed)>>1;        merge_sort(a,st,mid);        merge_sort(a,mid+1,ed);        merge_array(a,st,mid,ed);    }}int main(){    int n;    while(~scanf("%d",&n),n)    {        for(int i=0; i<n; i++)            scanf("%d",&s[i]);        cont=0;        merge_sort(s,0,n-1);        printf("%lld\n",cont);    }    return 0;}

方法二：树状数组
因为正在树状数组入门，所以这里主要说一下树状数组

借鉴大神的说法：
由于999999999这个数字实在是大，数组也开不了这么大，而我们也可以发现最多只有500000个数据，所以我们可以离散化一下

怎么对这个输入的数组进行离散操作？

这里用一个结构体
struct Node
{
int val,pos;
}p[510000];和一个数组a[510000];

其中val就是原输入的值，pos是下标；
然后对结构体按val从小到大排序；

此时，val和结构体的下标就是一个一一对应关系，
而且满足原来的大小关系；
比如 9 1 0 5 4 ——- 离散后a数组
就是 5 2 1 4 3；

离散之后，怎么使用离散后的结果数组来进行树状数组操作，计算出逆序数？
如果数据不是很大， 可以一个个插入到树状数组中，
每插入一个数之前， 统计小于它的数的个数，
对应的大于它的数的个数为 i-1- getsum( num[i] ),
其中 i-1 为前面已经插入的数的个数，
getsum( num[i] ）为小于num[i] 的数的个数,
i-1- getsum( num[i] ) 即比 a[i] 大的个数， 即逆序的个数

代码：

#include<stdio.h>#include<string.h>#include<algorithm>using namespace std;#define maxn 500010typedef long long LL;struct node{    int x,pos;}q[maxn];int a[maxn],num[maxn];int n;int lowbit(int x){    return x&-x;}bool cmp(node s,node b){    return s.x<b.x;}void add(int i,int x){    while(i<=n)    {        a[i]+=x;        i+=lowbit(i);    }}int getsum(int i){    int sum=0;    while(i>0)    {        sum+=a[i];        i-=lowbit(i);    }    return sum;}int main(){    while(~scanf("%d",&n),n)    {        memset(a,0,sizeof(a));//注意清零        for(int i=1;i<=n;++i)        {            scanf("%d",&q[i].x);            q[i].pos=i;//记录原始的位置        }        sort(q+1,q+n+1,cmp);        for(int i=1;i<=n;++i)            num[q[i].pos]=i;//离散化        LL ans=0;        for(int i=1;i<=n;++i)        {            ans+=(i-1)-getsum(num[i]);//前面有i-1个数，getsum(num[i])为小于num[i]的数            add(num[i],1);//加入数组中        }        printf("%lld\n",ans);    }    return 0;}