LeetCode第103场周赛题解

908. 最小差值 I

题目难度Easy

给定一个整数数组 A，对于每个整数 A[i]，我们可以选择任意 x 满足 -K <= x <= K，并将 x 加到 A[i] 中。

在此过程之后，我们得到一些数组 B。

返回 B 的最大值和 B 的最小值之间可能存在的最小差值。

示例 1：

输入：A = [1], K = 0
输出：0
解释：B = [1]

示例 2：

输入：A = [0,10], K = 2
输出：6
解释：B = [2,8]

示例 3：

输入：A = [1,3,6], K = 3
输出：0
解释：B = [3,3,3] 或 B = [4,4,4]

提示：

1 <= A.length <= 10000
0 <= A[i] <= 10000
0 <= K <= 10000

思路：

求数组中的最小值与最大值：如果他们之间的差小于等于2*K，那么数组中的所有数都可以通过加上一个在[-K, K]之间的数来达到(min(A)+max(A))//2；如果他们之间的差大于2*K，那么处理后的数组差值最小只能达到max(A)-min(A)-2*K。

时间复杂度 $O(N)$

空间复杂度 $O(1)$

代码：

class Solution:
    def smallestRangeI(self, A, K):
        """
        :type A: List[int]
        :type K: int
        :rtype: int
        """
        a = max(A)
        b = min(A)
        if (a-b>2*K):
            return a-b-2*K
        else:
            return 0

909. 蛇梯棋

题目难度Medium

在一块 N x N 的棋盘 board 上，从棋盘的左下角开始，每一行交替方向，按从 1 到 N*N 的数字给方格编号。例如，对于一块 6 x 6 大小的棋盘，可以编号如下：

棋盘示例

玩家从棋盘上的方格 1 （总是在最后一行、第一列）开始出发。

每一次从方格 x 起始的移动都由以下部分组成：

你选择一个目标方块 S，它的编号是 x+1，x+2，x+3，x+4，x+5，或者 x+6，只要这个数字 <= N*N。
如果 S 有一个蛇或梯子，你就移动到那个蛇或梯子的目的地。否则，你会移动到 S。

在 r 行 c 列上的方格里有 “蛇” 或 “梯子”；如果 board[r][c] != -1，那个蛇或梯子的目的地将会是 board[r][c]。

注意，你每次移动最多只能爬过蛇或梯子一次：就算目的地是另一条蛇或梯子的起点，你也不会继续移动。

返回达到方格 N*N 所需的最少移动次数，如果不可能，则返回 -1。

示例：

输入：[
[-1,-1,-1,-1,-1,-1],
[-1,-1,-1,-1,-1,-1],
[-1,-1,-1,-1,-1,-1],
[-1,35,-1,-1,13,-1],
[-1,-1,-1,-1,-1,-1],
[-1,15,-1,-1,-1,-1]]
输出：4
解释：
首先，从方格 1 [第 5 行，第 0 列] 开始。
你决定移动到方格 2，并必须爬过梯子移动到到方格 15。
然后你决定移动到方格 17 [第 3 行，第 5 列]，必须爬过蛇到方格 13。
然后你决定移动到方格 14，且必须通过梯子移动到方格 35。
然后你决定移动到方格 36, 游戏结束。
可以证明你需要至少 4 次移动才能到达第 N*N 个方格，所以答案是 4。

提示：

2 <= board.length = board[0].length <= 20
board[i][j] 介于 1 和 N*N 之间或者等于 -1。
编号为 1 的方格上没有蛇或梯子。
编号为 N*N 的方格上没有蛇或梯子。

思路：

题目要求最小步数，所以用宽度优先搜索（Breadth First Search，BFS）来解决这个问题比较好，我们注意，路径中可能出现回路，但是出现回路肯定不是最优解，所以我们在搜索过程中，可以把搜索过的格子标记为0，那么在下一层搜索过程中，只需要搜索值为-1或者大于0的格子即可。在搜索之前，我们可以将二维数组变为一位数组来简化搜索过程。

时间复杂度 $O(N^2)$

