leetcode第144场周赛
这次比赛也比较简单，自己的脑子还是不够快啊=，=
第一题 IP 地址无效化
题目大意：
用"[.]" 代替了每个 "."。
解题思路：
比较简单的方法是直接replace替换，如果要求在原字符串上更改，则可以先统计.的个数，最终的字符串长度+2*点的个数，从字符串的最后面开始放置字符即可。（比赛时间有限，直接用了replace）
代码如下：
class Solution:
def defangIPaddr(self, address: str) -> str:
return address.replace('.','[.]')第二题 航班预订统计
题目大意：
有 n 个航班，现有一份航班预订表，表中第 i 条预订记录 bookings[i] = [i, j, k] 意味着我们在从 i 到 j 的每个航班上预订了 k 个座位，返回一个长度为 n 的数组 answer，按航班编号顺序返回每个航班上预订的座位数。
解题思路：
因为bookings.length <= 20000，n<=20000，直接暴力应该会超时。
对于预定记录[i，j，k]，我们可以用一个数组记录在i 的地方加上k，在j + 1 的地方减去k，最后统计一遍数组即可。
以样例 bookings = [[1,2,10],[2,3,20],[2,5,25]], n = 5 为例：
代码如下：
class Solution:
def corpFlightBookings(self, bookings: List[List[int]], n: int) -> List[int]:
book_list = [0 for i in range(0, n + 1)]
for each in bookings:
book_list[each[0] - 1] += each[2]
book_list[each[1]] -= each[2]
for i in range(0, n - 1):
book_list[i + 1] += book_list[i]
return book_list[:n]第三题 删点成林
题目大意：
给出二叉树的根节点 root，树上每个节点都有一个不同的值。
如果节点值在 to_delete 中出现，我们就把该节点从树上删去，最后得到一个森林（一些不相交的树构成的集合）。
解题思路：
进行树的遍历，然后删除点，更新树的内容，将森林的根节点放到一个list中去
代码如下：
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def delNode(self, root: TreeNode, to_delete: List[int]):
rtn_list = []
if root == None:
return rtn_list, None
#更新左儿子
leftlist,leftnode = self.delNode(root.left, to_delete)
rtn_list = rtn_list + leftlist
root.left = leftnode
#更新右儿子
rightlist, rightnode = self.delNode(root.right, to_delete)
rtn_list = rtn_list + rightlist
root.right = rightnode
#更新当前节点
if root.val in to_delete:
if root.left != None:
rtn_list.append(root.left)
if root.right != None:
rtn_list.append(root.right)
root = None
return rtn_list, root
def delNodes(self, root: TreeNode, to_delete: List[int]) -> List[TreeNode]:
rtn_list, root = self.delNode(root, to_delete)
if root != None:
rtn_list.append(root)
return rtn_list第四题 有效括号的嵌套深度
题目大意：
给定字符串都由小括号构成，左括号与右括号数目相等即为有效括号字符串，现给你一个有效括号字符串，要将其分成两个有效括号字符串A,B,使得max(depth(A), depth(B)) 的可能取值最小。
有效括号字符串 s 的 嵌套深度 depth(S)：
s为空时，depth("") = 0s为A与B连接时，depth(A + B) = max(depth(A), depth(B))，其中A和B都是有效括号字符串s为嵌套情况，depth("(" + A + ")") = 1 + depth(A)，其中 A 是有效括号字符串
解题思路：
题目意思就是括号里面多套一层括号深度就加1，给你个有效括号字符串，先计算其深度，max(depth(A), depth(B))必为其深度/2向上取整。所以我们可以假设A的深度为总深度/2向下取整，B的深度为总深度/2向上取整。然后我们只要将从字符串开始计算，遇到左括号，深度加1，遇到右括号深度减一，深度不超过总深度/2向下取整均归为A，剩下的都是B的。
代码如下：
class Solution:
def maxDepthAfterSplit(self, seq: str) -> List[int]:
#left表示剩余左括号的数量，也可表示深度
left = 0
#最大深度
maxx = 0
for each in seq:
if each == '(':
left += 1
if each == ')':
left -= 1
maxx = max(maxx, left)
left = 0
maxx = maxx // 2
ans = []
for i in range(0, len(seq)):
#只要在A的深度范围内归为0，其余的都是B的为1
if seq[i] == '(' and left < maxx:
left += 1
ans.append(0)
elif seq[i] == ')' and left > 0:
left -= 1
ans.append(0)
else:
ans.append(1)
return ans