POJ2299——Ultra-QuickSort

最新推荐文章于 2022-12-15 12:59:42 发布

阿里卡通

最新推荐文章于 2022-12-15 12:59:42 发布

阅读量306

点赞数

分类专栏： ----OJ题目---- POJ 文章标签： poj 算法归并排序

本文链接：https://blog.csdn.net/smile_kai/article/details/52165513

版权

----OJ题目---- 同时被 2 个专栏收录

52 篇文章 0 订阅

订阅专栏

POJ

43 篇文章 0 订阅

订阅专栏

Ultra-QuickSort

Time Limit: 7000MS		Memory Limit: 65536K
Total Submissions: 55310		Accepted: 20391

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

Sample Output

6
0

Source

Waterloo local 2005.02.05

题目大意：

说简单点，就是求冒泡排序的交换次数，但是这里用暴力冒泡会超时，所以，更好的办法是用归并排序；

思路：

求逆序数、、、、

#include <iostream>
#include <cstdio>
#include <cstdlib>

using namespace std;

const int inf = 1000000000;
long long cnt;

void dell(int *a, int h, int mid, int t)
{
    int L = mid - h + 1;
    int R = t - mid;
    int *left = new int[L+2];
    int *right = new int[R+2];

    for( int i = 1; i <= L; i++)
        left[i] = a[h+i-1];
    left[L+1] = inf;

    for( int i = 1; i <= R; i++ )
        right[i] = a[mid+i];
    right[R+1] = inf;

    int k = h;
    int i, j;
    i = j = 1;
    while(k<=t)
    {
        if( left[i]<=right[j] )
            a[k++] = left[i++];
        else
        {
            a[k++] = right[j++];
            cnt += L - i + 1;
        }
    }
    free(left);
    free(right);          //用完之后要释放  否则会MLE
    return;
}

void msort(int *a, int h, int t)    //归并排序
{
    if( h<t )
    {
        int mid = (h+t)/2;
        msort(a,h,mid);
        msort(a,mid+1,t);
        dell(a,h,mid,t);
    }
    return;
}

int main()
{
    int n;
    while(cin>>n&&n)
    {
        int *a;
        a = new int[n+1];
        for( int i = 1; i <= n; i++ )
            cin>>a[i];

        cnt = 0;
        msort(a,1,n);
        cout<<cnt<<endl;

        free(a);

    }


    return 0;
}