AcWing算法基础课-788逆序对的数量-Java题解

news2024/9/20 19:03:55

heweilai-bolg-title-image-of-the-article

大家好，我是何未来，本篇文章给大家讲解《AcWing算法基础课》788 题——逆序对的数量。本文详细讲解了如何通过归并排序算法高效计算数组中的逆序对数量。通过递归分治和归并过程，我们不仅实现了数组的排序，还在排序过程中巧妙地计算了逆序对的数量。文章还提供了 Java 代码实现，帮助大家更好地理解和应用这一算法。

文章目录

❓题目描述
💡算法思路
✅Java代码
🔗参考

❓题目描述

给定一个长度为 n 的整数数列，请你计算数列中的逆序对的数量。

逆序对的定义如下：对于数列的第 i 个和第 j 个元素，如果满足 i < j 且 a[i] > a[j]，则其为一个逆序对；否则不是。

输入格式

第一行包含整数 n，表示数列的长度。

第二行包含 n 个整数，表示整个数列。

输出格式

输出一个整数，表示逆序对的个数。

数据范围

1 ≤ n ≤ 100000，
数列中的元素的取值范围 [1,10⁹]。

输入样例：

6
2 3 4 5 6 1

输出样例：

💡算法思路

对数组进行归并排序
归并排序过程中计算逆序对的数量

具体实现步骤：

递归分治：将数组分成两部分，分别对左半部分和右半部分进行递归排序。
归并过程：
- 使用两个指针 i 和 j 分别指向左半部分和右半部分的当前元素。
- 比较 nums[i] 和 nums[j]，将较小的元素放入临时数组 tmp 中。
- 如果 nums[i] 大于 nums[j]，计算逆序对的数量并累加到 ans 中。
- 将剩余的元素依次放入 tmp 数组中。
- 将 tmp 数组中的元素复制回原数组 nums。

看到这里可能你会产生疑问，为什么 nums[i] 大于 nums[j] 时，使用ans += mid - i + 1;就可以计算出逆序对的数量呢？

这是因为根据归并排序的原理，每次递归会将原数组分为左右两个子数组，先对左子数组进行递归排序，再对右子数组进行递归排序，那么我们可以知道，每一次递归结束，左子数组的所有元素一定是从小到大排列的，也就是右边的元素一定比左边的元素更大。那么我们在合并两个子数组过程中当 nums[i] 大于 nums[j] 时，它们刚好组成了一个逆序对，并且左子数组中 nums[i] 后面的元素都和 nums[j] 形成了逆序对，所以就可以计算出当前递归中有多少个逆序对，把所有次递归的逆序对数量累加起来就得到了整个数组的逆序对数量。

具体判断逻辑如下：

while (i <= mid && j <= r) { // 合并两个有序子数组
    if (a[i] <= a[j]) { // 如果左半部分的元素小于或等于右半部分的元素
        tmp[k++] = a[i++]; // 将左半部分的元素放入临时数组
    } else {
        tmp[k++] = a[j++]; // 否则将右半部分的元素放入临时数组
        // 以下为关键代码：
        // 此时a[i] > a[j]，并且i < j（尚未改变两元素的顺序），说明a[i]和a[j]是一组逆序对
        // 并且左子数组是有序的，所以左子数组中a[i]以及之后的所有元素（数量为mid-i+1）都大于等于a[j]
        // 也即此次递归中，大于a[j]的元素有mid-i+1个，等价于此次递归中逆序对有mid-i+1个
        // 每次递归都进行累加，最后就可以得到所有的逆序对个数。
        ans += mid - i + 1; // 计算逆序对的数量，并累加到ans
    }
}

看到这里大家可以还会提出一个问题，前面的递归中累加过的逆序对后面会不会重复累加，你能想到这个问题，说明你认真思考了，不过没有思考到位，那就是经过此次递归之后，两个原本是逆序对的元素的顺序已经改变了，比如 a[i] 本来是大于a[j] 并且 i < j 的，但是递归结束后，a[i] 就被排序到 a[j] 的后面了，之后的递归中他们就不是逆序对了，所以不会有重复计算的情况，这下理解了吧哈哈。

时间复杂度：O(n log n)
空间复杂度：O(n)

✅Java代码

import java.*;

public class Aw788 {

	// 创建一个 StreamTokenizer 对象，用于读取输入流
	static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

	// 读取下一个整数
	static int nextInt() throws IOException {
		in.nextToken();
		return (int) in.nval;
	}

	// 定义数组的最大长度
	static final int N = 100000 + 10;
	// 输入的数组长度
	static int n;
	// 存储输入的数组
	static int[] nums = new int[N];
	// 临时数组，用于归并排序
	static int[] tmp = new int[N];
	// 记录逆序对的数量
	static long ans = 0;

	public static void main(String[] args) throws IOException {
		// 读取数组长度
		n = nextInt();
		// 读取数组元素
		for (int i = 0; i < n; i++) {
			nums[i] = nextInt();
		}
		// 对数组进行归并排序，并计算逆序对的数量
		mergeSort(nums, 0, n - 1);
		// 输出逆序对的数量
		System.out.println(ans);
	}

	// 归并排序算法
	public static void mergeSort(int[] a, int l, int r) {
		// 如果数组长度为1或0，直接返回
		if (l >= r) {
			return;
		}
		// 计算中间位置
		int mid = l + r >> 1;
		// 递归排序左半部分
		mergeSort(a, l, mid);
		// 递归排序右半部分
		mergeSort(a, mid + 1, r);
		// 归并过程
		int k = 0, i = l, j = mid + 1;
		while (i <= mid && j <= r) {
			if (a[i] <= a[j]) {
				// 如果左边的元素小于等于右边的元素，直接放入临时数组
				tmp[k++] = a[i++];
			} else {
				// 以下为关键代码：
		        // 此时a[i] > a[j]，并且i < j（尚未改变两元素的顺序），说明a[i]和a[j]是一组逆序对
		        // 并且左子数组是有序的，所以左子数组中a[i]以及之后的所有元素（数量为mid-i+1）都大于等于a[j]
		        // 也即此次递归中，大于a[j]的元素有mid-i+1个，等价于此次递归中逆序对有mid-i+1个
		        // 每次递归都进行累加，最后就可以得到所有的逆序对个数。
				tmp[k++] = a[j++];
				ans += mid - i + 1;
			}
		}
		// 将剩余的左半部分元素放入临时数组
		while (i <= mid) {
			tmp[k++] = a[i++];
		}
		// 将剩余的右半部分元素放入临时数组
		while (j <= r) {
			tmp[k++] = a[j++];
		}
		// 将临时数组中的元素复制回原数组
		for (i = l, j = 0; i <= r; i++, j++) {
			nums[i] = tmp[j];
		}
	}

}