数组中唯一对(i，j)的计数

本文详细介绍如何在一个给定的数组中，找出能够满足 A[i] + A[j] = A[k] + A[l] 的唯一对（i，j）。

问题描述

给定一个整数数组 A，它的长度为 n。请你找出一个唯一的对 (i, j )，满足以下两个条件：

1. 0 ≤ i < j < n
2. A[i] + A[j] = A[k] + A[l]，其中 0 ≤ k < l < n，且 (i, j) ≠ (k, l)

解决方案

预处理逆序对

为了方便解决这个问题，我们首先需要预处理数组中的逆序对。

逆序对指数组中有多少对 (i, j) 满足 i < j 且 A[i] > A[j]。例如，在数组 A = [4, 3, 1, 2] 中，(4, 3) 和 (4, 2) 是逆序对。

我们可以使用归并排序，在归并过程中统计逆序对的数量。具体来说，对于一个左右两个已排序的子数组 A[lo...mid] 和 A[mid + 1...hi]，我们可以在进行归并的过程中统计逆序对的数量。假设左子数组中当前处理的元素为 A[i]，右子数组中当前处理的元素为 A[j]，并且左子数组的所有元素都已经处理完毕，那么：

1. 如果 A[i] <= A[j]，则没有逆序对产生，直接归并即可。
2. 如果 A[i] > A[j]，则右子数组中当前元素和左子数组中所有剩余的元素都形成了逆序对。

通过这种方式，我们可以在 O(n log n) 的时间复杂度内预处理数组中的逆序对。

枚举所有可能的 (i, j) 组合

在计算逆序对的同时，我们还可以维护一个 Map，用于存储所有元素的出现次数。

接下来，我们可以使用两层循环枚举所有不同的 (i, j) 组合，并计算 A[i] + A[j] 的值是否在 Map 中出现过。此外，我们还需要确保 (i, j) 不等于 (k, l)，其中 (k, l) 是我们之前找到的一个满足条件的数对。

def find_unique_pair(A):
    # 计算逆序对
    inversions = 0
    def merge_sort(lo, hi):
        nonlocal inversions
        if lo >= hi:
            return
        mid = (lo + hi) // 2
        merge_sort(lo, mid)
        merge_sort(mid + 1, hi)
        tmp = []
        i, j = lo, mid + 1
        while i <= mid and j <= hi:
            if A[i] <= A[j]:
                tmp.append(A[i])
                i += 1
            else:
                tmp.append(A[j])
                j += 1
                inversions += mid - i + 1
        while i <= mid:
            tmp.append(A[i])
            i += 1
        while j <= hi:
            tmp.append(A[j])
            j += 1
        A[lo:hi + 1] = tmp

    merge_sort(0, len(A) - 1)

    # 统计元素出现次数
    freq = {}
    for x in A:
        freq[x] = freq.get(x, 0) + 1

    # 查找 A[i] + A[j] 是否在 Map 中出现过
    res = 0
    used_pairs = set()
    for i in range(len(A)):
        for j in range(i + 1, len(A)):
            if (i, j) in used_pairs:
                continue
            k = freq.get(A[i] + A[j], 0)
            if k > 0:
                l = freq.get(A[i] + A[j], 0)
                if (i, j) != (k, l):
                    res += 1
                    used_pairs.add((i, j))
                    used_pairs.add((k, l))
                
    return res

结论

通过预处理逆序对和枚举所有组合的方式，我们可以在 O(n log n) 的时间复杂度内找到唯一的一组数对，使得它们的逆之和相等。