计算逆序对问题 BZOJ 1266
目录
前言
也许有许多大佬看到这个标题,就会心生嘲笑,毕竟只是一个小小的逆序对嘛。
当然,这只是逆序对而已。
我只是准备抛砖引玉,介绍一下本蒟蒻的一点点对树状数组的理解而已。
如有不适,可以自行跳过
正文
题目描述
设A[1..n]是一个包含N个数的数组。如果在i< j的情况下,有A[i] >a[j],则(i,j)就称为A中的一个逆序对。 例如,数组(3,1,4,5,2)的“逆序对”有 <3,1>,<3,2>,<4,2>,<<5,2> 共4个。
输入
第1行:1个整数N表示排序元素的个数。(1≤N≤100000) 第2行:N个用空格分开的整数,每个数小于100000。
输出
1行:仅一个数,即序列中包含的逆序对的个数
样例输入
3
1 3 2
样例输出
1
普通做法
相信各位大神们对逆序对一定不陌生,所以可以直接跳过,当然,如果是跟我一样的同道中人新手们,可以详见:https://baike.baidu.com/item/%E9%80%86%E5%BA%8F%E5%AF%B9/11035554。
可以看出,这道题是可以用暴力双层循环求解的。
#include <cstdio>
int a[20], n, i, j, ans;
int main (){
scanf ("%d", &n);
for (i = 1; i <= n; i++)
scanf ("%d", &a[i]);
for (i = 2; i <= n; i++){
for (j = 1; j < i; j++){
if (a[j] > a[i])
ans ++;
}
}
printf ("%d\n", ans);
return 0;
}
可是可以清楚地看出,这个程序的时间复杂度为O(n^2)的,这未免太大了一点吧。
因此,这里将引入新的知识点——归并排序。
归并排序
在这里,如果运用了归并排序的思想,那么时间复杂度将会变成O(nlogn),这下时间就蹭蹭蹭的往下掉了。
详见代码:
#include<cstdio>
#define MAXN 100000
using namespace std;
int n, a[MAXN + 5], b[MAXN + 5];
long long inver;
void merge_array (int l, int r, int mid){
int x = l, y = l, z = mid + 1;
while (x <= mid && z <= r){//排序,同时在计算逆序对
if (a[x] <= a[z]){
b[y++] = a[x++];
}
else{
inver += mid - x + 1;
b[y++] = a[z++];
}
}
while (x <= mid)//如果说第一个序列还有元素,就直接插入进去
b[y++] = a[x++];
while (z <= r)//同上,即为第二个序列
b[y++] = a[z++];
for (int i = l; i <= r; ++i)//将有序的序列再赋值回去
a[i] = b[i];
}
void mergesort (int l, int r){//归并排序,将数组二分成单个元素,再进行排序
if (l >= r)
return ;
int mid = (l + r) / 2;
mergesort (l, mid);
mergesort (mid + 1, r);
merge_array (l, r, mid);
}
template <typename T>//读入优化不解释
void read (T &x){
x = 0;
char c = getchar ();
while (c < '0' || c > '9')
c = getchar ();
while (c >= '0' && c <= '9'){
x = (x << 1) + (x << 3) + c - 48;
c = getchar ();
}
}
int main (){
read (n);
for (int i = 1; i <= n; ++i)
read (a[i]);
mergesort (1, n);
printf ("%lld", inver);
}
在这里的read函数很简单,其实就跟scanf作用一样,唯一的好处就是可以提高读入的速度,相当于骗分神器。
当然,重点还是mergesort和merge_array了。
mergesort其实就是将一个统一的数组一分为二,最后分成一个,然后再来进行合并。merge_array就是合并的sao操作,如果说左边的序列小于右边的序列,就可以直接把这个元素放到临时数组中。否则即相当于产生出了逆序对。
因为如果这个数与另一个数成为了逆序对,那么他就将会跟后面的所有数都能成为逆序对(前提是有序的)。
例如:
3 2
这里可以很清楚的看出将会产生一组逆序对。
我们一起来走一遍:
1、
l = 1, r = 2,mid = 1,分成的序列是3和2。
x = 1,z = 2,a[x]大于了a[z],那么inver将会等于mid - x + 1,即为1。
然后临时数组将会把a[z]装进去。
2、
l = 1, r = 3,不满足循环条件,退出。
把a[x]放进去。
3、
把临时数组赋值回a数组中。
在这里,归并算法思想的逆序对就做完了,但是,今天我的主题并不是这个,而是——树状数组!
树状数组
逆序对同样也可以用树状数组求解。终于扯到正文了,不知道有没有谁是直接跳到这里的呢
不过如果要用树状数组的话,那么就需要用到离散化了。
离散化是程序设计中的一个常用的技巧,它能够有效地降低时间复杂度。
如果有些数据特别大,无法作为数组的下标保存对应的属性,可只需要这些数据的相对属性的话,那么就可以直接进行离散化了。
例如:
在这里只需要保存排序后的数组下标(即是第几小的)。
离散化常见的有两种方式:1、数组离散化 2、STL+二分离散化
数组离散化
可以将需要离散化的数组映射成更小的值(支持为下标),以下使用的是对应的顺序(rank)值。
#include <cstdio>
#include <algorithm>
using namespace std;
struct node{
int value, id;
bool operator < (const node &k)const {
return value < k.value;
}
}a[20];
int b[20], N;
int main (){
scanf ("%d", &N);
for (int i = 1; i <= N; i++){
scanf ("%d", &a[i].value);
a[i].id = i;
}
sort (a + 1, a + 1 + N);
for (int i = 1; i <= N; i++){
b[a[i].id] = i;
}
for (int i = 1; i <= N; i++){
printf ("%d\n", b[i]);
}
}
输入:
5
1000 65 32 1200 78
输出:
4
2
1
5
3
STL+二分离散化
#include <cstdio>
#include <algorithm>//sort,unique,lower_bound都需要这个函数
using namespace std;
int N, a[20], b[20], cnt;
int main (){
scanf ("%d", &N);
for (int i = 1; i <= N; i++){
scanf ("%d", &a[i]);
b[i] = a[i];
}
sort (a + 1, a + 1 + N);
cnt = unique (a + 1, a + 1 + N) - a - 1;//unique的作用就是排序并去重,返回的是无重复数组的最后一个位置的地址加一
for (int i = 1; i <= N; i++){
b[i] = lower_bound (a + 1, a + 1 + N, b[i]) - a;//lower_bound是在a数组中找第一个大于等于b[i]的地址
}
for (int i = 1; i <= N; i++){
printf ("%d\n", b[i]);
}
}
如果有不了解unique和lower_bound的朋友可以点这里:https://www.cnblogs.com/wangkundentisy/p/9033782.html
https://blog.csdn.net/qq_41603898/article/details/81603327,这里就不再赘述。
树状数组求逆序对
有了离散化,就可以来考虑逆序对了。
其实逆序对实际上就是统计当前元素前有几个比他大的元素个数,累加就OK了。
演示:
注意:这里的sum函数就是计算前缀和,而这个前缀和是把自己也算在里头了的。
参考代码:
#include <cstdio>
#include <algorithm>
#define MAXN 100000
#define lowbit(a) a & -a
using namespace std;
struct node{
int val, id;
bool operator < (const node &k)const {
return val < k.val;
}
}s[MAXN + 5];
int n, b[MAXN + 5], c[MAXN + 5];
int a[MAXN + 5], num[MAXN + 5];
long long inver;
template <typename T>
void read (T &x){
x = 0;
char c = getchar ();
while (c < '0' || c > '9')
c = getchar ();
while (c >= '0' && c <= '9'){
x = (x << 1) + (x << 3) + c - 48;
c = getchar ();
}
}
void upDate (int k){//相当于更改k的值,同时更改k后,他的祖先也会改变,所以一直追溯到祖先都要改变
for (int i = k; i <= n; i += lowbit(i)){
c[i] += 1;
}
}
long long Sum (int k){//计算前缀和
long long tot = 0;
for (int i = k; i >= 1; i -= lowbit (i)){
tot +=c[i];
}
return tot;
}
int main (){
read (n);
//这里有两种去重方法,一种是STL,另一种是数组去重
/*for (int i = 1; i <= n; ++i){
read (s[i].val);
s[i].id = i;
}
sort (s + 1, s + 1 + n);
int cnt = 0;
for (int i = 1; i <= n; ++i){
if (s[i].val != s[i - 1].val)
cnt ++;
b[s[i].id] = cnt;
}*/
for (int i = 1; i <= n; ++i){
read (a[i]);
num[i] = a[i];
}
sort (num + 1, num + 1 + n);
int cnt = unique (num + 1, num + 1 + n) - num - 1;
for (int i = 1; i <= n; ++i){
a[i] = lower_bound (num + 1, num + 1 + cnt, a[i]) - num;
}
for (int i = 1; i <= n; ++i){
upDate (a[i]);
inver += i - Sum (a[i]);
}
printf ("%lld",inver);
}