Ultra-QuickSort
Time Limit: 7000MS | Memory Limit: 65536K | |
Total Submissions: 20073 | Accepted: 7102 |
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
Ultra-QuickSort produces the output
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
Source
#include <iostream>
using namespace std;
const int SORT_NUM = 500000;
const int MAX_NUM=999999999;
long long reverse_num;
void merge(int* a, int p, int r, int q)
{
int L[r-p+1], R[q-r];
int ln, rn, an;
for(int i=0; i<=r-p; i++)
{
L[i]=a[p+i];
}
for(int j=0; j<=q-r-1; j++)
{
R[j]=a[j+r+1];
}
ln=0;
rn=0;
an=p;
while(ln<=r-p && rn<=q-r-1)
{
if(L[ln]<=R[rn])
{
a[an]=L[ln];
an++;
ln++;
}
else
{
a[an]=R[rn];
an++;
rn++;
reverse_num += (r-p-ln+1);
}
}
while(ln<=r-p)
{
a[an]=L[ln];
an++;
ln++;
}
while(rn<=q-r-1)
{
a[an]=R[rn];
an++;
rn++;
}
}
void merge_sort(int* a, int p, int q)
{
int r;
if(p<q)
{
r=(p+q)/2;
merge_sort(a,p,r);
merge_sort(a,r+1,q);
merge(a,p,r,q);
}
}
int main()
{
int a[SORT_NUM];
int n;
cin>>n;
while(n!=0)
{
reverse_num=0;
for(int i=0; i<n; i++)
{
cin>>a[i];
}
merge_sort(a,0,n-1);
cout<<reverse_num<<endl;
cin>>n;
}
return 0;
}