逆序对——浅谈一维树状数组 & 离散化

最新推荐文章于 2025-05-26 13:16:32 发布

PI_RE

最新推荐文章于 2025-05-26 13:16:32 发布

阅读量922

点赞数 5

CC 4.0 BY-SA版权

分类专栏：数据结构

本文链接：https://blog.youkuaiyun.com/weixin_43925239/article/details/84787027

数据结构专栏收录该内容

3 篇文章

订阅专栏

计算逆序对问题 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

样例输出

普通做法

相信各位大神们对逆序对一定不陌生，所以可以直接跳过，当然，如果是跟我一样的~~同道中人~~新手们，可以详见：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

输出：

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.youkuaiyun.com/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);
}