如何在线性时间内找到 2-sum？

Question

我报名了 Coursera 上的Algorithms, Part II 课程，其中一道面试题（未评分）如下：

2-sum。给定一个由n 64 位整数组成的数组a 和一个目标值T， 确定是否存在两个不同的整数 i 和 j 使得 a[i] + a[j] = T。你的算法应该在最坏的情况下以线性时间运行 案例。

提示：按线性时间对数组进行排序。

我可以想办法解决这个问题：

1. 一次性将元素插入哈希表。然后进行第二遍，在哈希表中寻找T - a[i]。哈希表的空间复杂度为 O(n)，2 遍的空间复杂度为 O(n)。此解决方案满足问题中所述的时间要求。

2. 对数组进行排序，然后分别从开头和结尾运行2个指针i和j，寻找a[i] + a[j] = T。如果a[i] + a[j] < T，则增加i，否则减少j。空间复杂度取决于排序算法；假设，快速排序，不需要额外的空间。时间复杂度，nlogn，所以它没有达到问题中所述的时间要求。

3. 考虑到问题是在基数排序讲座之后给出的，我假设意图是使用基数排序之一。由于问题指定了 64 位整数，使用 long 的二进制表示并使用 In-place MSD radix sort，因此可以在线性时间内对数组进行就地排序。这似乎是最好的方法。

其他想法？

附：我看过这个question，但它假定一个排序数组，并且那里的所有答案都使用某种散列。

我也见过这个question，但对于 2-sum 的具体情况来说，它似乎过于复杂。

Answer 1

我分析了您的观察结果，并分析了似乎符合要求的观察结果：

一次性在哈希表中插入元素。然后进行第二次传球， 在哈希表中寻找 T - a[i]。空间复杂度为 O(n) 哈希表，以及 2 遍的 O(n)。该解决方案符合 问题中说明的时间要求。

我认为这种方法不符合要求，因为理论上hashtable 最坏情况插入复杂度为 O(n)。

正如您所说您学习了基数排序，我相信这是要走的路，您可以在时间要求内对数组进行排序，然后您可以使用Two Pointers技术检查是否有和T ：

int left = 0, right = array_size - 1;
boolean found = false;
while (left < right) {

    if (a[left] + a[right] == T) {              
        found = true;
    }
    else if (a[left] + a[right] < T) {
        left++;
    }
    else {
        right--;
    }
}

Answer 2

当您遍历数组时，将值放入一个哈希表中，将值映射到索引。由于我们只求两个数之和，因此在哈希中求当前数与余数之和即可得到目标。

public static int[] twoSumInOnePass(int[] values, int target) throws Exception {
    // value => index
    Map<Integer, Integer> valueToIndexMap = new HashMap<Integer, Integer>();
    for (int i = 0; i < values.length; i++) {
        int remainder = target - values[i];
        if (valueToIndexMap.containsKey(remainder)) {
            return new int[] { valueToIndexMap.get(remainder), i };
        }
        valueToIndexMap.put(values[i], i);
    }

    throw new Exception("Could not find indexes that sum to " + target);
}

https://leetcode.com/problems/two-sum/description/

Answer 3

回答我自己的问题，这是 Java 中的有效解决方案：

public class RadixSortsInterviewQuestions {
    private static final int MSB = 64;

    static Map.Entry<Integer, Integer> twoSum(long[] a, long sum) {
        int n = a.length - 1;
        sort(a, MSB, 0, n);

        for (int i = 0, j = n; i < j; ) {
            long t = a[i] + a[j];
            if (t == sum) {
                return new SimpleImmutableEntry<>(i, j);
            } else if (t < sum) {
                i++;
            } else {
                j--;
            }
        }
        return null;
    }

    // Binary MSD radix sort: https://en.wikipedia.org/wiki/Radix_sort#In-place_MSD_radix_sort_implementations
    private static void sort(long[] a, int d, int lo, int hi) {
        if (hi < lo || d < 1) return;

        int left = lo - 1;
        int right = hi + 1;

        for (int i = left + 1; i < right; ) {
            if (isBitSet(a[i], d)) {
                swap(a, i, --right);
            } else {
                left++;
                i++;
            }
        }
        sort(a, d - 1, lo, left);
        sort(a, d - 1, right, hi);
    }

    private static boolean isBitSet(long x, int k) {
        boolean set = (x & 1L << (k - 1)) != 0;

        // invert signed bit so that all positive integers come after negative ones
        return (k == MSB) != set;
    }

    private static void swap(long[] a, int i, int j) {
        long tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }
}