排序题目：翻转对

题目

标题和出处

标题：翻转对

出处：493. 翻转对

难度

8 级

题目描述

要求

给定一个整数数组 $\text{nums}$，返回数组中的翻转对的数量。

如果下标对 $\text{(i, j)}$ 满足 $\text{0}\le \text{i}<\text{j}<\text{nums.length}$ 且 $\text{nums[i]}>\text{2}\times \text{nums[j]}$，则称为翻转对。

示例

示例 1：

输入：$\text{nums = [1,3,2,3,1]}$
输出：$\text{2}$

示例 2：

输入：$\text{nums = [2,4,3,5,1]}$
输出：$\text{3}$

数据范围

• $\text{1}\le \text{nums.length}\le \text{5}\times {\text{10}}^{\text{4}}$
• ${\text{-2}}^{\text{31}}\le \text{nums[i]}\le {\text{2}}^{\text{31}}-\text{1}$

解法一

思路和算法

对于长度为 $n$ 的数组，最朴素的计算翻转对的数量的方法的时间复杂度是 $O(n^2)$。由于数组 $\text{nums}$ 的长度最大为 $5\times 10^4$，因此 $O(n^2)$ 的时间复杂度过高，必须使用时间复杂度更低的方法。

由于翻转对和排序相关，因此可以使用排序的思想计算翻转对的数量。归并排序的过程中，每次将两个升序子数组合并，合并的过程中即可发现这两个升序子数组中的翻转对。因此可以在归并排序的过程中完成翻转对数量的计算。

考虑下标范围 $[\text{low},\text{high}]$ 的子数组。当 $\text{low}\ge \text{high}$ 时，子数组的长度是 $0$ 或 $1$，此时子数组中不存在翻转对。当 $\text{low}<\text{high}$ 时，子数组的长度大于等于 $2$，将子数组分成两个更短的子数组，两个更短的子数组排序之后合并，同时计算翻转对。具体做法如下。

1. 取 $\text{low}$ 和 $\text{high}$ 的平均值 $\text{mid}$，将下标范围 $[\text{low},\text{high}]$ 的子数组分成下标范围 $[\text{low},\text{mid}]$ 和下标范围 $[\text{mid}+1,\text{high}]$ 的两个子数组。

2. 对两个子数组分别排序并计算翻转对的数量，得到两个升序的子数组和两个子数组分别包含的翻转对数量。

3. 计算两个升序子数组之间的翻转对数量。为了计算两个升序子数组之间的翻转对数量，需要定义两个指针 $i$ 和 $j$，初始时分别指向两个升序子数组的开始位置，即 $i=\text{low}$，$j=\text{mid}+1$。当 $i\le \text{mid}$ 且 $j\le \text{high}$ 时，根据指针 $i$ 和 $j$ 指向的元素计算翻转对数量。

   • 如果 $\text{nums}[i]>2\times \text{nums}[j]$，则 $(i,j)$ 是翻转对，由于对于任意 $i\le k\le \text{mid}$ 都有 $\text{nums}[i]\le \text{nums}[k]$，因此 $\text{nums}[k]>2\times \text{nums}[j]$，即 $(k,j)$ 是翻转对，因此以 $j$ 作为右侧下标的翻转对数量是 $\text{mid}-i+1$。更新翻转对数量之后，将 $j$ 指向的下标加 $1$。

   • 如果 $\text{nums}[i]\le 2\times \text{nums}[j]$，则 $(i,j)$ 不是翻转对，将 $i$ 指向的下标加 $1$。

4. 计算两个升序子数组之间的翻转对数量之后，合并两个升序子数组。

当整个数组排序结束时即可得到整个数组的翻转对数量。

由于计算两个升序子数组之间的翻转对数量以及合并两个升序子数组都需要遍历两个升序子数组，因此计算翻转对数量并没有提升总时间复杂度，总时间复杂度和原始归并排序一样是 $O(n\log n)$。

归并排序可以使用自顶向下的方式递归实现，也可以使用自底向上的方式迭代实现。对于同一个数组，使用自顶向下和自底向上两种方式实现的中间过程可能有所区别，但是都能得到正确的结果。

