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 <= 100000 <= A[i] <= 100000 <= K <= 10000
思路：
求数组中的最小值与最大值：如果他们之间的差小于等于2*K，那么数组中的所有数都可以通过加上一个在[-K, K]之间的数来达到(min(A)+max(A))//2；如果他们之间的差大于2*K，那么处理后的数组差值最小只能达到max(A)-min(A)-2*K。
时间复杂度
空间复杂度
代码：
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的格子即可。在搜索之前，我们可以将二维数组变为一位数组来简化搜索过程。
时间复杂度
空间复杂度
代码：
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 <= 100000 <= A[i] <= 100000 <= K <= 10000
思路：
为了生成数组B，将数组升序排序后，我们需要找到数组中的一个数，小于等于这个数都加上K，大于这个数都减去K，设这个数是第i个数，那么输出的结果为max(A[len(A)-1]-K,A[i]+K)-min(A[0]+K,A[i+1]-K)。
时间复杂度
空间复杂度
代码：
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 <= 50000 <= persons[i] <= persons.length-
times是严格递增的数组，所有元素都在[0, 10^9]范围中。 - 每个测试用例最多调用
10000次TopVotedCandidate.q。 -
TopVotedCandidate.q(int t)被调用时总是满足t >= times[0]。
思路：
以给的投票时间序列times为索引，记录每次投票后的胜出候选人，在查询的时候采用二分法即可在对数时间内返回正确结果。计算胜出候选人的时候，用hashmap记录每个候选人的票数，并用变量记录当前优胜者和最大票数，如果投票后，当前投给的候选人票数大于等于当前优胜者的票数，那么替换当前优胜者和最大票数。
构造时间复杂度 查询时间复杂度
空间复杂度
代码：
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)
网友评论