leetcode 第 172 場周賽 - 答案和思路解釋

本週題目不太難。

第一題 5315. 6 和 9 組成的最大數字

簡單題。

直接遍歷把第一個 6 改爲 9 就行。

用 python 很方便，可是須要注意 python 的字符串是不可變的，須要轉成 list 方便操做（固然我是從 int 轉成 str 再轉成了 list）

class Solution:
    def maximum69Number (self, num: int) -> int:
        x = list(str(num))
        for i in range(len(x)):
            if x[i] == '6':
                x[i] = '9'
                break
        return int(''.join(x))

在題目評論裏看到別人的解法，太強了

class Solution:
    def maximum69Number (self, num: int) -> int:
        return int(str(num).replace('6','9',1))

第二題 5316. 豎直打印單詞

這個遠遠沒有題庫裏的第 6 題 Z 字形變換 難，這題很靠前，估計不少人都作過吧。

本題目尤爲用 python 方便，連去結尾空格都有函數。

class Solution:
    def printVertically(self, s: str) -> List[str]:
        s = s.split(' ')
        max_l = 0
        for w in s:
            max_l = max(max_l, len(w))
        r = [[] for i in range(max_l)]
        for w in s:
            for i in range(max_l):
                if i < len(w):
                    r[i].append(w[i])
                else:
                    r[i].append(' ')
        rr = []
        for x in r:
            rr.append(''.join(x).rstrip())
        return rr

第三題 5317. 刪除給定值的葉子節點

本題比賽中的示例 5 剛開始是有問題的：

示例 5：

輸入：root = [1,2,3], target = 2
輸出：[1,2,3]

讓我猶豫了一會。

後來這個 target 改爲 1 就對了。

也不難

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def removeLeafNodes(self, root: TreeNode, target: int) -> TreeNode:
        def del_t(t):
            if t.left:
                if del_t(t.left):
                    t.left = None
            if t.right:
                if del_t(t.right):
                    t.right = None
            if not t.left and not t.right:
                if t.val == target:
                    return True
            return False
        if del_t(root):
            return None
        return root

第四題 5318. 灌溉花園的最少水龍頭數目

這題目 18 年初實習面試的時候被問過。線段覆蓋問題。貪心算法。面試的時候我想的使用遞歸方法，此次寫的是迭代。

思路是：
先把每一個水龍頭的範圍轉化成區間，弄成一個區間數組。
好比 示例 1

轉換成：

[[0, 3], [0, 5], [1, 3], [2, 4]]

這裏作了兩個優化：

1. 長度爲零的就忽略了
2. 超出 0 到 n 範圍的就截止到 [0, n] 區間內

而後咱們能夠在按照區間的左端點排序。（上面的數組已是這個順序了）

其實另外還有一個優化：若是一個區間被另外一個區間徹底覆蓋了，那這個區間也是無效的，應該刪掉，例如 [1, 3] 徹底落在 [0, 3] 內。

結果這裏就只剩下 [0, 5] 了：
[[0, 5]]

因此這個例子很差，能夠看下示例 3

n = 7, ranges = [1,2,1,0,2,1,0,1]

通過上述操做後剩下的區間其實也只有恰好三個了：
[(0, 3), (2, 6), (6, 7)]
因此乾脆去掉

以後的作法是：

若是這個區間數量是 0 或者第一個區間不能覆蓋 0，直接返回 -1
而後就開始貪心：

1. 第一個區間必選，ans 變量計已選的區間數
2. 判斷是否能夠覆蓋，若是能夠，返回 ans
3. 從下一個區間開始，全部能夠選擇的區間（若是這個區間的左端點小於等於上一個選中區間的右端點，就能夠選）中找一個右端點最大的，選擇，若是沒有可選的，返回 -1

這個代碼寫的不夠精煉

class Solution:
    def minTaps(self, n: int, ranges: List[int]) -> int:
        # ranges 轉化爲區間
        seg = []
        for i in range(n+1):
            if ranges[i] > 0:
                seg.append((max(0, i - ranges[i]), min(n, i + ranges[i])))
        # 去掉被其餘區間覆蓋的區間
        s2 = {}
        for s in seg:
            if s[0] not in s2:
                s2[s[0]] = []
            s2[s[0]].append(s)
        seg = []
        for k in s2:
            t = s2[k][0]
            for xx in s2[k]:
                if xx[1] > t[1]:
                    t = xx
            seg.append(t)
        s2 = {}
        for s in seg:
            if s[1] not in s2:
                s2[s[1]] = []
            s2[s[1]].append(s)
        seg = []
        for k in s2:
            t = s2[k][0]
            for xx in s2[k]:
                if xx[0] < t[0]:
                    t = xx
            seg.append(t)
            
            
        seg.sort(key=lambda x: x[0]) # 按區間左端點排序
 
        
        if not seg or seg[0][0] != 0: # 區間數量是 0 或者第一個區間不能覆蓋 0，直接返回 -1
            return -1
        
        i = 0
        ans = 1
        while seg[i][1] != n:
            nx = i
            j = 1 + i
            while j < len(seg) and seg[j][0] <= seg[i][1]:
                if seg[nx][1] < seg[j][1]:
                    nx = j
                j += 1
            if nx == i:
                return -1
            ans += 1
            i = nx
        return ans

謝謝閱讀

歡迎訪問個人博客 https://codeplot.top/

個人博客的刷題分類