在排序数组中找到三个元素，它们与第四个元素相加

Question

我的一位朋友最近得到了这个面试问题，这在我们看来是可以解决的，但不是在面试官认为应该可能的渐近时间范围内。 这是问题所在：

你有一个N整数的数组， xs ，已排序但可能不同。 您的目标是找到四个数组索引^（1） (a,b,c,d) ，以便以下两个属性成立：

 xs[a] + xs[b] + xs[c] = xs[d] a < b < c < d 

目标是在O（N ² ）时间内完成此操作。

首先，O（N ³ log（N））解决方案是显而易见的：对于每个(a,b,c)有序三元组，使用二进制搜索来查看是否可以找到适当的d 。 现在，如何做得更好？

面试官的一个有趣建议是将第一个条件重写为：

xs[a] + xs[b] = xs[d] - xs[c]

在此之后还不清楚该怎么做，但也许我们可以选择一些枢轴值P，并搜索一个(a,b)对加起来P和一个(d,c)对减去它。 对于给定的P，通过从数组的两端向内搜索，该搜索很容易在O（n）时间内完成。 然而，在我看来，这个问题是N ²这样的值P，而不仅仅是N，所以我们实际上根本没有减小问题的大小：我们正在进行O（N）工作， O（N ² ）次。

我们发现在其他地方在线讨论了一些相关的问题：在N ²时间内， 在一个数组中找到添加到给定总和的3个数字是可以解决的，但要求总和提前修复; 适应相同的算法，但迭代每个可能的总和使我们一如既往地在N ³ 。

另一个相关的问题似乎是在数组中查找所有三元组，其总和小于或等于给定的总和 ，但我不确定这里有多少相关的东西：不等式而不是平等混合了很多东西，当然，目标是固定的而不是变化的。

那么，我们缺少什么？ 考虑到性能要求，问题毕竟是不可能的吗？ 还是有一个我们无法发现的聪明算法？

---

（1）实际上提出的问题是找到所有这样的(a,b,c,d)元组，并返回有多少元组的计数。 但我认为即使在所需的时间限制内找到其中一个也很难。

Answer 1

如果算法必须列出解决方案（即满足条件的a ， b ， c和d的集合），则最坏情况时间复杂度为O（n ⁴ ） ：

1.可以有O（n ⁴ ）个解决方案

简单的例子是一个只有0值的数组。 然后a ， b ， c和d只要它们保持有序就具有所有的自由度。 这代表O（n ⁴ ）个解决方案。

但更一般地，遵循以下模式的数组具有O（n ⁴ ）个解决方案：

w, w, w, ... x, x, x, ..., y, y, y, ...  z, z, z, ....

每次出现次数最多，并且：

w + x + y = z

然而，为了仅产生解决方案的数量 ，算法可以具有更好的时间复杂度。

2.算法

这是已经发布的算法的略微变化，其不涉及H因子。 它还描述了如何处理不同配置导致相同总和的情况。

• 检索所有对并将它们存储在数组X中 ，其中每个元素都获取以下信息：

  a ：两者中最小的指数
  b ：另一个指数
  sum ： xs[a] + xs[b]

• 同时还为另一个数组Y中的每个这样的对存储，如下：

  c ：两者的最小指数
  d ：另一个索引
  sum ： xs[d] - xs[c]的值xs[d] - xs[c]

上述操作的时间复杂度为O（n²）

• 按元素的sum属性对两个数组进行排序。 在总和值相等的情况下，排序顺序将如下确定：对于X数组，增加b ; 对于Y数组，通过减少c 。 可以在O（n²） O（nllogn）时间内完成排序。

[ 编辑：我无法证明之前的O（n²）声明 （除非做出一些允许基数/桶分类算法的假设，我不会假设）。 如注释中所述，一般来说，带有n²元素的数组可以按O（n²logn²）排序，即O（n²logn） ，但不是O（n²） ]

• 通过“tandem”中的两个数组来查找相等的和。 如果是这种情况，则需要检查X[i].b < Y[j].c 。 如果是这样，它就代表了一个解 但是可能有很多，并且在可接受的时间内计算它们需要特别小心。

  设m = n(n-1)/2 ，即数组X中的元素数（也是数组Y的大小）：

    i = 0
    j = 0
    while i < m and j < m:
        if X[i].sum < Y[j].sum:
            i = i + 1
        elif X[i].sum > Y[j].sum:
            j = j + 1
        else:
            # We have a solution. Need to count all others that have same sums in X and Y.
            # Find last match in Y and set k as index to it:
            countY = 0
            while k < m and X[i].sum == Y[j].sum and X[i].b < Y[j].c:
                countY = countY + 1
                j = j + 1
            k = j - 1
            # add chunks to `count`:
            while i < m and countY >= 0 and X[i].sum == Y[k].sum:
                while countY >= 0 and X[i].b >= Y[k].c:
                    countY = countY - 1
                    k = k - 1
                count = count + countY
                i = i + 1

请注意，虽然有嵌套循环，但变量i只会递增， j也是如此。 变量k总是在最里面的循环中递减。 虽然它也可以从较高的值开始，但它永远不会通过k索引对同一个Y元素进行多次寻址，因为在递减该索引时，它会保持在Y的“相同和”范围内。

所以这意味着算法的最后一部分以O（m）运行，即O（n²） 。 由于我的最新编辑确认排序步骤不是O（n²） ，该步骤决定了整体时间复杂度： O（n²logn） 。

Answer 2

所以一个解决方案可以是：

列出所有x [a] + x [b]值，使a <b并以这种方式对它们进行散列

key = (x[a]+x[b]) and value = (a,b).

这一步的复杂性 - O（n ^ 2）

现在列出所有x [d] - x [c]值，使得d> c。 此外，对于每个x [d] - x [c]，通过查询搜索哈希映射中的条目。 如果存在任何命中c> b的条目，我们就有一个解决方案。 该步骤的复杂性 - O（n ^ 2）* H.

其中H是hashmap中的搜索时间。

总复杂度 - O（n ^ 2）* H.现在H可以是O（1）。 如果数组中的值范围很小，则可以执行此操作。 散列函数的选择还取决于数组中元素的属性。