[Swift]LeetCode454. 四数相加 II | 4Sum II

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10343175.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

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

---

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -228 到 228 - 1 之间，最终结果不会超过 231 - 1 。

例如:

输入:
A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]

输出:
2

解释:
两个元组如下:
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

---

264ms

class Solution {
    func fourSumCount(_ A: [Int], _ B: [Int], _ C: [Int], _ D: [Int]) -> Int {
        var map: [Int: Int] = [:]
        for i in 0..<A.count {
            for j in 0..<B.count {
                let sum = A[i] + B[j]
                map[sum, default: 0] += 1
            }
        }
        
        var count = 0
        for i in 0..<C.count {
            for j in 0..<D.count {
                let sum = C[i]+D[j]
                if let negativeOfSum = map[-sum] {
                    count += negativeOfSum
                }
            }
        }
        
        return count
    }
}

---

312ms

class Solution {
    func fourSumCount(_ A: [Int], _ B: [Int], _ C: [Int], _ D: [Int]) -> Int {
        var map: [Int: Int] = [:]
        for i in A.indices {
            for j in B.indices {
                map[A[i] + B[j], default: 0] += 1
            }
        }
        
        var result = 0
        for i in C.indices {
            for j in D.indices {
                result += map[-C[i]-D[j], default:0]
            }
        }
        
        return result
    }
}

---

436ms

 class Solution {
        func Max(_ A: ([Int], Int), _ B: ([Int], Int)) -> ([Int], Int) {
            if A.0.count > B.0.count {
                return A
            }else{
                return B
            }
        }
        func Min(_ A: ([Int], Int), _ B: ([Int], Int)) -> ([Int], Int) {
            if A.0.count < B.0.count {
                return A
            }else{
                return B
            }
        }
        func fourSumCount(_ A: [Int], _ B: [Int], _ C: [Int], _ D: [Int]) -> Int {
            var nums = [A, B, C, D]
            let A1 = Max(Max((nums[0],0), (nums[1],1)), Max((nums[2],2), (nums[3],3)))
            nums.remove(at: A1.1)
            let B1 = Min(Min((nums[0],0), (nums[1],1)), (nums[2], 2))
            nums.remove(at: B1.1)
            let C1 = nums[0]
            let D1 = nums[1]
            
            var dict = [Int:Int]()
            for a in A1.0 {
                for b in B1.0 {
                    if let n = dict[a + b]{
                        dict[a + b] = n + 1
                    }else{
                        dict[a + b] = 1
                    }
                }
            }
            var count = 0
            for c in C1 {
                for d in D1 {
                    if let n = dict[0 - c - d] {
                        count += n
                    }
                }
            }
            return count
        }
    }

---

540ms

class Solution {
    func fourSumCount(_ A: [Int], _ B: [Int], _ C: [Int], _ D: [Int]) -> Int {
        var res:Int = 0
        var n:Int = A.count
        var m1:[Int:Int] = [Int:Int]()
        var m2:[Int:Int] = [Int:Int]()
        for i in 0..<n
        {
            for j in 0..<n
            {
                if m1[A[i] + B[j]] == nil
                {
                    m1[A[i] + B[j]] = 1
                }
                else
                {
                    m1[A[i] + B[j]]! += 1
                }
                if m2[C[i] + D[j]] == nil
                {
                    m2[C[i] + D[j]] = 1
                }
                else
                {
                    m2[C[i] + D[j]]! += 1
                }
            }
        }
        for (key,val) in m1
        {
            if m2[-key] != nil
            {
                res += val * m2[-key]!
            }            
        }
        return res
    }
}

---

548ms

class Solution {
    func fourSumCount(_ A: [Int], _ B: [Int], _ C: [Int], _ D: [Int]) -> Int {
        var result = 0
        var map: [Int: Int] = [:]
        for a in A {
            for b in B {
                 let sum = a + b
                if let count = map[sum] {
                    map[sum] = count + 1
                } else {
                    map[sum] = 1
                }
            }
        }

        for c in C {
            for d in D {
                let sum = -(c + d)
                if let count = map[sum] {
                    result += count
                }
            }
        }

        return result
    }
}

---

880ms

class Solution {
    func fourSumCount(_ A: [Int], _ B: [Int], _ C: [Int], _ D: [Int]) -> Int {
        
        var res = 0
        
        var CDRecord = [Int : Int]()
        
        for c in C {
            for d in D {
               if let r = CDRecord[c + d] {
                   CDRecord[c + d] = r + 1
               } else {
                    CDRecord[c + d] = 1
               }
            }
        }
        
        for a in A {
            for b in B {
                let complete = 0 - (a + b)
                
                if let value = CDRecord[complete] {
                    res += value
                }
            }
        }
        return res                
    }
}