leetcode 第 180 场周赛 - python 解法

5356. 矩阵中的幸运数

class Solution:
    def luckyNumbers (self, matrix: List[List[int]]) -> List[int]:
        rmin = [min(x) for x in matrix]
        cmax = []
        n = len(matrix)
        m = len(matrix[0])
        for i in range(m):
            maxv = matrix[0][i]
            for j in range(1, n):
                maxv = max(maxv, matrix[j][i])
            cmax.append(maxv)
        ans = []
        for i in range(n):
            for j in range(m):
                if matrix[i][j] == rmin[i] and matrix[i][j] == cmax[j]:
                    ans.append(matrix[i][j])
        return ans

5357. 设计一个支持增量操作的栈

创建 self.s = [] 作为栈。但是 s 中每个元素第一个是真实的值，第二个是增加的值，每次 increment 操作，直接增加栈里元素，而是记录在栈里相应位置的元素的这个列表中，直到 pop 的才加起来，而且累加到前面一个元素上。

class CustomStack:

    def __init__(self, maxSize: int):
        self.size = 0
        self.maxSize = maxSize
        self.s = []

    def push(self, x: int) -> None:
        if self.size < self.maxSize:
            self.s.append((x, 0)
            self.size += 1


    def pop(self) -> int:
        if self.size == 0:
            return -1
        x, inc = self.s.pop()
        if len(self.s) > 0:
            self.s[-1][1] += inc
        self.size -= 1
        return x + inc


    def increment(self, k: int, val: int) -> None:
        if self.size > 0:
            k -= 1
            k = min(k, self.size-1)
            self.s[k][1] += val

5179. 将二叉搜索树变平衡

我的方法是遍历树 -> 转数组 -> 排序 -> 构建二叉搜索树

class Solution:
    def balanceBST(self, root: TreeNode) -> TreeNode:
        ls = []
        def vis(t):
            if not t: return
            ls.append(t)
            vis(t.left)
            vis(t.right)
        vis(root)
        ls.sort(key=lambda t:t.val)
        def build(l, r):
            if l == r: 
                ls[l].left = None
                ls[l].right = None
                return ls[l]
            if l + 1 == r:
                ls[r].left = ls[l]
                ls[l].left = None
                ls[l].right = None
                ls[r].right = None
                return ls[r]
            mid = (l+r)>>1
            ls[mid].left = build(l, mid-1)
            ls[mid].right = build(mid+1, r)
            return ls[mid]
        return build(0, len(ls)-1)

5359. 最大的团队表现值

先按效率从大到小排列，刚开效率设为最大值，这是只能选效率最高的人，然后不断降低效率，效率越低，可以用的人越多，每次选择 k （如果人不够就选尽量多的人） 个满足效率要求的而且速度最大的人。

使用优先队列维护当前选中的所有人的速度，这样每次可以剔除速度最慢的人

import queue
class Solution:
    def maxPerformance(self, n: int, speed: List[int], efficiency: List[int], k: int) -> int:
        es = []
        for i in range(n):
            es.append((efficiency[i], speed[i]))
        es.sort(reverse=True)
        q = queue.PriorityQueue()
        q.put(es[0][1])
        mins = es[0][1]
        sm = mins
        mine = es[0][0]
        ans = sm * mine
        maxv = ans
        cur_min = -1
        for i in range(1, n):
            if i < k:
                q.put(es[i][1])
                sm += es[i][1]
                mine = min(mine, es[i][0])
                maxv = max(maxv, sm*mine)
            else:
                if cur_min == -1:
                    cur_min = q.get()
                if cur_min < es[i][0]:
                    sm += es[i][1]
                    sm -= cur_min
                    cur_min = -1
                    mine = min(mine, es[i][0])
                    maxv = max(maxv, sm*mine)
                    q.put(es[i][1])
        return maxv % 1000000007