空间复杂度 $O(N^2)$

代码：

class Solution:
    def snakesAndLadders(self, board):
        """
        :type board: List[List[int]]
        :rtype: int
        """
        n = len(board)
        road = []
        i = n - 1
        flg = True
        while i >= 0:
            if flg:
                road += board[i]
            else:
                road += board[i][::-1]
            flg = not flg
            i -= 1
        # print(road)
        l = n * n
        ans = 0
        queue = [0]
        while queue:
            # print(queue)
            ans += 1
            if ans >= l:
                return -1
            tmp = []
            while queue:
                p = queue.pop(0)
                for i in range(1, 7):
                    next_p = p + i
                    if next_p == l - 1:
                        return ans
                    if road[next_p] > 0:
                        jump = road[next_p] - 1
                        if jump == l - 1:
                            return ans
                        # 走过梯子或蛇了
                        road[next_p] = 0
                        tmp.append(jump)
                    elif road[next_p] == -1:
                        tmp.append(next_p)
                        road[next_p] = 0
            queue = tmp
        return -1

910. 最小差值 II

题目难度Medium

给定一个整数数组 A，对于每个整数 A[i]，我们可以选择 x = -K 或是 x = K，并将 x 加到 A[i] 中。

在此过程之后，我们得到一些数组 B。

返回 B 的最大值和 B 的最小值之间可能存在的最小差值。

示例 1：

输入：A = [1], K = 0
输出：0
解释：B = [1]

示例 2：

输入：A = [0,10], K = 2
输出：6
解释：B = [2,8]

示例 3：

输入：A = [1,3,6], K = 3
输出：3
解释：B = [4,6,3]

提示：

1 <= A.length <= 10000
0 <= A[i] <= 10000
0 <= K <= 10000

思路：

为了生成数组B，将数组升序排序后，我们需要找到数组中的一个数，小于等于这个数都加上K，大于这个数都减去K，设这个数是第i个数，那么输出的结果为max(A[len(A)-1]-K,A[i]+K)-min(A[0]+K,A[i+1]-K)。

时间复杂度 $O(logN)$

空间复杂度 $O(1)$

代码：

class Solution:
    def smallestRangeII(self, A, K):
        """
        :type A: List[int]
        :type K: int
        :rtype: int
        """
        l = len(A)
        if l <= 1:
            return 0
        A.sort()
        ans = A[l - 1] - A[0]
        for i in range(l - 1):
            ma = max(A[i] + K, A[l - 1] - K)
            mi = min(A[i + 1] - K, A[0] + K)
            ans = min(ans, ma - mi)
        return ans

911. 在线选举

题目难度Medium

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

思路：

以给的投票时间序列times为索引，记录每次投票后的胜出候选人，在查询的时候采用二分法即可在对数时间内返回正确结果。计算胜出候选人的时候，用hashmap记录每个候选人的票数，并用变量记录当前优胜者和最大票数，如果投票后，当前投给的候选人票数大于等于当前优胜者的票数，那么替换当前优胜者和最大票数。

构造时间复杂度 $O(N)$ 查询时间复杂度 $O(logN)$

空间复杂度 $O(N)$

代码：

class TopVotedCandidate:

    def __init__(self, persons, times):
        """
        :type persons: List[int]
        :type times: List[int]
        """
        l = len(times)
        self.t = times
        self.winner = [persons[0]] * l
        d = dict()
        winner_bynow = persons[0]
        max_ticket = 1
        d[persons[0]] = 1
        for i in range(1, l):
            if persons[i] in d:
                d[persons[i]] += 1
            else:
                d[persons[i]] = 1
            if d[persons[i]] >= max_ticket:
                winner_bynow = persons[i]
                max_ticket = d[persons[i]]
            self.winner[i] = winner_bynow
            
    def q(self, t):
        """
        :type t: int
        :rtype: int
        """
        index = bisect.bisect(self.t, t) - 1
        return self.winner[index]


# Your TopVotedCandidate object will be instantiated and called as such:
# obj = TopVotedCandidate(persons, times)
# param_1 = obj.q(t)