zoukankan      html  css  js  c++  java
  • poj 2299(离散化+树状数组)

    Ultra-QuickSort
    Time Limit: 7000MS   Memory Limit: 65536K
    Total Submissions: 53777   Accepted: 19766

    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
    

    Source

    题意:求解一个串的逆序数的个数是多少??

    题解:离散化数组变成下标,然后每次将离散化的下标放进树状数组,放进去之后统计小于他的数的个数是多少。用 i - getsum(a[i])即为大于它的数的个数,其中 i 为当前已经插入的数的个数。

    #include <iostream>
    #include <stdio.h>
    #include <string.h>
    #include <stack>
    #include <vector>
    #include <algorithm>
    using namespace std;
    const int N = 500005;
    
    struct Node{
        int v,id;
    }node[N];
    int a[N],c[N],n;
    int lowbit(int x){
        return x&(-x);
    }
    void update(int idx,int v){
        for(int i=idx;i<=N;i+=lowbit(i)){
            c[i]+=v;
        }
    }
    int getsum(int idx){
        int sum = 0;
        for(int i=idx;i>=1;i-=lowbit(i)){
            sum+=c[i];
        }
        return sum;
    }
    int cmp(Node a,Node b){
        return a.v<b.v;
    }
    int main()
    {
        while(scanf("%d",&n)!=EOF,n){
            memset(c,0,sizeof(c));
            for(int i=1;i<=n;i++){
                scanf("%d",&node[i].v);
                node[i].id = i;
            }
            sort(node+1,node+n+1,cmp);
            for(int i=1;i<=n;i++){
                a[node[i].id] = i;
            }
            long long  cnt = 0;
            for(int i=1;i<=n;i++){
                update(a[i],1);
                cnt=cnt+ i - getsum(a[i]);
            }
            printf("%lld
    ",cnt);
        }
        return 0;
    }
  • 相关阅读:
    信息安全系统设计基础第十二周学习总结
    day07-流程控制之while循环
    day07-深浅拷贝
    第一次小测
    day05-与用户交互与运算符
    day05学习笔记-垃圾回收机制
    day04学习笔记-变量
    day03-python-学习笔记
    P4323-[JSOI2016]独特的树叶【换根dp,树哈希】
    CF990G-GCD Counting【dfs】
  • 原文地址:https://www.cnblogs.com/liyinggang/p/5655293.html
Copyright © 2011-2022 走看看