代码

以下代码为归并排序的自顶向下实现。

class Solution {
    public int reversePairs(int[] nums) {
        return mergeSortAndCount(nums, 0, nums.length - 1);
    }

    public int mergeSortAndCount(int[] nums, int low, int high) {
        if (low >= high) {
            return 0;
        }
        int mid = low + (high - low) / 2;
        int count = mergeSortAndCount(nums, low, mid) + mergeSortAndCount(nums, mid + 1, high);
        int i = low, j = mid + 1;
        while (i <= mid && j <= high) {
            if ((long) nums[i] > 2 * (long) nums[j]) {
                count += mid - i + 1;
                j++;
            } else {
                i++;
            }
        }
        merge(nums, low, mid, high);
        return count;
    }

    public void merge(int[] nums, int low, int mid, int high) {
        int currLength = high - low + 1;
        int[] temp = new int[currLength];
        int i = low, j = mid + 1, k = 0;
        while (i <= mid && j <= high) {
            if (nums[i] <= nums[j]) {
                temp[k++] = nums[i++];
            } else {
                temp[k++] = nums[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = nums[i++];
        }
        while (j <= high) {
            temp[k++] = nums[j++];
        }
        System.arraycopy(temp, 0, nums, low, currLength);
    }
}

以下代码为归并排序的自底向上实现。

class Solution {
    public int reversePairs(int[] nums) {
        int count = 0;
        int length = nums.length;
        for (int halfLength = 1, currLength = 2; halfLength < length; halfLength *= 2, currLength *= 2) {
            for (int low = 0; low < length - halfLength; low += currLength) {
                int mid = low + halfLength - 1;
                int high = Math.min(low + currLength - 1, length - 1);
                int i = low, j = mid + 1;
                while (i <= mid && j <= high) {
                    if ((long) nums[i] > 2 * (long) nums[j]) {
                        count += mid - i + 1;
                        j++;
                    } else {
                        i++;
                    }
                }
                merge(nums, low, mid, high);
            }
        }
        return count;
    }

    public void merge(int[] nums, int low, int mid, int high) {
        int currLength = high - low + 1;
        int[] temp = new int[currLength];
        int i = low, j = mid + 1, k = 0;
        while (i <= mid && j <= high) {
            if (nums[i] <= nums[j]) {
                temp[k++] = nums[i++];
            } else {
                temp[k++] = nums[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = nums[i++];
        }
        while (j <= high) {
            temp[k++] = nums[j++];
        }
        System.arraycopy(temp, 0, nums, low, currLength);
    }
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。归并排序的时间复杂度是 $O(n\log n)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。自顶向下实现时需要递归调用栈的空间是 $O(\log n)$，自底向上实现时可以省略递归调用栈的空间。无论是自顶向下实现还是自底向上实现，归并过程需要 $O(n)$ 的辅助空间。

解法二

预备知识

该解法涉及到二分查找和线段树。

二分查找的作用是在有序序列中查找目标值，或者在特定范围中查找符合要求的最大值或最小值。

线段树是一种二叉搜索树，将一个区间划分成两个更短的区间。线段树中的每个叶结点都是长度为 $1$ 的区间，称为单元区间。

线段树支持区间的快速查询和修改。对于长度为 $n$ 的区间，使用线段树查询特定子区间的元素个数以及修改特定子区间内的元素个数的时间是 $O(\log n)$。

有时，为了降低线段树的空间复杂度，需要使用离散化。

思路和算法

对于长度为 $n$ 的数组，其中不同元素的个数最多有 $n$ 个。由于计算翻转对数量只需要考虑元素的相对大小，因此可以使用离散化将区间长度限制在 $n$ 以内。离散化的方法是计算数组 $\text{nums}$ 中的每个元素的名次，计算名次的方法是：新建数组 $\text{sorted}$ 并将数组 $\text{nums}$ 中的所有元素复制到数组 $\text{sorted}$ 中，然后对数组 $\text{sorted}$ 排序，排序之后，$\text{sorted}[i]$ 的名次为 $i$，如果 $i>0$ 且 $\text{sorted}[i]=\text{sorted}[i-1]$ 则 $\text{sorted}[i]$ 的名次与 $\text{sorted}[i-1]$ 的名次相同。每个元素的名次都在范围 $[0,n-1]$ 中，表示数组中的小于该元素的元素个数。

创建线段树，用于存储数组 $\text{nums}$ 中的每个元素的名次。从左到右遍历数组 $\text{nums}$，对于每个元素 $\text{num}$，其左边的元素已经遍历过，其左边的元素中的每个大于 $2\times \text{num}$ 的元素都与 $\text{num}$ 组成一个翻转对，因此得到 $\text{num}$ 的名次 $\text{rank}$，并使用二分查找得到大于等于 $2\times \text{num}+1$ 的元素的最小名次 $\text{minRank}$，计算线段树的子区间 $[\text{minRank},n-1]$ 中的元素个数，该元素个数即为已经遍历过的元素中的大于 $2\times \text{num}$ 的元素个数，将翻转对数量增加该元素个数。更新翻转对数量之后，将 $\text{rank}$ 添加到线段树中，继续遍历后面的元素并更新翻转对数量。遍历结束之后，即可得到数组 $\text{nums}$ 中的翻转对数量。

代码

class Solution {
    public int reversePairs(int[] nums) {
        int count = 0;
        Map<Integer, Integer> ranks = getRanks(nums);
        int length = nums.length;
        int[] sorted = new int[length];
        for (int i = 0; i < length; i++) {
            sorted[i] = nums[i];
        }
        Arrays.sort(sorted);
        SegmentTree st = new SegmentTree(length);
        for (int i = 0; i < length; i++) {
            int rank = ranks.get(nums[i]);
            int minRank = binarySearch(sorted, (long) 2 * nums[i] + 1);
            count += st.getCount(minRank, length - 1);
            st.add(rank);
        }
        return count;
    }

    public Map<Integer, Integer> getRanks(int[] nums) {
        int length = nums.length;
        int[] sorted = new int[length];
        System.arraycopy(nums, 0, sorted, 0, length);
        Arrays.sort(sorted);
        Map<Integer, Integer> ranks = new HashMap<Integer, Integer>();
        for (int i = 0; i < length; i++) {
            int num = sorted[i];
            if (i == 0 || num > sorted[i - 1]) {
                ranks.put(num, i);
            }
        }
        return ranks;
    }

    public int binarySearch(int[] nums, long target) {
        int low = 0, high = nums.length;
        while (low < high) {
            int mid = low + (high - low) / 2;
            if (nums[mid] >= target) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }
        return low;
    }
}

class SegmentTree {
    int length;
    int[] tree;

    public SegmentTree(int length) {
        this.length = length;
        this.tree = new int[length * 4];
    }

    public int getCount(int start, int end) {
        return getCount(start, end, 0, 0, length - 1);
    }

    public void add(int rank) {
        add(rank, 0, 0, length - 1);
    }

    private int getCount(int rangeStart, int rangeEnd, int index, int treeStart, int treeEnd) {
        if (rangeStart > rangeEnd) {
            return 0;
        }
        if (rangeStart == treeStart && rangeEnd == treeEnd) {
            return tree[index];
        }
        int mid = treeStart + (treeEnd - treeStart) / 2;
        if (rangeEnd <= mid) {
            return getCount(rangeStart, rangeEnd, index * 2 + 1, treeStart, mid);
        } else if (rangeStart > mid) {
            return getCount(rangeStart, rangeEnd, index * 2 + 2, mid + 1, treeEnd);
        } else {
            return getCount(rangeStart, mid, index * 2 + 1, treeStart, mid) + getCount(mid + 1, rangeEnd, index * 2 + 2, mid + 1, treeEnd);
        }
    }

    private void add(int rank, int index, int start, int end) {
        if (start == end) {
            tree[index]++;
            return;
        }
        int mid = start + (end - start) / 2;
        if (rank <= mid) {
            add(rank, index * 2 + 1, start, mid);
        } else {
            add(rank, index * 2 + 2, mid + 1, end);
        }
        tree[index] = tree[index * 2 + 1] + tree[index * 2 + 2];
    }
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。每个元素在线段树中的查询和更新操作都需要 $O(\log n)$ 的时间，时间复杂度是 $O(n\log n)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。创建用于排序的数组和线段树需要 $O(n)$ 的空间。

解法三

预备知识

该解法涉及到二分查找和树状数组。

二分查找的作用是在有序序列中查找目标值，或者在特定范围中查找符合要求的最大值或最小值。

树状数组也称二叉索引树，由 Peter M. Fenwick 发明，因此又称 Fenwick 树。树状数组支持快速计算数组的前缀和与区间和，以及快速修改。对于长度为 $n$ 的区间，使用树状数组查询特定子区间的区间和以及修改特定子区间内的元素值的时间是 $O(\log n)$。

有时，为了降低树状数组的空间复杂度，需要使用离散化。

思路和算法

计算翻转对数量也可以使用树状数组实现。

首先使用离散化将区间长度限制在 $n$ 以内，然后创建树状数组，用于存储数组 $\text{nums}$ 中的每个元素的名次。从左到右遍历数组 $\text{nums}$，对于每个元素 $\text{num}$，得到 $\text{num}$ 的名次 $\text{rank}$，并使用二分查找得到大于等于 $2\times \text{num}+1$ 的元素的最小名次 $\text{minRank}$，计算树状数组的子区间 $[\text{minRank},n-1]$ 中的元素个数，该元素个数即为已经遍历过的元素中的大于 $2\times \text{num}$ 的元素个数，将翻转对数量增加该元素个数。更新翻转对数量之后，将 $\text{rank}$ 添加到树状数组中，继续遍历后面的元素并更新翻转对数量。遍历结束之后，即可得到数组 $\text{nums}$ 中的翻转对数量。

代码

class Solution {
    public int reversePairs(int[] nums) {
        int count = 0;
        Map<Integer, Integer> ranks = getRanks(nums);
        int length = nums.length;
        int[] sorted = new int[length];
        for (int i = 0; i < length; i++) {
            sorted[i] = nums[i];
        }
        Arrays.sort(sorted);
        BinaryIndexedTree bit = new BinaryIndexedTree(length);
        for (int i = 0; i < length; i++) {
            int rank = ranks.get(nums[i]);
            int minRank = binarySearch(sorted, (long) 2 * nums[i] + 1);
            count += bit.getCount(minRank, length - 1);
            bit.add(rank);
        }
        return count;
    }

    public Map<Integer, Integer> getRanks(int[] nums) {
        int length = nums.length;
        int[] sorted = new int[length];
        System.arraycopy(nums, 0, sorted, 0, length);
        Arrays.sort(sorted);
        Map<Integer, Integer> ranks = new HashMap<Integer, Integer>();
        for (int i = 0; i < length; i++) {
            int num = sorted[i];
            if (i == 0 || num > sorted[i - 1]) {
                ranks.put(num, i);
            }
        }
        return ranks;
    }

    public int binarySearch(int[] nums, long target) {
        int low = 0, high = nums.length;
        while (low < high) {
            int mid = low + (high - low) / 2;
            if (nums[mid] >= target) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }
        return low;
    }
}

class BinaryIndexedTree {
    int length;
    int[] tree;

    public BinaryIndexedTree(int length) {
        this.length = length;
        this.tree = new int[length + 1];
    }

    public int getCount(int start, int end) {
        return getPrefixSum(end + 1) - getPrefixSum(start);
    }

    public void add(int index) {
        index++;
        while (index <= length) {
            tree[index]++;
            index += lowbit(index);
        }
    }

    private int getPrefixSum(int index) {
        int sum = 0;
        while (index > 0) {
            sum += tree[index];
            index -= lowbit(index);
        }
        return sum;
    }

    private static int lowbit(int x) {
        return x & (-x);
    }
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。每个元素在树状数组中的查询和更新操作都需要 $O(\log n)$ 的时间，时间复杂度是 $O(n\log n)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。创建用于排序的数组和树状数组需要 $O(n)$ 的空间。