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+10
LL 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 500010
typedef 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;
}