找到数组中 (i,j) 对的总数，使得 i<j 和 a[i]>a[j]

Posted 2023-03-05

【中文标题】找到数组中 (i,j) 对的总数，使得 i<j 和 a[i]>a[j]

【英文标题】：find total number of (i,j) pairs in array such that i<j and a[i]>a[j]

【发布时间】：2012-10-20 22:34:07

【问题描述】：

如问题中所述，需要在数组中找到 (i,j) 对的总数，使得

(1) **i<j** 
(2) **a[i]>a[j]**

其中 i 和 j 是数组的索引。没有空间限制。

我的问题是

 1) Is there any approach which takes less than O(N^2) time?
 2) if so what is least complexity ?
 3) How do we prove that ? 

我希望我对这个问题很清楚。

我的做法如下

解决问题的一种方法是使用蛮力，这需要 O(N^2) 时间。

但我认为这个问题应该有一个更好的优化解决方案至少O(NlogN) solution。我直觉的原因如下

直觉 1) For sorting an array in ascending order conditions we have are : for i<j , a[i]<a[j] which is similar to my question . I also read that sorting has lower bound of Omega(n log n) . So my question should also have Omega(n log n) . I may be completely wrong if so please correct me .

我的第二个直觉是：

假设我们有一个元素数组如下：4,9,7,3,2,1,8,12

我们为元素 4 计算上述条件i<j , a[i]>a[j] ，因为 i=0 指向 4 ，所以 j 的可能值是 3,4,5 .因为 a[0]>a[3],a[0]> a[4],a[0]>a[5] ，所以我现在 (i,j) 对的总数是 3 。 下次当我将 i(index) 增加到 1 时， j 的可能值为 2,3,4,5,6 。但是我们应该使用这样一个事实，即当 i=0 时（当 a[i]=4 时）我们计算出比 a[i=0] 少 3 个元素，而 a[i=0] 又小于 a[i=1] ，所以 i 不会将 9 与 3,2,1 进行比较（以消除不必要的计算）。如果我们可以消除不必要的计算，那么我们可以将复杂性降低到小于 O(N^2) 的值，否则不存在小于 O(N^2) 的解。但是，如果存在解决方案，那么我们该怎么做。我尝试制作图表，但我的努力是徒劳的。

方法一）In-order to obtain O(nlogn) complexity I think we need to tweak around quick sort or merge sort to get solution but problem here is, if we sort the array we loose the actual positions of elements.

接近2)In-order to get solution in O(NlogN) time I think using tree we may get the optimised sollution . I didn't get any clue.

方法3)If there exists any O(N) time algorithm it should be with hashing . But in this case simple hashing doest work .

所以请让我知道上述哪些直觉或方法是正确的（如果正确，哪种方法将导致优化的解决方案以及如何实现）。

【问题讨论】：

您的意思是“小于 O(N^2)”吗？我问是因为从技术上讲，O(N*2) 与 O(N) 是一回事，不清楚你所说的“O(N2)”是什么意思。

您是要找出这些对的正确计数还是枚举它们？

一些额外（更复杂）的算法：在值 a[i] 上使用 fenwick 树（需要一些 O(NlogN) 预处理）。将每个 (i, a[i]) 解释为 2D 点并使用正交范围最小查询算法。

@A.Webb: 只是想数数..

@Nabb：一个好的参考会很有帮助.....

【参考方案1】：

您可以使用该算法计算反向对，类似于归并排序，如 here 所述。

这个想法是对数组进行合并排序，同时计算每一步改变了多少反转。

---

另一种方法是使用顺序统计树。您将数组的元素顺序插入到这棵树中，每次插入后，看看插入元素之前有多少元素比它大。

订单统计树的替代品是Indexable skiplist。

---

两种算法都有 O(N log N) 的时间复杂度。

要获得近似的反演次数，O(N) 时间复杂度是可能的，但有一些限制。我们可以像修改合并排序一样修改Bucket sort。

在桶排序的“分散”阶段，我们应该估计桶中较大元素的元素数量，同时在某个桶的末尾插入元素（每个桶中的元素保持原始顺序）。

在桶排序的“排序”阶段，我们应该（以同样的方式）修改排序算法（最有可能是插入排序）。在将元素插入到合适的位置时，我们应该计算它跳过了多少其他元素。

至于限制，这个算法只适用于数字（或对象，容易转换为数字），我们应该提前知道这些数字是如何分布的。所以，如果我们有一个均匀分布的整数数组，这个算法应该可以正常工作。

【讨论】：

订单统计树听起来是个好主意。是不是像这样：二叉搜索树，每个节点都跟踪其右子树中包含更大元素的子节点的数量。当我们向下遍历树时，插入将更新这个计数，并且还会计算当我们向下遍历树时可以从这些计数中找到的反转数。这大致正确吗？

@Paresh：没错。除了每个节点都跟踪子树中的节点数，以它为根。

@EvgenyKluev：很好的解决方案。我想因为计算一个正确的哈希（双倍或更多）函数的问题应该在 O(N) 中工作，因为没有空间要求。

@Imposter：我认为散列在这里没有帮助。现在我正在考虑其他 O(N) 解决方案。

我在一次采访中被问到这个问题，我彻底崩溃了。感谢您的资源。

【参考方案2】：

这样的对被称为数组中的反转数。它是衡量数组与排序的接近程度的一种方法。您可以修改归并排序以有效地计算 O(nlogn) 时间内的反转次数。详情请参考this。

【讨论】：

提供的链接给出了 403 禁止，所以 web-archive https://web.archive.org/web/20170222074703/http://www.cs.umd.edu/class/fall2009/cmsc451/lectures/Lec08-inversions.pdf