LeetCode N-sum的问题总结

首先列出题号 15 16 18 259 454， 这是推荐的练习顺序。
N Sum也算是非常典型的一类问题了。基本的算法就是考察2-pointer在已排序数组中的使用。为什么我不推荐用hashset，因为在这一类问题中，2-pointer更加地general，而且代码的可读性更好。

还有比较重要的一点，2-pointer能够处理一些变体，比如不是完全的等于，而是小于或者大于（16题就是一个很典型的例子，你如果用hashset做，可以做，但是很容易出错）。但是不可能一个2-pointer所有题目通用。2-pointer

很显然必须要数组经过排序，如果答案是要输出原始索引的，那么你就需要重新copy数组保存原始的索引。还有一个更重要的是时间复杂度的问题。

a+b+c = 0 -> 用2-pointer和hashset都能达到O(N²) 但是你考虑 a+b+c+d = 0.用2-pointer最好也是O(N^3)，如果用hashset反而能达到O(n^2)。下面来看454题这个例子的体现。

第一个解法是用2-pointer，只能到N^3的时间复杂度

public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Arrays.sort(nums3);
        Arrays.sort(nums4);
        int n = nums1.length, ret = 0;
        for(int i = 0; i < nums1.length; i++) {
            for(int j = 0; j < nums2.length; j++) {
                int expected = (nums1[i] + nums2[j]) * -1;
                int start1 = 0, start2 = n - 1;
                while(start1 < n && start2 >= 0) {
                    int cur = nums3[start1] + nums4[start2];
                    if (cur == expected) {
                        int next1 = start1, next2 = start2;
                        while (next1 < n && nums3[next1] == nums3[start1]) {
                            next1++;
                        }
                        while(next2 >= 0 && nums4[next2] == nums4[start2]) {
                            next2--;
                        }
                        ret += (next1 - start1) * (start2 - next2);
                        start1 = next1;
                        start2 = next2;
                    } else if (cur < expected) {
                        start1++;
                    } else {
                        start2--;
                    }
                }
            }
        }
        return ret;
    }

第二个解法是hashset，时间复杂度是n^2

public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int ret = 0;
        HashMap<Integer, Integer> sum1 = new HashMap<>();
        for(int i = 0; i < nums1.length; i++) {
            for(int j = 0; j < nums2.length; j++) {
                int sum = nums1[i] + nums2[j];
                sum1.put(sum, sum1.getOrDefault(sum, 0) + 1);
            }
        }
        
        for(int i = 0; i < nums3.length; i++) {
            for(int j = 0; j < nums4.length; j++) {
                int sum = (nums3[i] + nums4[j]) * -1;
                ret += sum1.getOrDefault(sum, 0);
            }
        }
        
        return ret;
    }

其实看到这里你应该已经能看清楚规律了，当方程的未知数越多，hashset就更有效。假设方程有n个未知数，那么hashset最好总是能达到 (n + 1) / 2的复杂度，这一点是由方程的对称性体现的。