题目链接
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.
Description:
交换任意相邻两个数,使得序列变为升序
Solution:
这是一个求解逆序对的问题,首先考虑到利用树状数组来求解。
对于一个给定n个元素的排列 a0, a1, ……an,如果想知道以他为首的逆序对的数目(形如(ai, aj)这样的数对),就是需要计算ai+1, ……, an 这个序列中小于 ai 的元素个数。由于树状数组维护的是前缀和,所以我们可以将 ai 本身作为树状数组的下标,那么每插入一个数,我们只需要对当前 (ai - 1) 计算前缀和,就可以知道 ai 后面有多少个小与 ai 的数了,需要注意的是要从后往前枚举,因为是要寻找 ai 后面有多少个小与 ai 的元素,当枚举到 ai 时,那么我们就可以通过 ans += getSum(ai - 1) 得到前面小于 ai 数目,然后再通过 add(ai, 1) 把 ai 这个数添加到树上。
通常树状数组求逆序数,是将数组元素本身作为树状数组的下标,这就对元素的大小产生了限制,而本题的元素最大可达 999,999,999,所以传统做法明显不可行,这时就需要 离散化 思想了:
题目中的元素都是独一无二的,且最多只有 500000 个,把原始的数映射为 1 ~ n 一共n个数,用一个 f 数组存储离散后的值,f[i] 表示原序列中第 i 个数在将序列排序后所在的位置,之后就可以利用传统做法去求解了。
总的时间复杂度O(nlogn)。
Code:
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#define fi first
#define se second
#define Fio ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define fopen freopen("in.txt", "r", stdin); freopen("out.txt", "w", stdout);
#define _rush() int T; cin >> T; while(T--)
#define rush() int T; scanf("%d", &T); while(T--)
#define mst(a, b) memset(a, b, sizeof(a))
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int INF = 0x3f3f3f3f;
const double eps = 1e-9;
const int Mod = 1e9 + 7;
const int MaxN = 5e5 + 5;
struct node {
int x, id;
} a[MaxN];
int n;
int presum[MaxN], f[MaxN];
bool cmp(node p, node q) { return p.x < q.x; }
int lowbit(int x) { return x & (-x); }
int add(int p) {
for(int i = p; i <= n; i += lowbit(i)) presum[i]++;
}
int get_sum(int p) {
int ans = 0;
for(int i = p; i > 0; i -= lowbit(i)) ans += presum[i];
return ans;
}
int main()
{
Fio;
while(cin >> n) {
if(n == 0) return 0;
mst(presum, 0);
for(int i = 1; i <= n; i++) {
cin >> a[i].x;
a[i].id = i;
}
sort(a + 1, a + 1 + n, cmp);
LL ans = 0LL;
for(int i = 1; i <= n; i++) f[a[i].id] = i; 离散化
for(int i = 1; i <= n; i++) {
add(f[i]);
ans += i - get_sum(f[i]); //get_sum实际求的是正序对的数量,用总数对的数量减去正序对的数量就是逆序对的数量了
}
cout << ans << endl;
}
return 0;
}