[Swift]LeetCode697. 数组的度 | Degree of an Array

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

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

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

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

Given a non-empty array of non-negative integers nums, the degreeof this array is defined as the maximum frequency of any one of its elements.

Your task is to find the smallest possible length of a (contiguous) subarray of nums, that has the same degree as nums.

Example 1:

Input: [1, 2, 2, 3, 1]
Output: 2
Explanation: 
The input array has a degree of 2 because both elements 1 and 2 appear twice.
Of the subarrays that have the same degree:
[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
The shortest length is 2. So return 2. 

Example 2:

Input: [1,2,2,3,1,4,2]
Output: 6 

Note:

• nums.length will be between 1 and 50,000.
• nums[i] will be an integer between 0 and 49,999.

---

给定一个非空且只包含非负数的整数数组 nums, 数组的度的定义是指数组里任一元素出现频数的最大值。

你的任务是找到与 nums 拥有相同大小的度的最短连续子数组，返回其长度。

示例 1:

输入: [1, 2, 2, 3, 1]
输出: 2
解释: 
输入数组的度是2，因为元素1和2的出现频数最大，均为2.
连续子数组里面拥有相同度的有如下所示:
[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
最短连续子数组[2, 2]的长度为2，所以返回2.

示例 2:

输入: [1,2,2,3,1,4,2]
输出: 6

注意:

• nums.length 在1到50,000区间范围内。
• nums[i] 是一个在0到49,999范围内的整数。

---

Runtime: 220 ms

Memory Usage: 20.5 MB

class Solution {
    func findShortestSubArray(_ nums: [Int]) -> Int {
        guard nums.count > 1 else {
            return nums.count
        }
        var dic: [Int:Int] = [:]
        for i in 0..<nums.count {
            let num: Int = nums[i]
            if dic.keys.contains(num) {
                dic[num] = dic[num]! + 1
            } else {
                dic[num] = 1
            }
        }
        var max = 0//出现最大次数
        var maxNums: [Int] = []//出现最大次数元素数组
        for j in dic.keys {
            let v = dic[j]!
            if v > max {
                maxNums.removeAll()
                maxNums.append(j)
                max = v
            } else if v == max {
                maxNums.append(j)
            }
        }
        if max < 2 {
            return 1
        }
        var minChildArrayCount = nums.count//最短连续子数组长度
        for a in maxNums {
            var start: Int = 0,end: Int = nums.count-1//开始位置，结束位置
            for s in nums {
                if s != a {
                    start += 1
                } else {
                    break
                }
            }
            for e in nums.reversed() {
                if e != a {
                    end -= 1
                } else {
                    break
                }
            }
            minChildArrayCount = min(minChildArrayCount, end-start+1)
        }
        return minChildArrayCount
    }
}

---

228ms

class Solution {
    func findShortestSubArray(_ nums: [Int]) -> Int {        
        var starts = [Int: Int]()
        var ends = [Int: Int]()
        var counts = [Int: Int]()
        var maxCount = Int.min
        
        for i in 0..<nums.count {            
            let num = nums[i]
            if starts[num] == nil {
                starts[num] = i
            }
            ends[num] = i
            counts[num] = ( counts[num] ?? 0 ) + 1            
            maxCount = max(counts[num]!, maxCount)
        }        

        var result = Int.max
        for key in counts.keys {            
            if counts[key]! < maxCount {
                continue
            }
            
            result = min(ends[key]! - starts[key]! + 1, result)
        }        

        return result
    }
}

---

240ms

class Solution {
    func findShortestSubArray(_ nums: [Int]) -> Int {
        var dict = [Int: [Int]]()
        var frequency = Dictionary( nums.map{ ($0, 1) }, uniquingKeysWith: +)
        var degree = 0
        for (key, value) in frequency {
            degree = max(value, degree)
        }
        var degreeItemArray = Set<Int>()
        for (key, value) in frequency {
            if value == degree {
                degreeItemArray.insert(key)
            }
        }
        for i in 0..<nums.count {
            guard degreeItemArray.contains(nums[i]) else {
                continue
            }
            dict[nums[i]] = dict[nums[i]] ?? [i, i]
            var items = dict[nums[i]]!
            if i > items[1] {
                items[1] = i
            }
            dict[nums[i]] = items
        }
        var result = Int.max
        for (key, value) in dict {
            result = min(result, value[1] - value[0] + 1)
        }
        return result
    }
}

---

264ms

class ItemInfo {
    let value: Int
    var count: Int
    var startIndex: Int
    var endIndex: Int
    
    var length: Int {
        return self.endIndex - self.startIndex + 1
    }
    
    init(value: Int, at index: Int) {
        self.value = value
        self.count = 1
        self.startIndex = index
        self.endIndex = index
    }
    
    func addItem(at index: Int) -> Self {
        self.count += 1
        self.startIndex = min(startIndex, index)
        self.endIndex = max(endIndex, index)
        
        return self
    }
}

class Solution {
    func findShortestSubArray(_ nums: [Int]) -> Int {
        guard nums.count > 1 else {
            return nums.count
        }
        
        var info: [Int: ItemInfo] = [:]
        
        for (index, num) in nums.enumerated() {
            if let currentInfo = info[num] {
                info[num] = currentInfo.addItem(at: index)
            } else {
                info[num] = ItemInfo(value: num, at: index)
            }
        }
        
        if let max = info.max(by: { (arg1, arg2) -> Bool in
            return arg1.value.count < arg2.value.count || (arg1.value.count == arg2.value.count && arg1.value.length > arg2.value.length)
        }) {
            return max.value.length
        } else {
            return -1
        }
    }
}

---

284ms

class Solution {
    func findShortestSubArray(_ nums: [Int]) -> Int {
        var firstIndexMap = [Int: Int]()
        var lastIndexMap = [Int: Int]()
        var countMap = [Int: Int]()

        // Find the "degree" (most frequent element count)
        var maxCount = 0
        for (i, num) in nums.enumerated() {
            if let count = countMap[num] {
                maxCount = max(maxCount, count + 1)
                countMap[num] = count + 1
                lastIndexMap[num] = i
            } else {
                countMap[num] = 1
                firstIndexMap[num] = i
            }
            
            maxCount = max(maxCount, countMap[num]!)
        }
        
        guard maxCount > 1 else { return maxCount }

        let maxDict = countMap.filter { k, v in v == maxCount }

        var lengthsDict = [Int: Int]()
        for (key, _) in maxDict {
            lengthsDict[key] = lastIndexMap[key]! - firstIndexMap[key]! + 1
        }

        let minValue = [Int](lengthsDict.values).min() ?? 0

        return minValue
    }
}

---

440ms

class Solution {
    func findShortestSubArray(_ nums: [Int]) -> Int {
        
        if nums.count <= 1 {
            return nums.count
        }
        
        var dict = [Int: [String: Int]]()
        
        for i in 0..<nums.count {
            
            let value = nums[i]
            
            if dict[value] == nil {
                dict[value] = [
                    "start": i,
                    "end": i,
                    "count": 1
                ]
            } else {
                dict[value]!["end"] = i
                dict[value]!["count"] = dict[value]!["count"]! + 1
            }
        }
        
        var count = Int.min
        var degree = Int.max
        
        for key in dict.keys {
            
            let d = dict[key]
            
            guard let c = d!["count"] else {
                continue
            }
            
            if c < count {
                continue
            }
            
            guard let s = d!["start"] else {
                continue
            }
            
            guard let e = d!["end"] else {
                continue
            }
            
            if c > count {
                degree = e - s + 1
            } else {
                degree = min(degree, e - s + 1)
            }
            
            count = max(count, c)
        }
        
        return degree == Int.max ? 1 : degree
    }
}