算法多解——JZ51 数组中的逆序对（归并排序进阶树状数组）

题面

[中等]  通过率：16.79%  时间限制：3秒  空间限制：64M

---

解法1（朴素做法）

思路

• 看到这条题目，最简单的想法就是暴力：
• 二重循环扫描数组，如果出现前面比后面大的，就计数+1
• 但是看到50%的数据，size<=1e4，二重循环1e8还可以，再大一点显然不行了
• 因此纯暴力拿不到全分（看测试点怎么给了）

复杂度分析

• 时间复杂度：O(nlogn)到O(n^2)，每次循环后内循环的长度都减一
• 空间复杂度：O(1)

代码

class Solution {
public:
    int InversePairs(vector<int> data) {
        int len = data.size();
        if(!data.size()){
            return 0;
        }
        long long int ans = 0;
        for(int i=0; i<len; i++){
            for(int j=i+1; j<len; j++){
                if(data[i]>data[j]) ans++;
            }
        }
        return ans%1000000007;
    }
};

---

解法2（归并排序优化）

思路

看到要求时间复杂度为O(nlogn)时，正确的想法应该想到快速排序、归并排序、堆排序。本题更适合用归并排序来解。

归并排序过程中，会将数组划分成最小2个元素的子数组，然后依次比较子数组的长度，这里可以用相同的方法统计逆序对。主要有三个阶段：

1. 划分阶段：将待划分区间从中点划分成两部分；
2. 排序阶段：使用归并排序递归地处理子序列，同时统计逆序对；
3. 合并阶段：将排好序的子序列合并。

归并排序中，右边大于左边时，它大于了左边的所有子序列。基于这个性质我们可以不用每次加1来统计，减少运算次数。

图解

复杂度分析

• 时间复杂度：O(nlogn)，归并排序利用分治思想，复杂度为此
• 空间复杂度：O(n)，辅助数组temp长度为n及递归栈最大深度不会超过n

代码

class Solution {
public:
    int mod = 1000000007;
    int mergeSort(int left, int right, vector<int>& data, vector<int>& temp){
        if(left>=right)    // 停止划分
            return 0;
        int mid = (left+right)/2; //取中间
        int res = mergeSort(left, mid, data, temp) + mergeSort(mid+1, right, data, temp); //左右划分
        res %= mod;  //防止溢出
        int i=left, j = mid+1;
        for(int k=left; k<=right; k++)
            temp[k] = data[k];
        for(int k=left; k<=right; k++){
            if(i==mid+1)
                data[k] = temp[j++];
            else if(j==right+1 || temp[i]<=temp[j])
                data[k] = temp[i++];
            else{ //左边比右边大，答案增加
                data[k] = temp[j++];
                res += mid-i+1; // 统计逆序对
            }
        }
        return res % mod;
    }
    int InversePairs(vector<int> data) {
        int n = data.size();
        vector<int> res(n);
        return mergeSort(0, n-1, data, res);
    }
};

---

解法3（树状数组优化）

思路

树状数组是如图所示的数组，可以累加前缀和

有关一维和二维前缀和&差分的总结 ——> 转下

前缀和&差分硬核图文总结——经典4大例题附图讲解_夏旭的博客-CSDN博客1.一维前缀和：典型模板题：前缀和题目：输入一个长度为n的整数序列。接下来再输入m个询问，每个询问输入一对l, r。对于每个询问，输出原序列中从第l个数到第r个数的和。输入格式第一行包含两个整数n和m。第二行包含n个整数，表示整数数列。接下来m行，每行包含两个整数l和r，表示一个询问的区间范围。输出格式共m行，每行输出一个询问的结果。数据范围1≤l≤r≤n1≤l≤r≤n,1≤n,m≤1000001≤n,m≤100000,−1000≤数列中元素的值≤1000−1000≤数列中元素的值≤https://blog.csdn.net/Luoxiaobaia/article/details/105903362

• 比如4统计123的前缀和，8统计1234567的前缀，而且因为是树状的，因此操作都是O(logn)。
• 我们首先对原数组进行离散化操作，经过排序后的操作加上后续二分查找映射，将 数组[1 5000 2 400 30] 映射为 ——> [1 5 2 4 3]，即使他们相连，减少空间需求，因为题目所给没有重复元素，因此也不用去重，还是n个数字。
• 然后从前往后遍历每个元素，查找在树状数组中的前缀和，表示这个元素在树状数组中出现过多少，前缀和做差，query(n)−query(data[i])，表示值在 [data[i]+1,m] 中出现的次数，也就是逆序数个数。

复杂度分析

• 时间复杂度：O(nlogn)，sort函数排序为O(nlogn)；离散化过程中二分法时间复杂度为O(logn)，一共n次；统计逆序对过程中，查询更新都是O(logn)，一共n次
• 空间复杂度：O(n)，辅助数组temp的长度和树状数组的长度都是n

代码

class BIT {
private:
    vector<int> tree;
    int n;
    
public:
    BIT(int m) : n(m), tree(m + 1) {} //初始化

    int lowbit(int x){ //位操作，使数组呈现2、4、8、16这种树状
        return x & (-x);
    }

    int query(int x){ //查询序列1到x的前缀和
        int res = 0;
        while(x){
            res += tree[x];
            x -= lowbit(x);
        }
        return res;
    }
    
    void update(int x){ //序列x位置的数加1
        while(x <= n){
            tree[x]++;
            x += lowbit(x);
        }
    }
};

class Solution {
public:
    int mod = 1000000007;
    int InversePairs(vector<int> data) {
        int n = data.size();
        int res = 0;
        vector<int> temp = data;

        //离散化
        sort(temp.begin(), temp.end()); //排序
        for(int i = 0; i < n; i++) //二分法重新映射
            data[i] = lower_bound(temp.begin(), temp.end(), data[i]) - temp.begin() + 1;
        BIT bit(n); //建立树状数组
        for(int i = 0; i < n; i++){ //统计逆序对
            res = (res + bit.query(n) - bit.query(data[i])) % mod;
            bit.update(data[i]);
        }
        return res;
    }
};

参考致谢：孤帆远影碧空尽_牛客博客