package LeetCode_454

/**
 * 454. 4Sum II
 * https://leetcode.com/problems/4sum-ii/
 * Given four lists A, B, C, D of integer values,
 * compute how many tuples (i, j, k, l) there are such that A[i] + B[j] + C[k] + D[l] is zero.
To make problem a bit easier, all A, B, C, D have same length of N where 0 ≤ N ≤ 500.
All integers are in the range of -228 to 228 - 1 and the result is guaranteed to be at most 231 - 1.
Example:
Input:
A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]
Output:
2
Explanation:
The two tuples are:
1. (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0
 * 
 
*/
class Solution {
    /*
    * solution: HashMap, key is sum of A[i] and B[j], value is number of occurrences number of sum,
    * then count the number of -(C[i] and D[j]), for example A[i]+B[j]=1,C[i]+D[j]=-1, so sum up 1,-1 is 0;
    * Time(n^2), Space:O(n^2)
    * */
    fun fourSumCount(A: IntArray, B: IntArray, C: IntArray, D: IntArray): Int {
        val map 
 
= HashMap<Int, Int>()
        for (i in A.indices) {
            for (j in B.indices) {
                val sum = A[i] + B[j]
                map.put(sum, map.getOrDefault(sum, 0) + 1)
            }
        }
        var result = 0
        for (i in C.indices) {
            for (j in D.indices) {
                val sum 
 
= C[i] + D[j]
                result += map.getOrDefault(-1 * sum, 0)
            }
        }
        return result
    }
}