[Swift]LeetCode911. 在线选举 | Online Election

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

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

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

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

In an election, the i-th vote was cast for persons[i] at time times[i].

Now, we would like to implement the following query function: TopVotedCandidate.q(int t) will return the number of the person that was leading the election at time t.  

Votes cast at time t will count towards our query.  In the case of a tie, the most recent vote (among tied candidates) wins.

Example 1:

Input: ["TopVotedCandidate","q","q","q","q","q","q"], [[[0,1,1,0,0,1,0],[0,5,10,15,20,25,30]],[3],[12],[25],[15],[24],[8]]
Output: [null,0,1,1,0,0,1]
Explanation: 
At time 3, the votes are [0], and 0 is leading.
At time 12, the votes are [0,1,1], and 1 is leading.
At time 25, the votes are [0,1,1,0,0,1], and 1 is leading (as ties go to the most recent vote.)
This continues for 3 more queries at time 15, 24, and 8.

Note:

1. 1 <= persons.length = times.length <= 5000
2. 0 <= persons[i] <= persons.length
3. times is a strictly increasing array with all elements in [0, 10^9].
4. TopVotedCandidate.q is called at most 10000 times per test case.
5. TopVotedCandidate.q(int t) is always called with t >= times[0].

---

在选举中，第 i 张票是在时间为 times[i] 时投给 persons[i] 的。

现在，我们想要实现下面的查询函数： TopVotedCandidate.q(int t) 将返回在 t 时刻主导选举的候选人的编号。

在 t 时刻投出的选票也将被计入我们的查询之中。在平局的情况下，最近获得投票的候选人将会获胜。

示例：

输入：["TopVotedCandidate","q","q","q","q","q","q"], [[[0,1,1,0,0,1,0],[0,5,10,15,20,25,30]],[3],[12],[25],[15],[24],[8]]
输出：[null,0,1,1,0,0,1]
解释：
时间为 3，票数分布情况是 [0]，编号为 0 的候选人领先。
时间为 12，票数分布情况是 [0,1,1]，编号为 1 的候选人领先。
时间为 25，票数分布情况是 [0,1,1,0,0,1]，编号为 1 的候选人领先（因为最近的投票结果是平局）。
在时间 15、24 和 8 处继续执行 3 个查询。 

提示：

1. 1 <= persons.length = times.length <= 5000
2. 0 <= persons[i] <= persons.length
3. times 是严格递增的数组，所有元素都在 [0, 10^9] 范围中。
4. 每个测试用例最多调用 10000 次 TopVotedCandidate.q。
5. TopVotedCandidate.q(int t) 被调用时总是满足 t >= times[0]。

---

Runtime: 1524 ms

Memory Usage: 21.9 MB

class TopVotedCandidate {
    var m:[Int:Int] = [Int:Int]()
    var time:[Int]

    init(_ persons: [Int], _ times: [Int]) {
        self.time = times
        var n:Int = persons.count
        var lead:Int = -1
        var count:[Int:Int] = [Int:Int]()
        for i in 0..<n
        {
            count[persons[i],default:0] += 1
            if i == 0 || count[persons[i],default:0] >= count[lead,default:0]
            {
                lead = persons[i]
            }
            m[times[i]] = lead
        }        
    }
    
    func q(_ t: Int) -> Int {
        var i:Int = binarySearch(t)
        return i < 0 ? m[time[-i-2],default:0] : m[time[i],default:0]      
    }

    func binarySearch(_ target:Int) -> Int
    {
        var low = 0
        var high = time.count - 1
        var mid = (low + high) >> 1
        
        while low <= high {
            let val = time[mid]
            if target == val {
                return mid
            } else if target < val {
                high = mid - 1
            } else {
                low = mid + 1 
            }
            mid = (low + high) >> 1
        }
        return high
    }
}

/**
 * Your TopVotedCandidate object will be instantiated and called as such:
 * let obj = TopVotedCandidate(persons, times)
 * let ret_1: Int = obj.q(t)
 */

