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; }