二、中等
339、嵌套列表权重和
给定一个嵌套的整数列表 nestedList ，每个元素要么是整数，要么是列表。同时，列表中元素同样也可以是整数或者是另一个列表。
整数的 深度 是其在列表内部的嵌套层数。例如，嵌套列表 [1,[2,2],[[3],2],1] 中每个整数的值就是其深度。
请返回该列表按深度加权后所有整数的总和。
链接：https://leetcode.cn/problems/nested-list-weight-sum
# """
# This is the interface that allows for creating nested lists.
# You should not implement it, or speculate about its implementation
# """
#class NestedInteger:
# def __init__(self, value=None):
# """
# If value is not specified, initializes an empty list.
# Otherwise initializes a single integer equal to value.
# """
#
# def isInteger(self):
# """
# @return True if this NestedInteger holds a single integer, rather than a nested list.
# :rtype bool
# """
#
# def add(self, elem):
# """
# Set this NestedInteger to hold a nested list and adds a nested integer elem to it.
# :rtype void
# """
#
# def setInteger(self, value):
# """
# Set this NestedInteger to hold a single integer equal to value.
# :rtype void
# """
#
# def getInteger(self):
# """
# @return the single integer that this NestedInteger holds, if it holds a single integer
# Return None if this NestedInteger holds a nested list
# :rtype int
# """
#
# def getList(self):
# """
# @return the nested list that this NestedInteger holds, if it holds a nested list
# Return None if this NestedInteger holds a single integer
# :rtype List[NestedInteger]
# """
class Solution:
def depthSum(self, nestedList: List[NestedInteger]) -> int:
dic1 = []
dic2 = []
def dfs(l, depth):
for x in l:
if x.isInteger():
dic1.append(x.getInteger())
dic2.append(depth)
else:
dfs(x.getList(), depth+1)
dfs(nestedList, 1)
ans = 0
for x, y in zip(dic1, dic2):
ans += (x*y)
return ans
348、设计井字棋
请在 n × n 的棋盘上，实现一个判定井字棋（Tic-Tac-Toe）胜负的神器，判断每一次玩家落子后，是否有胜出的玩家。
在这个井字棋游戏中，会有 2 名玩家，他们将轮流在棋盘上放置自己的棋子。
在实现这个判定器的过程中，你可以假设以下这些规则一定成立：
1. 每一步棋都是在棋盘内的，并且只能被放置在一个空的格子里；
2. 一旦游戏中有一名玩家胜出的话，游戏将不能再继续；
3. 一个玩家如果在同一行、同一列或者同一斜对角线上都放置了自己的棋子，那么他便获得胜利。
链接：https://leetcode.cn/problems/design-tic-tac-toe
class TicTacToe:
def __init__(self, n: int):
# inf = 2*31 - 1
self.keyboard = [['' for _ in range(n)] for _ in range(n)]
self.n = n
self.dic1_r = defaultdict(int)
self.dic1_c = defaultdict(int)
self.dic1_w = 0
self.dic1_u = 0
self.dic2_r = defaultdict(int)
self.dic2_c = defaultdict(int)
self.dic2_w = 0
self.dic2_u = 0
def move(self, row: int, col: int, player: int) -> int:
if player == 1:
self.keyboard[row][col] = 'X'
self.dic1_r[row] += 1
self.dic1_c[col] += 1
if row == col:
self.dic1_w+=1
if row == self.n-col-1:
self.dic1_u+=1
if self.dic1_r[row] == self.n or self.dic1_c[col] == self.n:
return 1
if self.dic1_w==self.n or self.dic1_u == self.n:
return 1
return 0
else:
self.keyboard[row][col] = 'O'
self.dic2_r[row] += 1
self.dic2_c[col] += 1
if row == col:
self.dic2_w+=1
if row == self.n-col-1:
self.dic2_u+=1
if self.dic2_r[row] == self.n or self.dic2_c[col] == self.n:
return 2
if self.dic2_w==self.n or self.dic2_u == self.n:
return 2
return 0
return 0
# Your TicTacToe object will be instantiated and called as such:
# obj = TicTacToe(n)
# param_1 = obj.move(row,col,player)
360、有序转化数组
给你一个已经 排好序 的整数数组 nums 和整数 a 、 b 、 c 。对于数组中的每一个元素 nums[i] ，计算函数值 f(x) = ax2 + bx + c ，请 按升序返回数组 。
链接：https://leetcode.cn/problems/sort-transformed-array
class Solution:
def sortTransformedArray(self, nums: List[int], a: int, b: int, c: int) -> List[int]:
ans = []
### 一元一次方程
if a == 0:
for i,x in enumerate(nums):
tmp = a*(x**2) + b*x + c
ans.append(tmp)
if b>0:
return ans
### 常数
elif b==0:
return [c]*len(nums)
else:
return ans[::-1]
l = -(b/(2*a))
idx = -1
minm = float("inf")
for i,x in enumerate(nums):
if abs(x-l) < minm:
idx = i
minm = abs(x-l)
left, right = idx-1, idx+1
while left >= 0 and right <= len(nums)-1:
tmp = a*(nums[idx]**2) + b*nums[idx] + c
ans.append(tmp)
if abs(nums[left]-l) > abs(nums[right]-l):
idx = right
right += 1
else:
idx = left
left -= 1
tmp = a*(nums[idx]**2) + b*nums[idx] + c
ans.append(tmp)
if left != -1:
for i in range(left,-1,-1):
tmp = a*(nums[i]**2) + b*nums[i] + c
ans.append(tmp)
if right != len(nums) :
for i in range(right, len(nums)):
tmp = a*(nums[i]**2) + b*nums[i] + c
ans.append(tmp)
if a>0:
return ans
else:
return ans[::-1]
362、敲击计数器
设计一个敲击计数器，使它可以统计在过去 5 分钟内被敲击次数。（即过去 300 秒）
您的系统应该接受一个时间戳参数 timestamp (单位为 秒 )，并且您可以假定对系统的调用是按时间顺序进行的(即 timestamp 是单调递增的)。几次撞击可能同时发生。
实现 HitCounter 类:
HitCounter() 初始化命中计数器系统。
void hit(int timestamp) 记录在 timestamp ( 单位为秒 )发生的一次命中。在同一个 timestamp 中可能会出现几个点击。
int getHits(int timestamp) 返回 timestamp 在过去 5 分钟内(即过去 300 秒)的命中次数。
链接：https://leetcode.cn/problems/design-hit-counter
class HitCounter:
def __init__(self):
self.times = defaultdict(int)
self.time = []
self.left = 0
self.right = 0
def hit(self, timestamp: int) -> None:
if timestamp not in self.time:
self.time.append(timestamp)
while timestamp - self.time[self.left] >= 300:
self.left += 1
self.times[timestamp] += 1
def getHits(self, timestamp: int) -> int:
print(self.left, self.time)
if timestamp not in self.time:
while self.left<len(self.time) and timestamp - self.time[self.left] >= 300:
self.left += 1
ans = 0
for i in range(self.left, len(self.time)):
ans += self.times[self.time[i]]
return ans
# Your HitCounter object will be instantiated and called as such:
# obj = HitCounter()
# obj.hit(timestamp)
# param_2 = obj.getHits(timestamp)
361、轰炸敌人
给你一个大小为 m x n 的矩阵 grid ，其中每个单元格都放置有一个字符：
'W' 表示一堵墙
'E' 表示一个敌人
'0'（数字 0）表示一个空位
返回你使用 一颗炸弹 可以击杀的最大敌人数目。你只能把炸弹放在一个空位里。
由于炸弹的威力不足以穿透墙体，炸弹只能击杀同一行和同一列没被墙体挡住的敌人。
链接：https://leetcode.cn/problems/bomb-enemy
class Solution:
def maxKilledEnemies(self, grid: List[List[str]]) -> int:
m, n = len(grid), len(grid[0])
self.res = 0
### 超时
# for i in range(m):
# for j in range(n):
# if grid[i][j] == '0':
# pathway = [(1,0),(0,1),(-1,0),(0,-1)]
# num = 0
# for k in range(4):
# dr, dc = pathway[k]
# nr, nc = i+dr, j+dc
# while 0<=nr<m and 0<=nc<n and grid[nr][nc]!='W':
# if grid[nr][nc] == 'E':
# num+=1
# nr += dr
# nc += dc
# self.res = max(self.res, num)
# return self.res
f_r = [[-1 for _ in range(n)] for _ in range(m)]
f_c = [[-1 for _ in range(n)] for _ in range(m)]
for i in range(m):
for j in range(n):
if grid[i][j] == '0':
if i==0 or f_r[i-1][j]==-1:
pathway = [(1,0),(-1,0)]
num = 0
for k in range(2):
dr, dc = pathway[k]
nr, nc = i+dr, j+dc
while 0<=nr<m and 0<=nc<n and grid[nr][nc]!='W':
if grid[nr][nc] == 'E':
num+=1
nr += dr
nc += dc
f_r[i][j] = num
else:
f_r[i][j] = f_r[i-1][j]
if j==0 or f_c[i][j-1] == -1:
pathway = [(0,1),(0,-1)]
num = 0
for k in range(2):
dr, dc = pathway[k]
nr, nc = i+dr, j+dc
while 0<=nr<m and 0<=nc<n and grid[nr][nc]!='W':
if grid[nr][nc] == 'E':
num+=1
nr += dr
nc += dc
f_c[i][j] = num
else:
f_c[i][j] = f_c[i][j-1]
self.res = max(self.res, f_r[i][j]+f_c[i][j])
return self.res
364、加权嵌套序列和二
给你一个整数嵌套列表 nestedList ，每一个元素要么是一个整数，要么是一个列表（这个列表中的每个元素也同样是整数或列表）。
整数的 深度 取决于它位于多少个列表内部。例如，嵌套列表 [1,[2,2],[[3],2],1] 的每个整数的值都等于它的 深度 。令 maxDepth 是任意整数的 最大深度 。
整数的 权重 为 maxDepth - (整数的深度) + 1 。
将 nestedList 列表中每个整数先乘权重再求和，返回该加权和。
链接：https://leetcode.cn/problems/nested-list-weight-sum-ii
# """
# This is the interface that allows for creating nested lists.
# You should not implement it, or speculate about its implementation
# """
#class NestedInteger:
# def __init__(self, value=None):
# """
# If value is not specified, initializes an empty list.
# Otherwise initializes a single integer equal to value.
# """
#
# def isInteger(self):
# """
# @return True if this NestedInteger holds a single integer, rather than a nested list.
# :rtype bool
# """
#
# def add(self, elem):
# """
# Set this NestedInteger to hold a nested list and adds a nested integer elem to it.
# :rtype void
# """
#
# def setInteger(self, value):
# """
# Set this NestedInteger to hold a single integer equal to value.
# :rtype void
# """
#
# def getInteger(self):
# """
# @return the single integer that this NestedInteger holds, if it holds a single integer
# Return None if this NestedInteger holds a nested list
# :rtype int
# """
#
# def getList(self):
# """
# @return the nested list that this NestedInteger holds, if it holds a nested list
# Return None if this NestedInteger holds a single integer
# :rtype List[NestedInteger]
# """
class Solution:
def depthSumInverse(self, nestedList: List[NestedInteger]) -> int:
self.depth = []
self.nums = []
def dfs(i, x, dist):
l = x.getList()
for j,y in enumerate(l):
if y.isInteger():
self.depth.append(dist)
self.nums.append(y.getInteger())
elif y.getList() == []:
self.depth.append(dist)
self.nums.append(0)
else:
dfs(i+j, y, dist+1)
for i,x in enumerate(nestedList):
dp = 1
if not x.isInteger():
# if x.getList() != []:
dfs(i, x, dp+1)
else:
self.depth.append(dp)
self.nums.append(x.getInteger())
if self.depth == []: return 0
max_depth = max(self.depth)
res = 0
for i in range(len(self.depth)):
res += (max_depth-self.depth[i]+1)*self.nums[i]
print(self.depth, self.nums)
return res
379、电话目录管理系统
设计一个电话目录管理系统，让它支持以下功能：
get: 分配给用户一个未被使用的电话号码，获取失败请返回 -1 check: 检查指定的电话号码是否被使用 release:
释放掉一个电话号码，使其能够重新被分配
链接：https://leetcode.cn/problems/design-phone-directory
class PhoneDirectory:
def __init__(self, maxNumbers: int):
self.dic = defaultdict(int)
for i in range(maxNumbers):
self.dic[i] = 0
def get(self) -> int:
for k, v in self.dic.items():
if v == 0:
self.dic[k] = 1
return k
return -1
def check(self, number: int) -> bool:
if self.dic[number]==0:
return True
else:
return False
def release(self, number: int) -> None:
self.dic[number] = 0
# Your PhoneDirectory object will be instantiated and called as such:
# obj = PhoneDirectory(maxNumbers)
# param_1 = obj.get()
# param_2 = obj.check(number)
# obj.release(number)
356、直线镜像
在一个二维平面空间中，给你 n 个点的坐标。问，是否能找出一条平行于 y 轴的直线，让这些点关于这条直线成镜像排布？
注意：题目数据中可能有重复的点。
class Solution:
def isReflected(self, points: List[List[int]]) -> bool:
def sorted_cmp(l1, l2):
if l1[0] > l2[0]:
return 1
elif l1[0] == l2[0]:
if l1[1] > l2[1]:
return 1
else:
return -1
else:
return -1
points.sort(key = cmp_to_key(sorted_cmp))
arr = []
for k in points:
if k not in arr:
arr.append(k)
points = arr
if len(points)%2 == 0:
x = 0
for l in points:
x += l[0]
x = x/len(points)
i, j = 0, len(points)//2
flag = True
while i < (len(points)//2) and j < (len(points)):
# print(i, j, points, x)
if points[i][0] == points[j][0] == x:
flag = True
elif points[i][1] != points[j][1] or x-points[i][0] != points[j][0]-x:
flag = False
break
i+=1
j+=1
if flag:
return True
flag = True
i, j = 0, len(points)-1
while i < (len(points)//2) and j > (len(points)//2 -1):
# print(flag, points, x)
if points[i][0] == points[j][0] == x:
flag = True
elif points[i][1] != points[j][1] or x-points[i][0] != points[j][0]-x:
flag = False
break
i+=1
j-=1
if flag:
return True
return False
else:
x = points[len(points)//2][0]
i, j = 0, len(points)//2+1
flag = True
while i < (len(points)//2) and j < (len(points)):
if points[i][0] == points[j][0] == x:
flag = True
elif points[i][1] != points[j][1] or x-points[i][0] != points[j][0]-x:
flag = False
break
i+=1
j+=1
if flag:
return True
flag = True
i, j = 0, len(points)-1
while i < (len(points)//2) and j > (len(points)//2):
if points[i][0] == points[j][0] == x:
flag = True
elif points[i][1] != points[j][1] or x-points[i][0] != points[j][0]-x:
flag = False
break
i+=1
j-=1
if flag:
return True
return False
351、安卓系统手势解锁
class Solution:
def numberOfPatterns(self, m: int, n: int) -> int:
dic = {
1 : {3,7,9},
2 : {8},
3 : {1,9,7},
4 : {6},
5 : {},
6 : {4},
7 : {1, 9, 3},
8 : {2},
9 : {3, 7, 1}
}
self.res = 0
visited = [False for _ in range(9)]
def check(arr):
if len(arr) == 1:
return True
for i in range(0,len(arr)-1):
x = arr[i]
y = arr[i+1]
if y in dic[x]:
mid = (x + y)//2
if mid not in arr[:i]:
return False
return True
def backtrace(x, path):
if x>=n+1:
return
if not check(path):
return
if x>=m and x<=n:
self.res += 1
for i in range(9):
if not visited[i]:
visited[i] = True
backtrace(x+1, path+[i+1])
visited[i] = False
for i in range(9):
visited[i] = True
backtrace(1, [i+1])
visited[i] = False
return self.res
549、二叉树中最长的连续序列
给定二叉树的根 root ，返回树中最长连续路径的长度。
连续路径是路径中相邻节点的值相差 1 的路径。此路径可以是增加或减少。
例如， [1,2,3,4] 和 [4,3,2,1] 都被认为有效，但路径 [1,2,4,3] 无效。
另一方面，路径可以是子-父-子顺序，不一定是父子顺序。
链接：https://leetcode.cn/problems/binary-tree-longest-consecutive-sequence-ii
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def longestConsecutive(self, root: Optional[TreeNode]) -> int:
if not root: return 0
self.res = 1
def dfs(root):
if not root: return (0, 0)
left, right = dfs(root.left), dfs(root.right)
inc = dec = 1
if root.left:
if root.left.val == root.val + 1:
inc += left[0]
elif root.left.val == root.val - 1:
dec += left[1]
if root.right:
if root.right.val == root.val + 1:
inc = max(inc, right[0] + 1)
elif root.right.val == root.val - 1:
dec = max(dec, right[1] + 1)
self.res = max(self.res, inc + dec - 1)
return (inc, dec)
dfs(root)
return self.res
510、二叉搜索树中的中序后继
给定一棵二叉搜索树和其中的一个节点 node ，找到该节点在树中的中序后继。如果节点没有中序后继，请返回 null 。
一个节点 node 的中序后继是键值比 node.val 大所有的节点中键值最小的那个。
你可以直接访问结点，但无法直接访问树。每个节点都会有其父节点的引用。节点 Node 定义如下：
class Node {
public int val;
public Node left;
public Node right;
public Node parent;
}
链接：https://leetcode.cn/problems/inorder-successor-in-bst-ii
"""
# Definition for a Node.
class Node:
def __init__(self, val):
self.val = val
self.left = None
self.right = None
self.parent = None
"""
class Solution:
def inorderSuccessor(self, node: 'Node') -> 'Optional[Node]':
###两种情况
if node.right:
node = node.right
while node.left:
node = node.left
return node
while node.parent and node == node.parent.right:
node = node.parent
return node.parent
487、最大连续1的个数二
给定一个二进制数组 nums ，如果最多可以翻转一个 0 ，则返回数组中连续 1 的最大个数。
class Solution:
def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
f = [[0,0] for _ in range(len(nums))]
if nums[0] == 1:
f[0][1] = 1
f[0][0] = 0
else:
f[0][1] = 0
f[0][0] = 1
idx = 1
res = 1
while idx < len(nums):
if nums[idx]==1:
f[idx][0] = f[idx-1][0] + 1
f[idx][1] = f[idx-1][1] + 1
if nums[idx] == 0:
f[idx][0] = f[idx-1][1] + 1
f[idx][1] = 0
res = max(res,f[idx][0],f[idx][1])
idx += 1
return res
439、三元表达式解析器
给定一个表示任意嵌套三元表达式的字符串 expression ，求值并返回其结果。
你可以总是假设给定的表达式是有效的，并且只包含数字， ‘?’ ， ‘:’ ， ‘T’ 和 ‘F’ ，其中 ‘T’ 为真， ‘F’ 为假。表达式中的所有数字都是 一位 数(即在 [0,9] 范围内)。
条件表达式从右到左分组(大多数语言中都是这样)，表达式的结果总是为数字 ‘T’ 或 ‘F’ 。
链接：https://leetcode.cn/problems/ternary-expression-parser
class Solution:
def parseTernary(self, expression: str) -> str:
st = []
is_flag = False
for i in range(len(expression)-1, -1, -1):
if expression[i] == ':':
continue
elif expression[i] == '?':
is_flag = True
else:
if is_flag:
if expression[i] == 'T':
res = st[-1]
st.pop()
st.pop()
st.append(res)
else:
st.pop()
is_flag = False
else:
st.append(expression[i])
return st[0]
544、输出比赛匹配对
在 NBA 季后赛中，我们总是安排较强的队伍对战较弱的队伍，例如用排名第 1 的队伍和第 n 的队伍对决，这是一个可以让比赛更加有趣的好策略。现在，给你 n 支队伍，你需要以字符串格式输出它们的 最终 比赛配对。
n 支队伍按从 1 到 n 的正整数格式给出，分别代表它们的初始排名（排名 1 最强，排名 n 最弱）。我们用括号（‘(’, ‘)’）和逗号（‘,’）来表示匹配对——括号（‘(’, ‘)’）表示匹配，逗号（‘,’）来用于分割。 在每一轮的匹配过程中，你都需要遵循将强队与弱队配对的原则。
链接：https://leetcode.cn/problems/output-contest-matches
class Solution(object):
def findContestMatch(self, n):
team = [str(x) for x in range(1, n + 1)]
while n > 1:
for i in range(n // 2):
team[i] = "({},{})".format(team[i], team[n-i-1])
n //= 2
return team[0]
484、寻找排列
由范围 [1,n] 内所有整数组成的 n 个整数的排列 perm 可以表示为长度为 n - 1 的字符串 s ，其中:
如果 perm[i] < perm[i + 1] ，那么 s[i] == ’ i ’
如果 perm[i] > perm[i + 1] ，那么 s[i] == ‘D’ 。
给定一个字符串 s ，重构字典序上最小的排列 perm 并返回它。
链接：https://leetcode.cn/problems/find-permutation
class Solution:
def findPermutation(self, s: str) -> List[int]:
### DFS
# n = len(s) + 1
# self.res = []
# visited = [False for _ in range(n)]
# def dfs(arr, idx):
# if self.res != []:
# return
# if len(arr)==n:
# self.res = (arr)
# return
# if idx >= n-1:
# return
# for x in range(1,n+1):
# if s[idx] == 'I' and not visited[x-1] and x>(arr[-1]):
# visited[x-1] = True
# dfs(arr+[(x)], idx+1)
# visited[x-1] = False
# if s[idx] == 'D' and not visited[x-1] and x<(arr[-1]):
# visited[x-1] = True
# dfs(arr+[(x)], idx+1)
# visited[x-1] = False
# for i in range(1, n+1):
# visited[i-1] = True
# dfs([(i)], 0)
# if self.res != []:
# break
# visited[i-1] = False
# return (self.res)
### dp 不超时
n = len(s)
nums = list(range(1, n+2))
pre = s[0]
cnt = 1
for i in range(1, n):
if pre == s[i]:
cnt += 1
else:
if pre == 'D':
nums[i-cnt:i+1] = nums[i-cnt:i+1][::-1]
pre = s[i]
cnt = 1
if pre == 'D':
nums[n-cnt:n+1] = nums[n-cnt:n+1][::-1]
return nums
555、分割连接字符串
给定一个字符串列表 strs，你可以将这些字符串连接成一个循环字符串，对于每个字符串，你可以选择是否翻转它。在所有可能的循环字符串中，你需要分割循环字符串（这将使循环字符串变成一个常规的字符串），然后找到字典序最大的字符串。
具体来说，要找到字典序最大的字符串，你需要经历两个阶段：
将所有字符串连接成一个循环字符串，你可以选择是否翻转某些字符串，并按照给定的顺序连接它们。
在循环字符串的某个位置分割它，这将使循环字符串从分割点变成一个常规的字符串。
你的工作是在所有可能的常规字符串中找到字典序最大的一个。
链接：https://leetcode.cn/problems/split-concatenated-strings
class Solution:
def splitLoopedString(self, strs: List[str]) -> str:
### Limted time exceed
# arr = []
# res = ''
# for s in strs:
# tmp = arr
# arr = []
# s1 = s
# s2 = s[::-1]
# if tmp == []:
# arr = [s1,s2]
# else:
# for x in tmp:
# arr.append(x+s1)
# arr.append(x+s2)
# for x in arr:
# for i in range(len(x)):
# res = max(res, x[i:] + x[:i])
# return (res)
####
arr = [s if s>s[::-1] else s[::-1] for s in strs]
res = ''.join(arr)
for i in range(len(arr)):
other = ''.join(arr[i+1:]) + ''.join(arr[:i])
for j in range(len(arr[i])):
head = arr[i][:j]
tail = arr[i][j:]
cur = tail + other + head
res = max(cur, res)
cur = head[::-1] + other + tail[::-1]
res = max(cur, res)
return res
573、松鼠模拟
现在有一棵树，一只松鼠和一些坚果。位置由二维网格的单元格表示。你的目标是找到松鼠收集所有坚果的最小路程，且坚果是一颗接一颗地被放在树下。松鼠一次最多只能携带一颗坚果，松鼠可以向上，向下，向左和向右四个方向移动到相邻的单元格。移动次数表示路程。
链接：https://leetcode.cn/problems/squirrel-simulation
class Solution:
def minDistance(self, height: int, width: int, tree: List[int], squirrel: List[int], nuts: List[List[int]]) -> int:
path = float('inf')
x, y = squirrel
x_t, y_t = tree
path_t = 0
for i, j in nuts:
cur = abs(i-x_t) + abs(j-y_t)
path_t += cur*2
for i,j in nuts:
cur = path_t - (abs(i-x_t) + abs(j-y_t)) + (abs(i-x) + abs(j-y))
path = min(path, cur)
return path
634、寻找数组的错位排序
在组合数学中，如果一个排列中所有元素都不在原先的位置上，那么这个排列就被称为 错位排列 。
给定一个从 1 到 n 升序排列的数组，返回 不同的错位排列 的数量 。由于答案可能非常大，你只需要将答案对 109+7 取余 输出即可。
链接：https://leetcode.cn/problems/find-the-derangement-of-an-array
class Solution:
def findDerangement(self, n: int) -> int:
f = [0 for _ in range(n+1)]
f[0] = 0
f[1] = 1
for i in range(2, n+1):
f[i] = (i)*(f[i-1] + f[i-2]) % 1000000007
return f[n-1]
1057、校园自行车分配
在 X-Y 平面上表示的校园中，有 n 名工人和 m 辆自行车，其中 n <= m。
给定一个长度为 n 的数组 workers ，其中 worker [i] = [xi, yi] 表示第 i 个工人的位置。你也得到一个长度为 m 的自行车数组 bikers ，其中 bikes[j] = [xj, yj] 是第 j 辆自行车的位置。所有给定的位置都是 唯一 的。
我们需要为每位工人分配一辆自行车。在所有可用的自行车和工人中，我们选取彼此之间 曼哈顿距离 最短的工人自行车对 (workeri, bikej) ，并将其中的自行车分配給工人。
如果有多个 (workeri, bikej) 对之间的 曼哈顿距离 相同，那么我们选择 工人索引最小 的那对。类似地，如果有多种不同的分配方法，则选择 自行车索引最小 的一对。不断重复这一过程，直到所有工人都分配到自行车为止。
返回长度为 n 的向量 answer，其中 answer[i] 是第 i 位工人分配到的自行车的索引（从 0 开始）。
给定两点 p1 和 p2 之间的 曼哈顿距离 为 Manhattan(p1, p2) = |p1.x - p2.x| + |p1.y - p2.y|。
链接：https://leetcode.cn/problems/campus-bikes
class Solution:
def assignBikes(self, workers: List[List[int]], bikes: List[List[int]]) -> List[int]:
def Manhattan(p1, p2):
return abs(p1[0]-p2[0])+abs(p1[1]-p2[1])
from sortedcontainers import SortedDict as SD
dic = SD()
for i,b in enumerate(workers):
for j,w in enumerate(bikes):
dist = Manhattan(b, w)
if dist not in dic:
dic[dist] = [(i,j)]
else:
dic[dist].append((i, j))
res = [0 for _ in range(len(workers))]
visited_b = [False for _ in range(len(bikes))]
visited_w = [False for _ in range(len(workers))]
cnt = 0
for k, v in dic.items():
for x in v:
i, j = x
if not visited_w[i] and not visited_b[j]:
visited_w[i] = True
visited_b[j] = True
res[i] = j
cnt+=1
if cnt == len(workers):
break
return res
505、迷宫二
由空地和墙组成的迷宫中有一个球。球可以向上下左右四个方向滚动，但在遇到墙壁前不会停止滚动。当球停下时，可以选择下一个方向。
给定球的起始位置，目的地和迷宫，找出让球停在目的地的最短距离。距离的定义是球从起始位置（不包括）到目的地（包括）经过的空地个数。如果球无法停在目的地，返回 -1。
迷宫由一个0和1的二维数组表示。 1表示墙壁，0表示空地。你可以假定迷宫的边缘都是墙壁。起始位置和目的地的坐标通过行号和列号给出。
链接：https://leetcode.cn/problems/the-maze-ii
class Solution:
def shortestDistance(self, maze: List[List[int]], start: List[int], destination: List[int]) -> int:
queue = [(start[0], start[1])]
m, n = len(maze), len(maze[0])
dist = [[float('inf') for _ in range(n)]for _ in range(m)]
dist[start[0]][start[1]] = 0
while queue:
cur_i, cur_j = queue.pop(0)
print(cur_i, cur_j)
pathway = [(1,0),(-1,0),(0,1),(0,-1)]
for i in range(4):
dr, dc = pathway[i]
nr, nc = cur_i+dr, cur_j+dc
step = 1
while 0<=nr<m and 0<=nc<n and maze[nr][nc]==0:
nr += dr
nc += dc
step += 1
nr -= dr
nc -= dc
step -= 1
if dist[nr][nc]>dist[cur_i][cur_j]+step:
dist[nr][nc] = dist[cur_i][cur_j]+step
queue.append((nr, nc))
if dist[destination[0]][destination[1]] == float('inf'):
return -1
else:
return dist[destination[0]][destination[1]]
533、孤独像素二
给你一个大小为 m x n 的二维字符数组 picture ，表示一张黑白图像，数组中的 ‘B’ 表示黑色像素，‘W’ 表示白色像素。另给你一个整数 target ，请你找出并返回符合规则的 黑色 孤独像素的数量。
黑色孤独像素是指位于某一特定位置 (r, c) 的字符 ‘B’ ，其中：
行 r 和列 c 中的黑色像素恰好有 target 个。
列 c 中所有黑色像素所在的行必须和行 r 完全相同。
链接：https://leetcode.cn/problems/lonely-pixel-ii
class Solution:
def findBlackPixel(self, picture: List[List[str]], target: int) -> int:
m, n = len(picture), len(picture[0])
dic_r = defaultdict(list)
dic_c = defaultdict(list)
for i in range(m):
for j in range(n):
if picture[i][j] == 'B':
dic_r[i].append(j)
dic_c[j].append(i)
res = 0
# print(dic_r, dic_c)
for i in range(m):
if len(dic_r[i])!=target:
continue
for j in range(n):
if len(dic_c[j])!=target:
continue
if picture[i][j]== 'B':
y = dic_r[i]
flag = True
for x in dic_c[j]:
if dic_r[x] != y:
flag = False
break
if flag: res+=1
return res
635、设计日志存储系统
你将获得多条日志，每条日志都有唯一的 id 和 timestamp ，timestamp 是形如 Year:Month:Day:Hour:Minute:Second 的字符串，2017:01:01:23:59:59 ，所有值域都是零填充的十进制数。
实现 LogSystem 类：
LogSystem() 初始化 LogSystem 对象
void put(int id, string timestamp) 给定日志的 id 和 timestamp ，将这个日志存入你的存储系统中。
int[] retrieve(string start, string end, string granularity) 返回在给定时间区间 [start, end] （包含两端）内的所有日志的 id 。start 、end 和 timestamp 的格式相同，granularity 表示考虑的时间粒度（例如，精确到 Day、Minute 等）。例如 start = "2017:01:01:23:59:59"、end = "2017:01:02:23:59:59" 且 granularity = "Day" 意味着需要查找从 Jan. 1st 2017 到 Jan. 2nd 2017 范围内的日志，可以忽略日志的 Hour、Minute 和 Second 。
链接：https://leetcode.cn/problems/design-log-storage-system
class LogSystem:
def __init__(self):
self.dict = defaultdict(str)
self.granularity_dict = {"Year": 4, "Month": 7, "Day": 10,
"Hour": 13, "Minute": 16, "Second": 19}
def put(self, id: int, timestamp: str) -> None:
self.dict[id] = timestamp
def retrieve(self, start: str, end: str, granularity: str) -> List[int]:
check_len = self.granularity_dict[granularity]
res = []
for key, val in self.dict.items():
if val[:check_len] >= start[:check_len] and val[:check_len] <= end[:check_len]:
res.append(key)
return res
545、二叉树的边界
二叉树的 边界 是由 根节点 、左边界 、按从左到右顺序的 叶节点 和 逆序的右边界 ，按顺序依次连接组成。
左边界 是满足下述定义的节点集合：
根节点的左子节点在左边界中。如果根节点不含左子节点，那么左边界就为 空 。
如果一个节点在左边界中，并且该节点有左子节点，那么它的左子节点也在左边界中。
如果一个节点在左边界中，并且该节点 不含 左子节点，那么它的右子节点就在左边界中。
最左侧的叶节点 不在 左边界中。
右边界 定义方式与 左边界 相同，只是将左替换成右。即，右边界是根节点右子树的右侧部分；叶节点 不是 右边界的组成部分；如果根节点不含右子节点，那么右边界为 空 。
叶节点 是没有任何子节点的节点。对于此问题，根节点 不是 叶节点。
给你一棵二叉树的根节点 root ，按顺序返回组成二叉树 边界 的这些值。
链接：https://leetcode.cn/problems/boundary-of-binary-tree
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def boundaryOfBinaryTree(self, root: Optional[TreeNode]) -> List[int]:
if root and not root.left and not root.right:return [root.val]
left = []
bottom = []
right = []
def leftdfs(root):
if root and (root.left or root.right):
left.append(root.val)
if root.left:
leftdfs(root.left)
else:
leftdfs(root.right)
def bottomdfs(root):
if not root: return
if not root.left and not root.right:
bottom.append(root.val)
return
bottomdfs(root.left)
bottomdfs(root.right)
def rightdfs(root):
if root and (root.left or root.right):
right.append(root.val)
if root.right:
rightdfs(root.right)
else:
rightdfs(root.left)
leftdfs(root.left)
bottomdfs(root)
rightdfs(root.right)
return [root.val] + left + bottom + right[::-1]
616、给字符串添加加粗字符串
给你一个字符串 s 和一个字符串列表 words ，你需要将在字符串列表中出现过的 s 的子串添加加粗闭合标签 和 。
如果两个子串有重叠部分，你需要把它们一起用一对闭合标签包围起来。同理，如果两个子字符串连续被加粗，那么你也需要把它们合起来用一对加粗标签包围。
返回添加加粗标签后的字符串 s 。
链接：https://leetcode.cn/problems/add-bold-tag-in-string
class Solution:
def addBoldTag(self, s: str, words: List[str]) -> str:
n = len(s)
mask = [False for _ in range(n)]
for i in range(n):
for word in words:
if i+len(word)<=n and s[i:i+len(word)]==word:
for j in range(i, i+len(word)):
mask[j] = True
res = ''
for i in range(n):
if mask[i] and (i==0 or mask[i-1]==False):
res+='<b>'
res+=s[i]
if mask[i] and (i==n-1 or mask[i+1]==False):
res+='</b>'
return res
624、数组列表中的最大距离
给定 m 个数组，每个数组都已经按照升序排好序了。现在你需要从两个不同的数组中选择两个整数（每个数组选一个）并且计算它们的距离。两个整数 a 和 b 之间的距离定义为它们差的绝对值 |a-b| 。你的任务就是去找到最大距离
链接：https://leetcode.cn/problems/maximum-distance-in-arrays
class Solution:
def maxDistance(self, arrays: List[List[int]]) -> int:
m = len(arrays)
res = -float('inf')
arr = []
for i in range(m):
if len(arrays[i]) == 1 or arrays[i][0]==arrays[i][-1]:
arr.append((arrays[i][0], i))
else:
minn, maxn = arrays[i][0], arrays[i][-1]
arr.append((minn, i))
arr.append((maxn, i))
arr.sort(key = lambda x:x[0])
print(arr)
if arr[0][1] == arr[-1][1]:
res = max(abs(arr[-1][0]-arr[1][0]), abs(arr[-2][0]-arr[0][0]))
else:
res = arr[-1][0]-arr[0][0]
return res
723、粉碎糖果
这个问题是实现一个简单的消除算法。
给定一个 m x n 的二维整数数组 board 代表糖果所在的方格，不同的正整数 board[i][j] 代表不同种类的糖果，如果 board[i][j] == 0 代表 (i, j) 这个位置是空的。
给定的方格是玩家移动后的游戏状态，现在需要你根据以下规则粉碎糖果，使得整个方格处于稳定状态并最终输出：
如果有三个及以上水平或者垂直相连的同种糖果，同一时间将它们粉碎，即将这些位置变成空的。
在同时粉碎掉这些糖果之后，如果有一个空的位置上方还有糖果，那么上方的糖果就会下落直到碰到下方的糖果或者底部，这些糖果都是同时下落，也不会有新的糖果从顶部出现并落下来。
通过前两步的操作，可能又会出现可以粉碎的糖果，请继续重复前面的操作。
当不存在可以粉碎的糖果，也就是状态稳定之后，请输出最终的状态。
你需要模拟上述规则并使整个方格达到稳定状态，并输出。
链接：https://leetcode.cn/problems/candy-crush
class Solution:
def candyCrush(self, board: List[List[int]]) -> List[List[int]]:
m, n = len(board), len(board[0])
mask = [[False for _ in range(n)]for _ in range(m)]
while 1:
mask = [[False for _ in range(n)]for _ in range(m)]
flag = False
for i in range(m):
for j in range(n-2):
if board[i][j]!=0 and board[i][j] == board[i][j+1] == board[i][j+2]:
flag = True
mask[i][j] = mask[i][j+1] = mask[i][j+2] = True
for i in range(n):
for j in range(m-2):
if board[j][i]!=0 and board[j][i] == board[j+1][i] == board[j+2][i]:
flag = True
mask[j][i] = mask[j+1][i] = mask[j+2][i] = True
if flag:
for c in range(n):
rr = m - 1
for r in range(m - 1, -1, -1):
if mask[r][c] == False:
board[rr][c] = board[r][c]
rr -= 1
while rr > -1:
board[rr][c] = 0
rr -= 1
else:
break
return board
737、句子相似性二
并查集
我们可以将一个句子表示为一个单词数组，例如，句子 I am happy with leetcode"可以表示为 arr = [“I”,“am”,happy",“with”,“leetcode”]
给定两个句子 sentence1 和 sentence2 分别表示为一个字符串数组，并给定一个字符串对 similarPairs ，其中 similarPairs[i] = [xi, yi] 表示两个单词 xi 和 yi 是相似的。
如果 sentence1 和 sentence2 相似则返回 true ，如果不相似则返回 false 。
两个句子是相似的，如果:
- 它们具有 相同的长度 (即相同的字数)
- sentence1[i] 和 sentence2[i] 是相似的
请注意，一个词总是与它自己相似，也请注意，相似关系是可传递的。例如，如果单词 a 和 b 是相似的，单词 b 和 c 也是相似的，那么 a 和 c 也是 相似 的。
链接：https://leetcode.cn/problems/sentence-similarity-ii
class Union:
def __init__(self, n):
self.father = [i for i in range(n)]
def findFather(self, x):
while x != self.father[x]:
self.father[x] = self.father[self.father[x]]
x = self.father[x]
return x
def union(self, x, y):
fa_x = self.findFather(x)
fa_y = self.findFather(y)
if fa_x != fa_y:
if fa_x < fa_y:
fa_x, fa_y = fa_y, fa_x
self.father[fa_y] = fa_x
def isConnect(self, x, y):
fa_x = self.findFather(x)
fa_y = self.findFather(y)
return fa_x==fa_y
class Solution:
def areSentencesSimilarTwo(self, sentence1: List[str], sentence2: List[str], similarPairs: List[List[str]]) -> bool:
if len(sentence1) != len(sentence2): return False
n = len(sentence1)
sentence = sentence1 + sentence2
dic = dict()
Id = 0
for x in sentence:
if x not in dic:
dic[x] = Id
Id += 1
for x,y in similarPairs:
if x not in dic:
dic[x] = Id
Id += 1
if y not in dic:
dic[y] = Id
Id += 1
uf = Union(Id)
for x,y in similarPairs:
uf.union(dic[x], dic[y])
for i in range(n):
if not uf.isConnect(dic[sentence1[i]], dic[sentence2[i]]):
return False
return True
651、四键键盘
假设你有一个特殊的键盘包含下面的按键：
A：在屏幕上打印一个 'A'。
Ctrl-A：选中整个屏幕。
Ctrl-C：复制选中区域到缓冲区。
Ctrl-V：将缓冲区内容输出到上次输入的结束位置，并显示在屏幕上。
现在，你可以 最多 按键 n 次（使用上述四种按键），返回屏幕上最多可以显示 'A' 的个数 。
链接：https://leetcode.cn/problems/4-keys-keyboard
class Solution:
def maxA(self, n: int) -> int:
#### dfs
# self.res = 0
# def dfs(cur_i, nums, tmp):
# if cur_i == n:
# self.res = max(self.res, nums)
# return
# pathway = [1,3,1]
# for i in range(3):
# di = pathway[i]
# if 0 <= cur_i+di <= n:
# ni = cur_i + di
# if i == 0:
# dfs(ni, nums+1, tmp)
# elif i==1:
# dfs(ni, nums*2, nums)
# elif i==2:
# dfs(ni, nums+tmp, tmp)
# dfs(0,0,0)
# return self.res
#### dp
self.res = 0
f = [0 for _ in range(n)]
f[0] = 1
for i in range(1, n):
f[i] = f[i-1] + 1
for j in range(i):
f[i] = max(f[i], f[j]*(i-j-2+1))
return (f[n-1])
663、均匀树划分
给定一棵有 n 个结点的二叉树，你的任务是检查是否可以通过去掉树上的一条边将树分成两棵，且这两棵树结点之和相等。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def checkEqualTree(self, root: Optional[TreeNode]) -> bool:
def sumTree(root):
if not root:
return 0
left = sumTree(root.left)
right = sumTree(root.right)
return root.val + left + right
summ = sumTree(root)
if summ % 2 != 0:
return False
target = summ//2
def findtarget(root, pre):
if not root:
return False
if pre and sumTree(root) == target:
return True
return findtarget(root.left, root) or findtarget(root.right, root)
return findtarget(root, None)
666、路经总和四
对于一棵深度小于 5 的树，可以用一组三位十进制整数来表示。对于每个整数：
百位上的数字表示这个节点的深度 d，1 <= d <= 4。
十位上的数字表示这个节点在当前层所在的位置 P， 1 <= p <= 8。位置编号与一棵满二叉树的位置编号相同。
个位上的数字表示这个节点的权值 v，0 <= v <= 9。
给定一个包含三位整数的 升序 数组 nums ，表示一棵深度小于 5 的二叉树，请你返回 从根到所有叶子结点的路径之和 。
保证 给定的数组表示一个有效的连接二叉树。
链接：https://leetcode.cn/problems/path-sum-iv
class Solution:
def pathSum(self, nums: List[int]) -> int:
def int2arr(x):
arr = [int(str(x)[0]),int(str(x)[1]) ,int(str(x)[2])]
return arr
arr = []
for x in nums:
tmp = int2arr(x)
arr.append(tmp)
root = arr[0]
st = [root]
res = []
while st:
tmp = st
st = []
while tmp:
depth, width, summ = tmp.pop(0)
flag1, flag2=False, False
for d, w, n in arr:
if d==depth+1 and w == width*2-1:
st.append([d, w, summ+n])
flag1=True
for d, w, n in arr:
if d==depth+1 and w == width*2:
st.append([d, w, summ+n])
flag1=True
if not flag1 and not flag2:
res.append(summ)
return (sum(res))
1066、校园自行车
1120、子树的平均值
给你一棵二叉树的根节点 root，找出这棵树的 每一棵 子树的 平均值 中的 最大 值。
子树是树中的任意节点和它的所有后代构成的集合。
树的平均值是树中节点值的总和除以节点数。
链接：https://leetcode.cn/problems/maximum-average-subtree
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def maximumAverageSubtree(self, root: Optional[TreeNode]) -> float:
def sumTree(root, nums):
if not root:
return 0, 0
left, nums_l = sumTree(root.left, nums+1)
right, nums_r = sumTree(root.right, nums+1)
return root.val + left + right, nums_l+nums_r+1
self.res = 0
def dfs(root):
if not root:
return
dfs(root.left)
dfs(root.right)
summ, nums = sumTree(root, 0)
self.res = max(self.res, summ/nums)
dfs(root)
return self.res
1152、用户网站访问行为分析
给定两个字符串数组 username 和 website 和一个整数数组 timestamp 。给定的数组长度相同，其中元组 [username[i], website[i], timestamp[i]] 表示用户 username[i] 在时间 timestamp[i] 访问了网站 website[i] 。
访问模式 是包含三个网站的列表(不一定是完全不同的)。
例如，[“home”， “away”， “love”]， [“leetcode”， “love”， “leetcode”]，和 [“luffy”， “luffy”， “luffy”] 都是模式。
一种 访问模式 的 得分 是访问该模式中所有网站的用户数量，这些网站在该模式中出现的顺序相同。
例如，如果模式是 [“home”，“away”，“love”] ，那么分数就是用户数量 x , x 访问了 “home” ，然后访问了 “away” ，然后访问了 “love” 。
同样，如果模式是 [“leetcode”， “love”， “leetcode”] ，那么分数就是用户数量 x ，使得 x 访问了"leetcode"，然后访问了 “love” ，之后又访问了 “leetcode” 。
另外，如果模式是 [“luffy”，“luffy”，“luffy”] ，那么分数就是用户数量 x ，这样 x 就可以在不同的时间戳上访问 “luffy” 三次。
返回 得分 最大的 访问模式 。如果有多个访问模式具有相同的最大分数，则返回字典序最小的。
链接：https://leetcode.cn/problems/analyze-user-website-visit-pattern
class Solution:
def mostVisitedPattern(self, username: List[str], timestamp: List[int], website: List[str]) -> List[str]:
dict_input = dict(zip(timestamp, zip(username, website)))
dict_user = defaultdict(list)
from sortedcontainers import SortedDict as SD
mode = SD()
print(sorted(dict_input.keys()))
# for i in range(len(username)):
for key in sorted(dict_input.keys()):
user, web = dict_input[key]
dict_user[user].append(web)
for k,v in dict_user.items():
if len(v)>=3:
tmp_path_set = set()
for i in range(len(v)-2):
for j in range(i+1, len(v)-1):
for z in range(j+1, len(v)):
tmp_path_set.add(tuple([v[i],v[j],v[z]]))
for p in tmp_path_set:
if p not in mode:
mode[p] = 0
mode[p] += 1
print(dict_user, mode)
maxm = 0
self.res = []
for k,v in mode.items():
if v>maxm:
maxm = v
self.res = list(k)
return (self.res)
1166、设计文件系统
你需要设计一个文件系统，你可以创建新的路径并将它们与不同的值关联。
路径的格式是一个或多个连接在一起的字符串，形式为： / ，后面跟着一个或多个小写英文字母。例如， " /leetcode" 和 “/leetcode/problems” 是有效路径，而空字符串 “” 和 “/” 不是。
实现 FileSystem 类:
bool createPath(string path, int value) 创建一个新的 path ，并在可能的情况下关联一个 value ，然后返回 true 。如果路径已经存在或其父路径不存在，则返回 false 。
int get(string path) 返回与 path 关联的值，如果路径不存在则返回 -1 。
链接：https://leetcode.cn/problems/design-file-system
class FileSystem:
def __init__(self):
self.path_dict = defaultdict(int)
def createPath(self, path: str, value: int) -> bool:
if path == '' or path == '/':
return False
arr = path.split('/')[1:]
if '/' in arr:
return False
if tuple(arr) in self.path_dict:
return False
elif len(arr)>1:
if tuple(arr[:len(arr)-1]) not in self.path_dict:
return False
self.path_dict[tuple(arr)] = value
return True
def get(self, path: str) -> int:
arr = path.split('/')[1:]
if tuple(arr) not in self.path_dict:
return -1
else:
return self.path_dict[tuple(arr)]
# Your FileSystem object will be instantiated and called as such:
# obj = FileSystem()
# param_1 = obj.createPath(path,value)
# param_2 = obj.get(path)
1167、连接棒材的最低费用
你有一些长度为正整数的棍子。这些长度以数组 sticks 的形式给出， sticks[i] 是 第i个 木棍的长度。
你可以通过支付 x + y 的成本将任意两个长度为 x 和 y 的棍子连接成一个棍子。你必须连接所有的棍子，直到剩下一个棍子。
返回以这种方式将所有给定的棍子连接成一个棍子的 最小成本 。
链接：https://leetcode.cn/problems/minimum-cost-to-connect-sticks
用heapq排序，每次取最小的两个，用sort会超时
class Solution:
def connectSticks(self, sticks: List[int]) -> int:
ans = 0
heap = []
for n in sticks:
heapq.heappush(heap, n)
while len(heap) >= 2:
a = heapq.heappop(heap)
b = heapq.heappop(heap)
c = a + b
ans += c
heapq.heappush(heap, c)
return ans
1198、找出所有行的最小公共元素
利用set的特点
class Solution:
def smallestCommonElement(self, mat: List[List[int]]) -> int:
a = set(mat[0])
for i in range(len(mat)):
a = a & set(mat[i])
print(a)
a = list(a)
if len(a) == 0:
return -1
return a[0]
1214、查找两颗二叉树之和
给出两棵二叉搜索树的根节点 root1 和 root2 ，请你从两棵树中各找出一个节点，使得这两个节点的值之和等于目标值 Target。
如果可以找到返回 True，否则返回 False。
链接：https://leetcode.cn/problems/two-sum-bsts
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def twoSumBSTs(self, root1: Optional[TreeNode], root2: Optional[TreeNode], target: int) -> bool:
self.res = []
def dfs(root):
if not root: return
dfs(root.left)
self.res.append(root.val)
dfs(root.right)
dfs(root1)
res1 = self.res.copy()
self.res = []
dfs(root2)
res2 = self.res.copy()
for x in res1:
if target - x in res2:
return True
return False
1244、力扣排行榜
新一轮的「力扣杯」编程大赛即将启动，为了动态显示参赛者的得分数据，需要设计一个排行榜 Leaderboard。
请你帮忙来设计这个 Leaderboard 类，使得它有如下 3 个函数：
addScore(playerId, score)：
假如参赛者已经在排行榜上，就给他的当前得分增加 score 点分值并更新排行。
假如该参赛者不在排行榜上，就把他添加到榜单上，并且将分数设置为 score。
top(K)：返回前 K 名参赛者的 得分总和。
reset(playerId)：将指定参赛者的成绩清零（换句话说，将其从排行榜中删除）。题目保证在调用此函数前，该参赛者已有成绩，并且在榜单上。
请注意，在初始状态下，排行榜是空的。
链接：https://leetcode.cn/problems/design-a-leaderboard
class Leaderboard:
def __init__(self):
self.board = dict()
def addScore(self, playerId: int, score: int) -> None:
if playerId not in self.board:
self.board[playerId] = score
else:
self.board[playerId] += score
def top(self, K: int) -> int:
a = sorted(self.board.items(), key=lambda x:x[1], reverse=True)
ans = 0
a = a[:K]
for k, v in a:
ans += v
return ans
def reset(self, playerId: int) -> None:
if playerId in self.board:
del self.board[playerId]
# Your Leaderboard object will be instantiated and called as such:
# obj = Leaderboard()
# obj.addScore(playerId,score)
# param_2 = obj.top(K)
# obj.reset(playerId)
1265、逆序打印不可变链表
给您一个不可变的链表，使用下列接口逆序打印每个节点的值：
ImmutableListNode: 描述不可变链表的接口，链表的头节点已给出。
您需要使用以下函数来访问此链表（您 不能 直接访问 ImmutableListNode）：
ImmutableListNode.printValue()：打印当前节点的值。
ImmutableListNode.getNext()：返回下一个节点。
输入只用来内部初始化链表。您不可以通过修改链表解决问题。也就是说，您只能通过上述 API 来操作链表。
链接：https://leetcode.cn/problems/print-immutable-linked-list-in-reverse
# """
# This is the ImmutableListNode's API interface.
# You should not implement it, or speculate about its implementation.
# """
# class ImmutableListNode:
# def printValue(self) -> None: # print the value of this node.
# def getNext(self) -> 'ImmutableListNode': # return the next node.
class Solution:
def printLinkedListInReverse(self, head: 'ImmutableListNode') -> None:
def dfs(node):
if node == None: return
dfs(node.getNext())
node.printValue()
dfs(head)
1215、进步数
如果一个整数上的每一位数字与其相邻位上的数字的绝对差都是 1，那么这个数就是一个「步进数」。
例如，321 是一个步进数，而 421 不是。
给你两个整数，low 和 high，请你找出在 [low, high] 范围内的所有步进数，并返回 排序后 的结果。
链接：https://leetcode.cn/problems/stepping-numbers
BFS
class Solution:
def countSteppingNumbers(self, low: int, high: int) -> List[int]:
res = []
if low == 0:
res.append(low)
queue = [x for x in range(1,10)]
while queue:
tmp = queue.pop(0)
if tmp > high:
return res
if tmp >= low:
res.append(tmp)
last = tmp % 10
if last > 0:
queue.append(tmp*10 + last - 1)
if last < 9:
queue.append(tmp*10 + last + 1)
return res
1256、加密数字
给你一个非负整数 num ，返回它的「加密字符串」。
加密的过程是把一个整数用某个未知函数进行转化，你需要从下表推测出该转化函数：
class Solution:
def encode(self, num: int) -> str:
new_num = bin(num+1)
print(new_num)
length = len(str(new_num))
return str(new_num)[3: length]
1182、与目标颜色间的最短距离
给你一个数组 colors，里面有 1、2、 3 三种颜色。
我们需要在 colors 上进行一些查询操作 queries，其中每个待查项都由两个整数 i 和 c 组成。
现在请你帮忙设计一个算法，查找从索引 i 到具有目标颜色 c 的元素之间的最短距离。
如果不存在解决方案，请返回 -1。
链接：https://leetcode.cn/problems/shortest-distance-to-target-color
class Solution:
def shortestDistanceColor(self, colors: List[int], queries: List[List[int]]) -> List[int]:
ans = []
dic_color = defaultdict(list)
for idx,x in enumerate(colors):
dic_color[x].append(idx)
for x,y in queries:
if y not in dic_color:
ans.append(-1)
else:
if colors[x] == y:
ans.append(0)
else:
arr = dic_color[y]
left, right = 0, len(arr)-1
if x<=arr[left]:
ans.append(abs(arr[left]-x))
elif x>=arr[right]:
ans.append(abs(arr[right]-x))
else:
while left <= right:
mid = (left+right)//2
if x > arr[mid]: left = mid+1
else: right = mid-1
ans.append(min(abs(arr[left] - x), abs(arr[left - 1] - x)))
return ans
1230、抛掷硬币
有一些不规则的硬币。在这些硬币中，prob[i] 表示第 i 枚硬币正面朝上的概率。
请对每一枚硬币抛掷 一次，然后返回正面朝上的硬币数等于 target 的概率。
链接：https://leetcode.cn/problems/toss-strange-coins
class Solution:
def probabilityOfHeads(self, prob: List[float], target: int) -> float:
m = len(prob)
dp = [[0 for _ in range(target+1)] for _ in range(m+1)]
dp[0][0] = 1
for i in range(m):
dp[i+1][0] = dp[i][0]*(1-prob[i])
for i in range(1,m+1):
for j in range(1,target+1):
dp[i][j] = dp[i-1][j]*(1-prob[i-1])+dp[i-1][j-1]*prob[i-1]
return dp[-1][-1]
1258、近义词替换
给你一个近义词表 synonyms 和一个句子 text ， synonyms 表中是一些近义词对 ，你可以将句子 text 中每个单词用它的近义词来替换。
请你找出所有用近义词替换后的句子，按 字典序排序 后返回。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/synonymous-sentences
PS：利用并查集，确定近义词集合
class Union:
def __init__(self, n):
self.father = [x for x in range(n)]
def findFather(self, x):
while x!=self.father[x]:
self.father[x] = self.father[self.father[x]]
x = self.father[x]
return x
def union(self,x,y):
root1 = self.findFather(x)
root2 = self.findFather(y)
if root1 != root2:
if root2 > root1:
self.father[root2] = root1
else:
self.father[root1] = root2
def isConnect(self,x,y):
return self.findFather(x)==self.findFather(y)
class Solution:
def generateSentences(self, synonyms: List[List[str]], text: str) -> List[str]:
arr_str = text.split(' ')
word_id_dict = defaultdict(int)
idx = 0
for x,y in synonyms:
if x not in word_id_dict:
word_id_dict[x] = idx
idx+=1
if y not in word_id_dict:
word_id_dict[y] = idx
idx+=1
uf = Union(idx)
for x, y in synonyms:
uf.union(word_id_dict[x], word_id_dict[y])
syn_dict = defaultdict(set)
for x in word_id_dict.keys():
for y in word_id_dict.keys():
if x==y:
continue
if uf.isConnect(word_id_dict[x], word_id_dict[y]):
syn_dict[x].add(y)
self.res = set()
self.res.add(text)
def dfs(arr, i):
if i == len(arr):
return
for j in range(i,len(arr)):
print(arr[j])
if arr[j] in syn_dict:
for v in syn_dict[arr[j]]:
tmp = arr.copy()
tmp[j] = v
self.res.add(' '.join(tmp))
dfs(tmp, j+1)
tmp = arr.copy()
self.res.add(' '.join(tmp))
dfs(tmp, j+1)
dfs(arr_str,0)
self.res = list(self.res)
self.res.sort()
return self.res
1236、网络爬虫
给定一个链接 startUrl 和一个接口 HtmlParser ，请你实现一个网络爬虫，以实现爬取同 startUrl 拥有相同 域名标签 的全部链接。该爬虫得到的全部链接可以 任何顺序 返回结果。
链接：https://leetcode.cn/problems/web-crawler
# """
# This is HtmlParser's API interface.
# You should not implement it, or speculate about its implementation
# """
#class HtmlParser(object):
# def getUrls(self, url):
# """
# :type url: str
# :rtype List[str]
# """
class Solution:
def crawl(self, startUrl: str, htmlParser: 'HtmlParser') -> List[str]:
start_strr=startUrl[7:]
start_name = 'http://'+start_strr.split('/')[0]
res = set()
res.add(startUrl)
st = [startUrl]
while st:
tmp_str = st.pop(0)
res.add(tmp_str)
for x in htmlParser.getUrls(tmp_str):
if x not in res and x.startswith(start_name):
st.append(x)
return (res)
1257、最小化公共区域
给你一些区域列表 regions ，每个列表的第一个区域都包含这个列表内所有其他区域。
很自然地，如果区域 X 包含区域 Y ，那么区域 X 比区域 Y 大。
给定两个区域 region1 和 region2 ，找到同时包含这两个区域的 最小 区域。
如果区域列表中 r1 包含 r2 和 r3 ，那么数据保证 r2 不会包含 r3 。
数据同样保证最小公共区域一定存在。
链接：https://leetcode.cn/problems/smallest-common-region
class Solution:
def findSmallestRegion(self, regions: List[List[str]], region1: str, region2: str) -> str:
fa_dict = dict()
for region in regions:
fa = region[0]
for child in region[1:]:
fa_dict[child] = fa
r1, r2 = region1, region2
r1_fas = [r1]
while r1 in fa_dict:
r1 = fa_dict[r1]
r1_fas.append(r1)
while r2 in fa_dict:
if r2 in r1_fas:
return r2
r2 = fa_dict[r2]
return r2
1272、删除区间
实数集合可以表示为若干不相交区间的并集，其中每个区间的形式为 [a, b)（左闭右开），表示满足 a <= x < b 的所有实数 x 的集合。如果某个区间 [a, b) 中包含实数 x ，则称实数 x 在集合中。
给你一个 有序的 不相交区间列表 intervals 。intervals 表示一个实数集合，其中每一项 intervals[i] = [ai, bi] 都表示一个区间 [ai, bi) 。再给你一个要删除的区间 toBeRemoved 。
返回 一组实数，该实数表示intervals 中 删除 了 toBeRemoved 的部分 。换句话说，返回实数集合，并满足集合中的每个实数 x 都在 intervals 中，但不在 toBeRemoved 中。你的答案应该是一个如上所述的 有序的 不相连的间隔列表 。
链接：https://leetcode.cn/problems/remove-interval
class Solution:
def removeInterval(self, intervals: List[List[int]], toBeRemoved: List[int]) -> List[List[int]]:
res = []
for x,y in intervals:
tmp_x = min(x, toBeRemoved[0])
tmp_y = max(y, toBeRemoved[1])
if tmp_x == x and tmp_y == y:
if tmp_x == x == toBeRemoved[0] and tmp_y == y == toBeRemoved[1]:
continue
elif tmp_x == x == toBeRemoved[0]:
res.append([toBeRemoved[1], y])
elif tmp_y == y == toBeRemoved[1]:
res.append([x, toBeRemoved[0]])
else:
res.append([x,toBeRemoved[0]])
res.append([toBeRemoved[1],y])
elif tmp_x == x and tmp_y == toBeRemoved[1]:
res.append([x, min(y,toBeRemoved[0])])
elif tmp_x == toBeRemoved[0] and tmp_y == y:
res.append([max(x,toBeRemoved[1]), y])
return res
1273、删除树节点
class Solution:
def deleteTreeNodes(self, nodes: int, parent: List[int], value: List[int]) -> int:
edges = [[] for _ in range(nodes)]
for x, p in enumerate(parent):
if p != -1:
edges[p].append(x)
cnt_node = [1 for _ in range(nodes)]
def dfs(node):
for v in edges[node]:
dfs(v)
value[node] += value[v]
cnt_node[node] += cnt_node[v]
if value[node] == 0:
cnt_node[node] = 0
dfs(0)
return cnt_node[0]
758、字符串加粗单词
class Solution:
def boldWords(self, words: List[str], s: str) -> str:
n = len(s)
mask = [False for _ in range(n)]
for i in range(n):
for word in words:
if i+len(word)<=n and s[i:i+len(word)]==word:
for j in range(len(word)):
mask[i+j] = True
res = ''
for idx, x in enumerate(mask):
if mask[idx] and (idx==0 or mask[idx-1]==False):
res+='<b>'
res+=s[idx]
if mask[idx] and (idx==n-1 or mask[idx+1]==False):
res+='</b>'
return res
1062、最长重复子串
二分查找 binary-search
class Solution:
def boldWords(self, words: List[str], s: str) -> str:
n = len(s)
mask = [False for _ in range(n)]
for i in range(n):
for word in words:
if i+len(word)<=n and s[i:i+len(word)]==word:
for j in range(len(word)):
mask[i+j] = True
res = ''
for idx, x in enumerate(mask):
if mask[idx] and (idx==0 or mask[idx-1]==False):
res+='<b>'
res+=s[idx]
if mask[idx] and (idx==n-1 or mask[idx+1]==False):
res+='</b>'
return res
LCP 12. 小张刷题计划
class Solution:
def minTime(self, time: List[int], m: int) -> int:
left, right = 0, sum(time)
while left<right:
L = (left+right)//2
if self.isTime(L, time, m):
right = L
else:
left = L+1
return left
def isTime(self, Limit, time, m):
cur_time = 0
max_time = time[0]
days = 1
for x in time[1:]:
if cur_time + min(max_time, x)<=Limit:
cur_time += min(max_time,x)
max_time = max(max_time, x)
else:
cur_time = 0
days += 1
# max_time = min(max_time, x)
max_time = x
if days>m:
return False
else:
return True
625、最小因式分解
给定一个正整数 a，找出最小的正整数 b 使得 b 的所有数位相乘恰好等于 a。
如果不存在这样的结果或者结果不是 32 位有符号整数，返回 0。
class Solution:
def smallestFactorization(self, num: int) -> int:
res = 0
weight = 1
if num<=9:
return num
for x in range(9,1,-1):
while num%x == 0:
num //= x
res = weight*x + res
weight *= 10
if res >= 2**31-1:
return 0
if num!=1:
return 0
return res
750、角矩形的数量
动态规划
给定一个只包含 0 和 1 的 m x n 整数矩阵 grid ，返回 其中 「角矩形 」的数量 。
一个「角矩形」是由四个不同的在矩阵上的 1 形成的 轴对齐 的矩形。注意只有角的位置才需要为 1。
注意：4 个 1 的位置需要是不同的。
链接：https://leetcode.cn/problems/number-of-corner-rectangles
class Solution:
def countCornerRectangles(self, grid: List[List[int]]) -> int:
m, n = len(grid), len(grid[0])
dp = [[0 for _ in range(n)] for _ in range(n)]
res = 0
for i in range(m):
for j in range(n):
if grid[i][j]==1:
for k in range(j+1,n):
if grid[i][k]==1:
res+=dp[j][k]
dp[j][k]+=1
return res
三、困难
305、岛屿数量二
并查集的应用
给你一个大小为 m x n 的二进制网格 grid 。网格表示一个地图，其中，0 表示水，1 表示陆地。最初，grid 中的所有单元格都是水单元格（即，所有单元格都是 0）。
可以通过执行 addLand 操作，将某个位置的水转换成陆地。给你一个数组 positions ，其中 positions[i] = [ri, ci] 是要执行第 i 次操作的位置 (ri, ci) 。
返回一个整数数组 answer ，其中 answer[i] 是将单元格 (ri, ci) 转换为陆地后，地图中岛屿的数量。
岛屿 的定义是被「水」包围的「陆地」，通过水平方向或者垂直方向上相邻的陆地连接而成。你可以假设地图网格的四边均被无边无际的「水」所包围。
链接：https://leetcode.cn/problems/number-of-islands-ii
class FindUnion:
def __init__(self,n):
self.father = [x for x in range(n)]
self.cluster = 0
self.size = [1 for _ in range(n)]
def findFather(self,x):
while x!=self.father[x]:
self.father[x] = self.father[self.father[x]]
x = self.father[x]
return x
def Union(self,x,y):
root_x = self.findFather(x)
root_y = self.findFather(y)
if root_x == root_y:
return True
else:
if root_x > root_y:
self.father[root_x] = root_y
self.size[root_x] += self.size[root_y]
else:
self.father[root_y] = root_x
self.size[root_y] += self.size[root_x]
self.cluster -= 1
return True
class Solution:
def numIslands2(self, m: int, n: int, positions: List[List[int]]) -> List[int]:
uf = FindUnion(m*n)
seen = set()
res = []
for x,y in positions:
ID = x*n+y
if ID in seen:
res.append(uf.cluster)
continue
seen.add(ID)
uf.cluster += 1
for nr, nc in [(x+1,y),(x-1,y),(x,y+1),(x,y-1)]:
if 0<=nr<m and 0<=nc<n:
Id2 = nr*n+nc
if Id2 in seen:
uf.Union(ID, Id2)
res.append(uf.cluster)
return res
124、二叉树中的最大路径和
路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。
路径和 是路径中各节点值的总和。
给你一个二叉树的根节点 root ，返回其 最大路径和 。
链接：https://leetcode.cn/problems/binary-tree-maximum-path-sum
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def maxPathSum(self, root: Optional[TreeNode]) -> int:
self.res = -float('inf')
def dfs(root):
if not root: return 0
left = dfs(root.left)
right = dfs(root.right)
self.res=max(self.res,root.val+left+right, root.val+left, root.val+right, root.val)
print(root.val, self.res)
return max(root.val+left, root.val+right, root.val)
dfs(root)
return self.res
72、编辑距离
动态规划
给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。
你可以对一个单词进行如下三种操作：
插入一个字符
删除一个字符
替换一个字符
链接：https://leetcode.cn/problems/edit-distance
class Solution:
def minDistance(self, word1: str, word2: str) -> int:
m, n = len(word1), len(word2)
dp = [[0 for _ in range(n+1)]for _ in range(m+1)]
for i in range(m+1):
dp[i][0] = i
for i in range(n+1):
dp[0][i] = i
for i in range(1,m+1):
for j in range(1,n+1):
left = dp[i][j-1] + 1
right = dp[i-1][j] + 1
lr = dp[i-1][j-1]
if word1[i-1]!=word2[j-1]:
lr += 1
dp[i][j] = min(left, right, lr)
return dp[m][n]
912、排序数组
快排
class Solution:
def sortArray(self, nums: List[int]) -> List[int]:
def getIndex(nums, left, right):
p = nums[left]
while left < right:
while left < right and p<=nums[right]:
right -= 1
nums[left] = nums[right]
while left < right and p>=nums[left]:
left += 1
nums[right] = nums[left]
nums[left] = p
return left
def randomIndex(nums, left, right):
index = random.randint(left, right)
nums[left], nums[index] = nums[index],nums[left]
return getIndex(nums,left,right)
def quickSort(nums, left, right):
if left<right:
mid = randomIndex(nums,left,right)
quickSort(nums, left, mid-1)
quickSort(nums, mid+1, right)
quickSort(nums,0,len(nums)-1)
return nums
219
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
