从 3 个数组中查找唯一的公共元素

Question

原问题：
我有 3 个盒子，每个盒子里有 200 个硬币，因为只有一个人从三个盒子里打了电话，因此每个盒子里有一枚硬币，指纹相同，其余硬币指纹不同。您必须从所有 3 个盒子中找到包含相同指纹的硬币。这样我们就可以从三个盒子中找到打电话的人的指纹。

转换后的问题：
您有 3 个数组，每个数组包含 200 个整数。假设这 3 个数组中只有一个公共元素。找到共同的元素。
请考虑解决这个问题，而不是简单的 O(1) 空间和 O(n^3) 时间。

Answer 1

Pelkonen 的回答有所改进：
来自 OP 中的转换问题：

“鉴于这 3 个数组中只有一个公共元素。”

我们只需要对 2 个数组进行排序并找到共同的元素。

Answer 2

如果你首先对所有数组进行排序 O(n log n)，那么在不到 O(n^3) 的时间内就很容易找到公共元素。例如，您可以在对它们进行排序后使用二进制搜索。

Answer 3

设 N = 200，k = 3，

1. 创建容量≥Nk的哈希表H。

2. 对于数组 1 中的每个元素 X，将 H[X] 设置为 1。

3. 对于数组 2 中的每个元素 Y，如果 Y 在 H 并且 H[Y] == 1，则设置 H[Y] = 2。

4. 对于数组 3 中的每个元素 Z，如果 Z 在 H 并且 H[Z] == 2，则返回 Z。

5. throw new InvalidDataGivenByInterviewerException();

O(Nk) 时间，O(Nk) 空间复杂度。

Answer 4

为每个整数使用哈希表并对条目进行编码，以便您知道它来自哪个数组 - 然后检查包含所有 3 个数组条目的插槽。 O(n)

Answer 5

使用哈希表将对象映射到频率计数。遍历所有三个列表，递增哈希表中的出现次数，直到遇到出现次数为 3 的列表。这是 O(n)，因为不需要排序。 Python 中的示例：

def find_duplicates(*lists):
  num_lists = len(lists)
  counts = {}
  for l in lists:
    for i in l:
      counts[i] = counts.get(i, 0) + 1
      if counts[i] == num_lists:
        return i

或等效的，使用集合：

def find_duplicates(*lists):
  intersection = set(lists[0])
  for l in lists[1:]:
    intersection = intersection.intersect(set(l))
  return intersection.pop()

Answer 6

O(N) 解决方案：使用哈希表。 H[i] = 映射到 i 的三个数组中所有整数的列表。

对于所有 H[i] > 1，检查其三个值是否相同。如果是，你有你的解决方案。你甚至可以用简单的解决方案来做这个检查，它应该仍然非常快，或者你可以对那些 H[i] 进行排序，然后它就变得微不足道了。

如果你的数字比较小，你可以使用 H[i] = k 如果 i 在三个数组中出现 k 次，那么解决方案是 H[i] = 3 的 i。如果你的数字很大，不过使用哈希表。

即使您可以拥有仅对两个数组通用的元素，并且如果您可以在其中一个数组中拥有重复元素的元素，您也可以将其扩展为工作。它只是变得有点复杂，但你应该能够自己解决。

Answer 7

如果您想要最快的*答案：

• 对一个数组进行排序——时间为 N log N。
• 对于第二个数组中的每个元素，搜索第一个。如果找到它，将 1 添加到伴随数组；否则加 0--time 为 N log N，使用 N 个空间。
• 对于每个非零计数，将相应的条目复制到临时数组中，并对其进行压缩以使其仍处于排序状态——时间为 N。
• 对于第三个数组中的每个元素，搜索临时数组；当你发现命中时，停止。时间小于 N log N。

以下是 Scala 中的代码说明了这一点：

import java.util.Arrays

val a = Array(1,5,2,3,14,1,7)
val b = Array(3,9,14,4,2,2,4)
val c = Array(1,9,11,6,8,3,1)

Arrays.sort(a)
val count = new Array[Int](a.length)
for (i <- 0 until b.length) {
  val j =Arrays.binarySearch(a,b(i))
  if (j >= 0) count(j) += 1
}
var n = 0
for (i <- 0 until count.length) if (count(i)>0) { count(n) = a(i); n+= 1 }
for (i <- 0 until c.length) {
  if (Arrays.binarySearch(count,0,n,c(i))>=0) println(c(i))
}

稍微复杂一点，您既可以不使用额外空间，但对原始数组的破坏性更大，也可以完全避免接触原始数组，代价是另外 N 个空间。

---

编辑：* 正如 cmets 所指出的，哈希表对于非反常输入更快。这是“最快最坏的情况”。除非您使用非常好的散列算法，否则最坏的情况可能不会那么不可能，这可能会比您的排序消耗更多的时间。例如，如果你将所有值乘以 2^16，那么在小于 64k 的列表上，微不足道的散列（即仅使用位掩码整数作为索引）每次都会发生冲突......