ZOJ-2386 Ultra-QuickSort 【树状数组求逆序数+离散化】

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



题解:

树状数组求逆序数,先离散化,不然1e9开不下,然后每次对一个数id[i],将树状数组中这个位置+1,统计这个位置的前缀和,然后用i-sum(id[i])(差实际上就是id[i]位置后缀和)就是这个数id[i]导致的逆序对数量。

代码:

 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 #include<algorithm>
 5 using namespace std;
 6 #define INF 0x3f3f3f3f
 7 #define M(a, b) memset(a, b, sizeof(a))
 8 const int N = 5e5 + 10;
 9 int c[N], id[N], n;
10 struct node {
11     int val, pos;
12     bool operator < (const node &rhs) const {
13         return val < rhs.val;
14     }
15 }a[N];
16
17 int lowbit(int x) {return x & -x;}
18
19 void add(int x, int d) {
20     while (x <= n) {
21         c[x] += d;
22         x += lowbit(x);
23     }
24 }
25
26 int sum(int x) {
27     long long ret = 0;
28     while (x) {
29         ret += c[x];
30         x -= lowbit(x);
31     }
32     return ret;
33 }
34
35 int main() {
36     while (scanf("%d", &n), n) {
37         M(c, 0);
38         for (int i = 1; i <= n; ++i)
39             scanf("%d", &a[i].val), a[i].pos = i;
40         sort(a+1, a+1+n);
41         for (int i = 1; i <= n; ++i) id[a[i].pos] = i;
42         long long ans = 0;
43         for (int i = 1; i <= n; ++i) {
44             add(id[i], 1);
45             ans += i-sum(id[i]);
46         }
47         printf("%lld\n", ans);
48     }
49
50     return 0;
51 }
时间: 2024-12-06 00:45:18

ZOJ-2386 Ultra-QuickSort 【树状数组求逆序数+离散化】的相关文章

poj 2299 树状数组求逆序数+离散化

http://poj.org/problem?id=2299 最初做离散化的时候没太确定但是写完发现对的---因为后缀数组学的时候,,这种思维习惯了吧 1.初始化as[i]=i:对as数组按照num[]的大小间接排序 2.bs[as[i]]=i:现在bs数组就是num[]数组的离散化后的结果 3.注意,树状数组中lowbit(i)  i是不可以为0的,0&(-0)=0,死循环... #include <cstdio> #include <cstring> #include

poj 2299 Ultra-QuickSort(树状数组求逆序数+离散化)

题目链接:http://poj.org/problem?id=2299 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

POJ2299 Ultra-QuickSort(树状数组求逆序数+离散化)

原文:http://blog.csdn.net/alongela/article/details/8142965 给定n个数,要求这些数构成的逆序对的个数.除了用归并排序来求逆序对个数,还可以使用树状数组来求解. 树状数组求解的思路:开一个能大小为这些数的最大值的树状数组,并全部置0.从头到尾读入这些数,每读入一个数就更新树状数组,查看它前面比它小的 已出现过的有多少个数sum,然后用当前位置减去该sum,就可以得到当前数导致的逆序对数了.把所有的加起来就是总的逆序对数. 题目中的数都是独一无二

HDU 1394 Minimum Inversion Number (树状数组求逆序数)

Minimum Inversion Number Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 13942    Accepted Submission(s): 8514 Problem Description The inversion number of a given number sequence a1, a2, ..., a

树状数组求逆序数

poj 2299 树状数组求逆序数题目链接:http://poj.org/problem?id=2299 1 #include <stdio.h> 2 #include <string.h> 3 #include <iostream> 4 #include <algorithm> 5 #include <vector> 6 #include <queue> 7 #include <stack> 8 #include <

hdu 5147 Sequence II (树状数组 求逆序数)

题目链接 Sequence II Time Limit: 5000/2500 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 331    Accepted Submission(s): 151 Problem Description Long long ago, there is a sequence A with length n. All numbers in this se

hdu 1394 Minimum Inversion Number (裸树状数组 求逆序数)

题目链接 题意: 给一个n个数的序列a1, a2, ..., an ,这些数的范围是0-n-1, 可以把前面m个数移动到后面去,形成新序列:a1, a2, ..., an-1, an (where m = 0 - the initial seqence)a2, a3, ..., an, a1 (where m = 1)a3, a4, ..., an, a1, a2 (where m = 2)...an, a1, a2, ..., an-1 (where m = n-1)求这些序列中,逆序数最少的

poj2299 Ultra-QuickSort 树状数组求逆序数

poj2299 Ultra-QuickSort   树状数组求逆序数 Ultra-QuickSort Time Limit: 7000MS   Memory Limit: 65536K Total Submissions: 49587   Accepted: 18153 Description In this problem, you have to analyze a particular sorting algorithm. The algorithm processes a sequenc

Codeforces Round #261 (Div. 2) D. Pashmak and Parmida&#39;s problem (树状数组求逆序数 变形)

题目链接 题意: 给出一些数a[n],求(i, j), i<j 的数量,使得:f(1, i, a[i]) > f(j, n, a[j]) . f(lhs, rhs, x) 指在 { [lhs, rhs]范围中,a[k]的值=x } 的数量. 1.  f(1, i, a[i]) 就是指a[i]前面包括a[i]的数中,有几个值=a[i]. 2.  f(j, n, a[j]) 就是指a[j]后面包括a[j]的数中有几个值=a[j]. 虽然a[x]范围不小,但是n的范围是1000,不是很大,所以我们可