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("") = 0
• s 为 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