454. 4Sum II [Medium]

这道题不应该用kSum套路，虽然可以解出来，但是时间复杂度很高O(n^3)

1. 此题不需要去重，也太需要用到元素的大小关系，所以不需要排序

2. 每个数都从独立的数组里找出来，不存在kSum那样必须要在已确定的两个数字后面的情况，则无需每一层都用内嵌循环

本题思路：

先双层循环组合AB，将每个A[i] + B[j]的值与出现次数存于HashMap中，再组合CD的两个数字，从map中取得相补的数字key对应的value就是这一对CD能组成的答案个数，将所有CD能组成的答案个数加起来就是最终答案。

这样组合AB是O(n^2)的时间复杂度，组合CD也是O(n^2)的时间复杂度，整个题解仍然是O(n^2)的时间复杂度。

另外，题解中巧妙运用HashMap类的getOrDefault()方法设置key不存在时的返回值，如果直接用map()方法，当map中没有要找的key，会返回null。

/**
 * 自己的解法，用的kSum套路
 * 先确定AB数组中的数字，再分别sort()CD数组，然后用双指针分别从C头和D尾开始搜索使四数之和等于target
 * 时间faster than 5.06%，空间less than 99.99%
 */
class Solution {
    public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
        if (A.length == 0 || B.length == 0 || C.length == 0 || D.length == 0) return 0;
        int ans = 0;
        Arrays.sort(C);
        Arrays.sort(D);
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < B.length; j++) {
                int start = 0, end = D.length - 1;
                while (start < C.length && end >= 0) {
                    int sum = A[i] + B[j] + C[start] + D[end];
                    if (sum > 0) end--;
                    else if (sum < 0) start++;
                    else {
                        int cnt_c = 1, cnt_d = 1;
                        while (start + 1 < C.length && C[start] == C[start + 1]) {
                            start++;
                            cnt_c++;
                        }
                        while (end - 1 >= 0 && D[end] == D[end - 1]) {
                            end--;
                            cnt_d++;
                        }
                        ans += cnt_c * cnt_d;
                        start++;
                        end--;
                    }
                }
            }
        }
        return ans;
    }
}

/**
 * 先将所有AB数组的数字组合情况记录在HashMap中
 * 再组合CD数组的数字，在HashMap中寻找匹配的值
 * 时间复杂度O(max(n*m, p*q))
 * 本题巧妙运用HashMap类的getOrDefault()方法，如果直接用map()方法，当map中没有要找的key，会返回null
 */
class Solution {
    public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
        if (A.length == 0 || B.length == 0 || C.length == 0 || D.length == 0) return 0;
        int ans = 0;
        HashMap<Integer, Integer> map = new HashMap<>(); // 存储前两位数只和与出现次数的对应关系
        for (int i = 0; i < A.length; i++)
            for (int j = 0; j < B.length; j++)
                map.put(A[i] + B[j], map.getOrDefault(A[i] + B[j], 0) + 1); 
        for (int i = 0; i < C.length; i++)
            for (int j = 0; j < D.length; j++)
                ans += map.getOrDefault(- C[i] - D[j], 0); // 在map中找与当前C[i]+D[j]匹配的AB数组数字组合有几个
        return ans;
    }
}