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

计算逆序对问题    BZOJ    1266


目录

前言

正文

普通做法

归并排序

树状数组

数组离散化

STL+二分离散化

树状数组求逆序对


前言

也许有许多大佬看到这个标题,就会心生嘲笑,毕竟只是一个小小的逆序对嘛。

当然,这只是逆序对而已。

我只是准备抛砖引玉,介绍一下本蒟蒻的一点点对树状数组的理解而已。

如有不适,可以自行跳过

正文

题目描述

设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.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);
}
 
&lt;think&gt;好的,我现在需要帮助用户了解如何使用树状数组进行排列相关的操作。首先,我得回顾一下树状数组的基本概念和功能。树状数组主要用于高效处理动态前缀和查询和单点更新,时间复杂度都是O(log n)。用户提到的排列问题,可能涉及到逆序对的计算,这在树状数组的应用中比较常见。 根据用户提供的引用资料,特别是引用[2]和[4],里面提到了树状数组处理逆序对的方法,以及可能需要离散化数据。逆序对是排列中的一个重要概念,例如在排序算法中评估数组的有序程度。因此,用户可能想知道如何利用树状数组来高效计算排列中的逆序对数量。 接下来,我需要整理实现步骤。首先,通常处理逆序对需要将原始数组进行离散化,尤其是当元素值范围较大时,这样可以减少内存占用并提高效率。离散化步骤包括排序、去重,然后为每个元素分配一个排名。 然后,逆序对的计算通常是从后往前遍历数组,对于每个元素,查询树状数组中比当前元素小的元素数量,这即为当前元素右侧比它小的元素数目,累加起来就是总的逆序对数目。这里需要将每个元素插入到树状数组中,并更新相应的位置。 还需要考虑树状数组的更新和查询操作。每次处理一个元素时,先查询当前树状数组中已经存在的比它小的元素的数量,这通过sum(x-1)实现,然后将当前元素的位置更新到树状数组中,执行update(x, 1)。 用户提供的示例代码中,可能涉及到这些步骤。例如,引用[4]中的离散化和完整代码部分,应该展示了如何处理这些步骤。需要确保代码示例正确,并且符合树状数组的基本操作。 此外,用户可能对树状数组的其他排列相关操作感兴趣,比如动态维护排列中的某些特性,或者处理更复杂的查询。但根据引用内容,主要应用在逆序对的计算上,所以应该围绕这个核心展开。 需要验证示例代码的正确性,确保离散化处理正确,树状数组的更新和查询函数正确实现。例如,在离散化过程中,原数组可能包含重复元素,此时需要去重,并为每个元素分配正确的排名。在Python中,可以使用字典来存储每个元素对应的排名。 最后,生成相关问题时要围绕树状数组的应用,可能涉及逆序对的变种问题、离散化的必要性,以及与其他数据结构的对比,比如线段树。这样可以帮助用户进一步深入理解树状数组在排列问题中的应用。&lt;/think&gt;### 树状数组实现排列相关操作详解 树状数组(Fenwick Tree)在排列问题中主要用于高效计算**逆序对**,并能处理动态更新的数据。核心思路是通过离散化将排列元素映射到紧凑区间,再通过树状数组的快速查询和更新特性统计逆序对数量。 --- #### **一、逆序对计算步骤** 1. **离散化处理** 将原始数组元素映射到$[1, n]$的连续整数区间,减少内存占用并保持大小关系: ```python def discretize(arr): sorted_arr = sorted(arr) unique = sorted(set(sorted_arr)) rank = {v: i+1 for i, v in enumerate(unique)} # 从1开始编号 return [rank[x] for x in arr] ``` 2. **树状数组操作** 从右向左遍历离散化后的数组,利用树状数组统计右侧比当前元素小的元素数量: ```python class FenwickTree: def __init__(self, size): self.n = size self.tree = [0] * (self.n + 1) def update(self, idx, delta): while idx &lt;= self.n: self.tree[idx] += delta idx += idx &amp; -idx def query(self, idx): res = 0 while idx &gt; 0: res += self.tree[idx] idx -= idx &amp; -idx return res def count_inversions(arr): discretized = discretize(arr) max_rank = max(discretized) ft = FenwickTree(max_rank) inversions = 0 for x in reversed(discretized): inversions += ft.query(x - 1) # 统计右侧比x小的元素数量 ft.update(x, 1) # 将当前元素加入树状数组 return inversions ``` --- #### **二、核心原理** - **离散化**:将任意数值范围压缩到连续区间,避免树状数组空间浪费[^4] - **逆序对统计**:通过从右向左遍历,每次查询已插入元素中比当前元素小的数量,累计得到总逆序对数。时间复杂度$O(n \log n)$ - **树状数组优势**:相比线段树,树状数组代码更简洁,常数更小[^1] --- #### **三、应用场景** 1. 动态维护排列中的逆序对数量(如元素实时更新) 2. 求排列的奇偶性(逆序对数量模2) 3. 扩展问题:二维偏序问题、区间统计问题[^3] ---
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值