---

1672ms

class TopVotedCandidate {
    var history: [Int]
    let times: [Int]
    init(_ persons: [Int], _ times: [Int]) {
        self.history = Array(repeating: 0, count: times.count)
        self.times = times
        var votes = Array(repeating: 0, count: persons.count + 1)
        var last = 0
        for i in 0..<persons.count {
            let p = persons[i]
            votes[p] += 1
            if votes[p] >= votes[last] { last = p }
            history[i] = last
        }
        print(history)
        print(times)
    }
    
    // return the biggest index of a time <= t
    func binarySearch(_ t: Int) -> Int {
        var i = 0, j = times.count
        while i < j {
            let m = (i + j) / 2
            let a = times[m]
            if a == t { return m }
            if a > t { j = m }
            else {
                if i == m { return m }
                i = m
            }
        }
        return j
    }
    
    func q(_ t: Int) -> Int {
        let i = binarySearch(t)
        return history[i]
    }
}

---

1716ms

class TopVotedCandidate {
    var rankings = [(Int, Int)]()
    
    init(_ persons: [Int], _ times: [Int]) {
        var map = [Int: Int]()
        var leader = -1
        var leaderCount = -1
        for i in 0..<persons.count {
            let sum = (map[persons[i]] ?? 0) + 1
            map[persons[i]] = sum
            if sum >= leaderCount {
                leader = persons[i]
                leaderCount = sum
            }
            rankings.append((times[i], leader))
        }
    }
    
    func q(_ t: Int) -> Int {
        guard t < rankings.last!.0 else {
            return rankings.last!.1
        }
        var left = 0
        var right = rankings.count
        while left < right {
            let mid = left + (right - left) / 2
            if rankings[mid].0 <= t {
                left = mid + 1
            } else {
                right = mid
            }
        }
        return rankings[left - 1].1
    }
}

---

1732ms

class TopVotedCandidate {
    var curMax = 0,  maxes = [Int](), votes = [Int: Int](), times = [Int]()
    // 0,1,1,0,0,1,0
    // 0 1 1 0 0 1 0
    init(_ persons: [Int], _ times: [Int]) {
        maxes = [Int](repeating: -1, count: persons.count)
        for (idx, person) in persons.enumerated() {
            votes[person] = (votes[person] ?? 0) + 1
            if let vote = votes[person], vote >= curMax {
                curMax = vote
                maxes[idx] = person
            } else {
                maxes[idx] = maxes[idx - 1]
            }
        }
        self.times = times
    }
    
    func q(_ t: Int) -> Int {
        var l = 0, r = times.count, idx = -1
        while l < r {
            var mid = (l + r) / 2
            if times[mid] == t {
                idx = mid
                break
            } else if times[mid] < t {
                l = mid + 1
            } else {
                r = mid
            }
        }
        if idx == -1 {
            idx = l >= times.count ? l - 1 : times[l] > t ? l - 1 : l
        }
        return maxes[idx]
    }
}

---

1756ms

class TopVotedCandidate {
    var dict: [Int: Int]
    let times: [Int]
    init(_ persons: [Int], _ times: [Int]) {
        self.times = times
        var m = -1
        var leading = -1
        var d = [Int: Int]()
        dict = [Int: Int]()
        for (i ,t) in times.enumerated() {
            d[persons[i], default: 0] += 1
            if let value = d[persons[i]], value >= m {
                m = value
                leading = persons[i]
                dict[t] = persons[i]
            } else {
                dict[t] = leading
            }
        }
    }
    
    func q(_ t: Int) -> Int {
        var low = 0
        var high = times.count-1
        while low <= high {
            let middle = (low + high) / 2
            if times[middle] == t {
                return dict[times[middle]]!
            } else if times[middle] > t {
                high = middle - 1
            } else {
                low = middle + 1
            }
        }
        return dict[times[low-1]]!
    }
}