Poj2299 -- B-ultra-quicksort (line segment tree, discretization)

Ultra-quicksort

Time limit:7000 Ms		Memory limit:65536 K
Total submissions:41215		Accepted:14915

Description

In this problem, you have to analyze a particle 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 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 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

59105431230

Sample output

60

 

Obtain the minimum number of exchanges to make the array orderly (from small to large ). That is, to find the number of reverse orders, this question is merged and sorted, and the tree array, the line segment tree can be resolved again, can be used as a trainer

If we use the line segment tree to solve the problem, we need to discretization because the given value is very large. At the beginning, we directly used map to time out. We can only think of a simpler discrete method, use the struct to store the value K at the beginning and its initial sequence number (id1). Sort sorts K to obtain the new sequence number (Id2), and directly change the given array through id1, change to Id2, so that only the time of N + logn can be done discretely (pay attention to the repeated value, and the repeated value shares an Id2 ). The line segment tree is a template.

#include <cstdio>#include <cstring>#include <algorithm>using namespace std;#define LL __int64#define maxn 600000#define lmin 1#define rmax n#define lson l,(l+r)/2,rt<<1#define rson (l+r)/2+1,r,rt<<1|1#define root lmin,rmax,1#define now l,r,rt#define int_now LL l,LL r,LL rtstruct node{    LL id1 , id2 ;    LL k ;}p[maxn] ;LL cl[maxn<<2] , a[maxn] ;bool cmp(node a,node b){    return a.k < b.k ;}void push_up(int_now){    cl[rt] = cl[rt<<1] + cl[rt<<1|1] ;}void update(LL i,int_now){    if( i < l || i > r )        return ;    if( i == l && i==r )    {        cl[rt]++ ;        return ;    }    update(i,lson);    update(i,rson);    push_up(now);    return ;}LL query(int ll,int rr,int_now){    if( ll > r || rr < l )        return 0;    if( ll <= l && r <= rr )        return cl[rt] ;    return query(ll,rr,lson) + query(ll,rr,rson);}int main(){    LL i , n , m , l , r , x , num ;    while(scanf("%I64d", &m) && m)    {        for(i = 0 ; i < m ; i++)        {            scanf("%I64d", &a[i]);            p[i].k = a[i] ;            p[i].id1 = i ;        }        sort(p,p+m,cmp);        int temp = -1 ;        n = 0 ;        for(i = 0 ; i < m ; i++)        {            if( p[i].k == temp )                p[i].id2 = n ;            else            {                p[i].id2 = ++n ;                temp = p[i].k ;            }        }        for(i = 0 ; i < m ; i++)            a[ p[i].id1 ] = p[i].id2 ;        memset(cl,0,sizeof(cl));        num = 0 ;        for(i = 0 ; i < m ; i++)        {            num += (i - query(1,a[i],root));            update(a[i],root);        }        printf("%I64d\n", num);    }    return 0;}