?Ultra-QuickSort

Ultra-QuickSort

Time Limit: 7000MS   Memory Limit: 65536K
Total Submissions: 44489   Accepted: 16176

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
题目大意就是让你计算一个冒泡排序中,需要交换的次数。以为数据量较大,所以我们这里用到了Merge Sort :

 1 #include<stdio.h>
 2 #include<string.h>
 3 int temp[500005] ;
 4 int a[500005] ;
 5 __int64 number ;
 6 void MergeSort( int a[] , int fir , int end )
 7 {
 8     int len = end - fir ;
 9     if( len <= 1 )
10         return ;
11     int mid = fir + len/2 ;
12     MergeSort( a , fir , mid ) ;
13     MergeSort( a , mid , end ) ;
14     int p1 = fir , p2 = mid ;
15     for( int i = fir ; i < end ; i++ )
16     {
17         if( p1 == mid )
18         {
19             temp[i] = a[p2++] ;
20         }
21         else if( p2 == end )
22         {
23             temp[i] = a[p1++] ;
24         }
25         else
26         {
27             if( a[p1] >= a[p2] )
28             {
29                 temp[i] = a[p2++] ;
30                 number += mid - p1 ;//在Merge Sort 排序中仅仅多加了这句话
31             }
32             else
33             {
34                 temp[i] = a[p1++] ;
35             }
36         }
37     }
38
39     for(int i = fir ; i < end ; i++ )
40     {
41         a[i] = temp[i] ;
42     }
43 }
44 int main()
45 {
46    // freopen("a.txt" ,"r" , stdin );
47     int n ;
48     while( scanf("%d" , &n ) != EOF )
49     {
50         if( n == 0 ) break;
51         number = 0 ;
52         for(int i = 0 ; i < n ; i++ )
53             scanf("%d" , &a[i] ) ;
54         MergeSort( a , 0 , n ) ;
55
56         printf("%I64d\n" , number );
57     }
58     return 0 ;
59 }

AC

时间: 2024-12-13 05:02:54

?Ultra-QuickSort的相关文章

poj-2299 Ultra—QuickSort(归并排序求逆序数)

Ultra-QuickSort Time Limit: 7000MS   Memory Limit: 65536K Total Submissions: 38688   Accepted: 13950 Description In this problem, you have to analyze a particular sorting algorithm. The algorithm processes a sequence of n distinct integers by swappin

归并排序求逆序对模板(未完待续)

归并排序求逆序对题目(持续更新) \(1.\) \(Ultra\) \(Quicksort\) (需要该篇博文的阅读密码) 归并排序求逆序对 细节:传参三个,左.中.右三端点,每次运算注意中端点总取左右端点和的一半:返回条件为左右端点相等,此时无需排序. \(View\) \(Code\) void msort(int l,int mid,int r) { if(l==r) return; msort(l,(l+mid)>>1,mid); msort(mid+1,(r+mid+1)>&g

数组去重算法,quickSort

function removeRepeat(arr) { var arr2 = [] ,obj = {}; for (var i = 0; i<arr.length; i++) { var num = arr[i]; //先把arr的第[i]num if( !obj[num] ){ //如果上面有个true,那么就不要push进数组,否则就push进数组 arr2.push(num); obj[num] = true; //不要忘记push到数组以后把obj上的属性设置为true,那么下次有一样

排序算法四:快速排序(Quicksort)

快速排序(Quicksort),因其排序之快而得名,虽然Ta的平均时间复杂度也是o(nlgn),但是从后续仿真结果看,TA要比归并排序和堆排序都要快. 快速排序也用到了分治思想. (一)算法实现 1 protected void quicksort(int[] array, int first, int last) { 2 3 int pivot = array[first]; 4 int i = first; 5 int j = last - 1; 6 boolean serachBig =

快速排序QuickSort

前几天实现了直接插入排序.冒泡排序和直接选择排序这三个基础排序.今天看了一下冒泡排序的改进算法,快速排序.单独记录一下,后面还有归并和基数排序等 快速排序 1.选择一个支点默认为数组第一个元素及array[start]作为支点,将所有大于支点元素的值放到支点后面,将所有小于支点元素的值放到支点前面,完成一次划分,返回支点的位置index 2.通过一个划分形成两个带排序的序列,[start, index - 1]和[index + 1, end]两个,在执行1直到序列元素只有1个则已经完成排序 具

快速排序(quicksort)

快速排序是对冒泡排序算法的一种改进型算法,而且快速排序也采用了分治法的思想.快速排序是不稳定排序, 平均时间复杂度为:O(n*logn),最坏时间复杂度为:O(n*n),空间时间复杂度:O(logn),但快速排序通常是用于排 序的最佳实用的选择. 快速排序的思想:从数组选取一个数(通常是第一个数)作为标准,从数组的高位开始查找,找到比作为标准数小的数 ,然后进行交换,又从数组的低位开始查找,找到比作为标准大的数,然后进行交换,重复以上步骤,直至从高位到低位, 低位到高位重合为止. 示例: 6  

排序--QuickSort 快排

Quick の implementation 快排,就像它的名字一定,风一样的快.基本上算是最快的排序算法了.快排的基本思想是选择一个切分的元素.把这个元素排序了.所有这个元素左边的元素都小于这个元素,所有这个元素右边的元素都大于这个元素.接着再把左右2个数组分别排序. 假设你有如下数组 (所有 i  左边的对象都小于 切分对象. 所有 j  右边的对象都大于切分对象 这句话稍后有用 先知道一下) 首先,我们把index = 0 的元素当作切分元素. 从index = 1 的位置开始,找到第一个

quicksort(java版)

相信大家都知道几种排序算法,比如说冒泡排序,选择排序,插入排序等等,这些个算法都不是很难,自己多多理解理解就能掌握了,而今天我们要谈的就是重头戏就是快速排序. 引用大牛的思想来对排序算法解释一下.(文章链接:http://bubkoo.com/2014/01/12/sort-algorithm/quick-sort/#参考文章) 快速排序是图灵奖得主C. R. A. Hoare 于 1960 年提出的一种划分交换排序.它采用了一种分治的策略,通常称其为分治法(Divide-and-Conquer

【Sort】QuickSort

快速排序,平均运行时间O(N log N),最坏运行时间O(N^2). 我觉得先看Python版的快排算法(http://www.cnblogs.com/fcyworld/p/6160558.html)比较容易理解. 整体思路: 首先从数组中选出一个值pivot,然后依据这个值pivot,把数组分成大小两部分,然后再分别对这两部 分利用快排. 具体细节: 1.在具体的实现中,因为pivot的选择会对数组的划分产生很大的影响,若划分的不均衡,则极大的影响 排序时间.为了尽可能消除这种影响,同时取数

快速排序(QuickSort)

1.算法思想    快速排序是一种划分交换排序.它采用了一种分治的策略,通常称其为分治法(Divide-and-ConquerMethod). (1) 分治法的基本思想    分治法的基本思想是:将原问题分解为若干个规模更小但结构与原问题相似的子问题.递归地解这些子问题,然后将这些子问题的解组合为原问题的解. (2)快速排序的基本思想    设当前待排序的无序区为R[low..high],利用分治法可将快速排序的基本思想描述为:①分解:      在R[low..high]中任选一个记录作为基准