[Swift]LeetCode525. 连续数组 | Contiguous Array

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

Given a binary array, find the maximum length of a contiguous subarray with equal number of 0 and 1.

Example 1:

Input: [0,1]
Output: 2
Explanation: [0, 1] is the longest contiguous subarray with equal number of 0 and 1. 

Example 2:

Input: [0,1,0]
Output: 2
Explanation: [0, 1] (or [1, 0]) is a longest contiguous subarray with equal number of 0 and 1. 

Note: The length of the given binary array will not exceed 50,000.

---

给定一个二进制数组, 找到含有相同数量的 0 和 1 的最长连续子数组（的长度）。 

示例 1:

输入: [0,1]
输出: 2
说明: [0, 1] 是具有相同数量0和1的最长连续子数组。

示例 2:

输入: [0,1,0]
输出: 2
说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。 

注意: 给定的二进制数组的长度不会超过50000。

---

760ms

class Solution {
    func findMaxLength(_ nums: [Int]) -> Int {
        var map = [Int: Int]()
        map[0] = -1
        
        var maxLength = 0
        var count = 0
        for i in 0..<nums.count {
            count += nums[i] == 1 ? 1 : -1
            if let v = map[count] {
                maxLength = max(maxLength, i - v)
            } else {
                map[count] = i
            }
        }
        
        return maxLength
    }
}

---

804ms

class Solution {
    func findMaxLength(_ nums: [Int]) -> Int {
        let nums = nums.map { (n: Int) -> Int in
            if n == 0 { 
                return -1 
            } else { 
                return 1 
            }
        }
        var preSum: [Int: Int] = [:] // sum - index
        preSum[0] = -1
        var sum = 0
        var res = 0
        for i in 0 ..< nums.count {
            sum += nums[i]
            if preSum[sum] != nil {
                res = max(res, i - preSum[sum]!)  
            } else {
                preSum[sum] = i
            }
        }
        return res
    }
}

---

Runtime: 812 ms

Memory Usage: 19.7 MB

class Solution {
    func findMaxLength(_ nums: [Int]) -> Int {
        var res:Int = 0
        var n:Int = nums.count
        var sum:Int = 0
        var m:[Int:Int] = [0:-1]
        for i in 0..<n
        {
            let num:Int = (nums[i] << 1) - 1
            sum += num
            if m[sum] != nil
            {
                res = max(res, i - m[sum]!)
            }
            else
            {
                m[sum] = i
            }
        }
        return res
    }
}

---

904ms

class Solution {
    func findMaxLength(_ nums: [Int]) -> Int {
        if nums.isEmpty { return 0 }
        
        var sums = [Int: (Int?, Int?)]()
        sums[0] = (-1, nil)

        var sum = 0
        for i in 0..<nums.count {
            sum += (nums[i] == 1) ? 1 : -1
            if sums[sum] == nil {
                sums[sum] = (i, nil)
            } else {
                sums[sum]!.1 = i
            }
        }
        
        var ret = 0
        for (sum, pair) in sums {
            if pair.1 != nil {
                ret = max(ret, pair.1! - pair.0!)
            }
        }
        return ret
    }
}

---

976ms

class Solution {
    func findMaxLength(_ nums: [Int]) -> Int {
        let n = nums.count
        if n == 0 { return 0 }
        var max = [Int](repeating: 0, count: n)
        var count_ones = [Int](repeating: 0, count: n)
        for i in 0..<n {
            if i == 0 { count_ones[i] = nums[0] }
            else { count_ones[i] = count_ones[i-1] + nums[i] }
        }
        
        max[n-1] = 0
        var i = n-2
        var res = 0
        while i >= 0 {
            var diff = (nums[i] == 1 ? 1 : -1)
            var j = i
            while diff != 0 && j < n {
                let next_j = j + abs(diff)
                if next_j >= n { break }
                let ones = (count_ones[next_j] - count_ones[j])
                let zeros = (next_j - j) - ones
                diff = diff + ones - zeros
                j = next_j
            }
            
            if diff == 0 {
                max[i] = (j-i+1) + (j < n-1 ? max[j+1] : 0)
            }
            
            if res < max[i] { res = max[i] }
            
            i -= 1
        }
        
        return res
    }
}

---

1160ms

class Solution {
    func findMaxLength(_ nums: [Int]) -> Int {
        var map: [Int: [Int]] = [:]
        var curr = 0
        map[0] = [0]
        
        for i in 0..<nums.count {
            var bin = nums[i]
            
            if (bin == 1) {
                curr += 1
            }
            else {
                curr -= 1
            }
                
            if let _ = map[curr] {
                map[curr]!.append(i+1)
            }
            else {
                map[curr] = [i+1]
            }
        }
        
        return getMaxLengthFromMap(map)
    }
    
    func getMaxLengthFromMap(_ map: [Int: [Int]]) -> Int {
        var maxL = 0
        
        for key in map.keys {
            let indexes = map[key]!
            if indexes.count > 1 {
                var tempMax = indexes[indexes.count-1] - indexes[0]
                
                maxL = max(maxL, tempMax)
            }
        }
        
        return maxL
    }
}