POJ 2299 Ultra-QuickSort (求逆序数)

最新推荐文章于 2021-08-20 09:50:19 发布

原创最新推荐文章于 2021-08-20 09:50:19 发布 · 524 阅读

1 ·

CC 4.0 BY-SA版权

本文介绍了一种名为Ultra-QuickSort的排序算法，并详细解释了该算法如何通过交换相邻元素来对序列进行排序的过程。文章提供了两种实现方法，一种是使用归并排序，另一种则是结合线段树和离散化技术。

Ultra-QuickSort

Time Limit: 7000MS		Memory Limit: 65536K
Total Submissions: 31927		Accepted: 11375

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

水题，求逆序数。

做法一：归并排序  3772k 360ms

#include <iostream>
#include <cstdio>

using namespace std;

int first[1000005],temp[1000005];
__int64 ans;

void merge(int low,int mid,int high)
{
    int i=low,j=mid+1,k=low;
    while(i<=mid && j<=high)
    {
        if(first[i]<=first[j])
        {
            temp[k++]=first[i++];
        }
        else
        {
            temp[k++]=first[j++];
            ans += (mid-i+1);
        }
    }
    while(i<=mid)
    {
        temp[k++]=first[i++];
    }
    while(j<=high)
    {
        temp[k++]=first[j++];
    }
    for(i=low;i<=high;i++)
        first[i]=temp[i];
}

void mergeSort(int a,int b)
{
    if(a<b)
    {
        int mid=(a+b)/2;
        mergeSort(a,mid);
        mergeSort(mid+1,b);
        merge(a,mid,b);
    }
}

int main()
{
    int N;
    while(cin>>N && N)
    {
        ans=0;
        for(int i=0;i<N;i++)
            scanf("%d",&first[i]);
        mergeSort(0,N-1);
        printf("%I64d\n",ans);
    }
    return 0;
}
 
 
 
 
做法二：线段树+离散化 40560K 3985MS

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <algorithm>
#define SIZE 500005
#define ls l,mid,rt<<1
#define rs mid+1,r,rt<<1|1

using namespace std;

typedef __int64 Int;
int N,idx;
Int sum[SIZE<<2];
int a[SIZE];
int temp[SIZE];
set <int> st;
set <int>::iterator it;

void update(int l,int r,int rt,int v)
{
    sum[rt] ++;
    if(l == r)
        return;
    int mid = (l + r) >> 1;
    if(v <= mid)update(ls,v);
    else update(rs,v);
}

Int query(int l,int r,int rt,int L,int R)
{
    if(L <= l && r <= R)
        return sum[rt];
    int mid = (l + r) >> 1;
    Int ret = 0;
    if(L <= mid)ret += query(ls,L,R);
    if(R > mid)ret += query(rs,L,R);
    return ret;
}

int binarySearch(int tar)
{
    int low = 1, high = idx;
    while(low <= high)
    {
        int mid = (low + high) >> 1;
        if(temp[mid] > tar)
            high = mid - 1;
        else if(temp[mid] < tar)
            low = mid + 1;
        else
            return mid;
    }
    return -1;
}

int main()
{
    while(~scanf("%d",&N) && N)
    {
        idx = 0;
        st.clear();
        for(int i=1; i<=N; i++)
        {
            scanf("%d",&a[i]);
            a[i] ++;
            st.insert(a[i]);
        }
        for(it = st.begin(); it != st.end(); it ++)
            temp[++idx] = (*it);
        sort(temp+1,temp+1+idx);
        memset(sum,0,sizeof(sum));
        int L;
        Int ans = 0;
        for(int i=1; i<=N; i++)
        {
            L = binarySearch(a[i]);
            ans += query(1,idx,1,L,idx);
            update(1,idx,1,L);
        }
        printf("%I64d\n",ans);
    }
    return 0;
}