POJ 2299 Ultra-QuickSort(线段树入门)

Ultra-QuickSort

Time Limit: 7000MS
Memory Limit: 65536K

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

：：本题其实就是要求出有多少逆序对。本题还要虚拟化，因为0<=a[i]<=999,999,999，开一个数组大小为1,000,000,000*4铁定超内存

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
typedef long long ll;
const int maxn=555555;
int col[maxn<<2];
int a[maxn],b[maxn],n;

void build(int l,int r,int rt)
{
    col[rt]=0;
    if(l==r) return ;
    int m=(r+l)>>1;
    build(lson);
    build(rson);
}

int find(int x)
{
    int l=1,r=n;
    while(l<=r)
    {
        int m=(l+r)>>1;
        if(x==a[m]) return m;
        if(x>a[m]) l=m+1;
        else r=m-1;
    }
    return 0;
}

void update(int p,int l,int r,int rt)
{
    col[rt]++;
    if(l==r) return ;
    int m=(l+r)>>1;
    if(p<=m) update(p,lson);
    else update(p,rson);
}

int query(int p,int l,int r,int rt)
{
    if(p<=l) return col[rt];
    int m=(l+r)>>1;
    int ans=0;
    if(p<=m)
        ans=col[rt<<1|1]+query(p,lson);
    else
        ans=query(p,rson);
    return ans;
}

int main()
{
    int i;
    while(scanf("%d",&n),n)
    {
        build(1,n,1);
        for(i=1; i<=n; i++)
        {
            scanf("%d",a+i);
            b[i]=a[i];
        }
        sort(a+1,a+n+1);//让数组a升序排序，那么等下b就可以通过a来求出对应的树是第几大（这算是虚拟化吧）
        ll sum=0;
        for(i=1; i<=n; i++)
        {
            int t=find(b[i]);
            sum+=(ll)query(t,1,n,1);
            update(t,1,n,1);
        }
        printf("%lld
",sum);
    }
    return 0;
}