zoukankan      html  css  js  c++  java
  • POJ 2299 UltraQuickSort 树状数组

                                                                                                  Ultra-QuickSort
    Time Limit: 7000MS   Memory Limit: 65536K
    Total Submissions: 32009   Accepted: 11395

    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
    
    代码 :
    #include<cstdio>
    #include<iostream>
    #include<algorithm>
    using namespace std ;
    #define M 500010
    int xt[M*2] , n ;
    int a[M] ;
    struct node{ int w , id ; } qe[M] ;// 用结构体储存 原始数据 id 是数据原始的位置
    int cmp( node a , node b ){ 
    	return a.w < b.w ;
    }
    int lowbit( int x ){
    	return x & ( -x ) ;
    }
    void update( int x ){
    	while( x <= n ){
    		xt[x] += 1 ;
    		x += lowbit(x) ;
    	}
    
    }
    int sum( int x ){
    	int s = 0 ;
    	while( x > 0 ){
    		s += xt[x] ;
    		x -= lowbit(x) ;
    	}
    	return s ;
    }
    int main()
    {
    	int i ;
    	long long mun ;
    	while( cin >> n ){
    		if( n == 0 ) break ;
    		mun = 0 ;
    		memset( xt , 0 , sizeof(xt) ) ;
    		for( i = 1; i <= n ;i++){
    			scanf( "%d" , &qe[i].w ) ;
    			qe[i].id = i ;
    		} 
    		sort( qe + 1 , qe + 1 + n , cmp ) ;
    		for( i = 1 ; i <= n ; i++){
                 a[qe[i].id] = i ; // 对数据进行离散化 例如 原来是 9 0 1 2 处理后是 4 1 2 3 
    		}
    		for( i = 1 ; i <= n ; i++){
    			update(a[i] ) ;
    			mun += ( i - sum(a[i] - 1 ) - 1 ) ;
    		}
    		cout << mun << endl ;
    	}
    }
    

      

  • 相关阅读:
    Go反射原理
    并发控制--context篇
    Go并发控制--WaitGroup篇
    Go依赖管理--module
    正睿培训 8.4 学习笔记
    bitset
    7.18 学习笔记
    7.17 学习笔记
    P6835 [Cnoi2020]线形生物
    UVA11300 Spreading the Wealth 思维题
  • 原文地址:https://www.cnblogs.com/20120125llcai/p/3038980.html
Copyright © 2011-2022 走看看