大佬都是3-5分钟一题，而我10分钟一题，最后一题还不会。。qaq
5356. 矩阵中的幸运数
给你一个
m * n的矩阵，矩阵中的数字 各不相同 。请你按 任意 顺序返回矩阵中的所有幸运数。幸运数是指矩阵中满足同时下列两个条件的元素：
- 在同一行的所有元素中最小
- 在同一列的所有元素中最大
示例 1：
输入：matrix = [[3,7,8],[9,11,13],[15,16,17]] 输出：[15] 解释：15 是唯一的幸运数，因为它是其所在行中的最小值，也是所在列中的最大值。
class Solution(object):
def luckyNumbers (self, matrix):
"""
:type matrix: List[List[int]]
:rtype: List[int]
"""
if not matrix:
return []
if len(matrix)==1:
return [min(matrix[0])]
for i,k in enumerate(matrix):
m = min(k)
m_index = k.index(m)
res = []
for j in range(len(matrix)):
if i!=j:
res.append(matrix[j][m_index])
if m >= max(res):
return [m]
return [] #有可能不存在答案 坑 出了个Bug
class Solution:
def luckyNumbers (self, matrix: List[List[int]]) -> List[int]:
n=len(matrix)
m=len(matrix[0])
r=[]
for i in range(n):
for j in range(m):
if matrix[i][j]==min(matrix[i]) and matrix[i][j]==max(matrix[k][j] for k in range(n)):
r.append(matrix[i][j])
return r请你设计一个支持下述操作的栈。
实现自定义栈类 CustomStack ：
CustomStack(int maxSize)：用 maxSize 初始化对象，maxSize 是栈中最多能容纳的元素数量，栈在增长到 maxSize 之后则不支持 push 操作。
void push(int x)：如果栈还未增长到 maxSize ，就将 x 添加到栈顶。
int pop()：返回栈顶的值，或栈为空时返回 -1 。
void inc(int k, int val)：栈底的 k 个元素的值都增加 val 。如果栈中元素总数小于 k ，则栈中的所有元素都增加 val 。
class CustomStack(object):
def __init__(self, maxSize):
"""
:type maxSize: int
"""
self.maxSize = maxSize
self.stack = []
def push(self, x):
"""
:type x: int
:rtype: None
"""
if len(self.stack)<self.maxSize:
self.stack.append(x)
def pop(self):
"""
:rtype: int
"""
if not self.stack:
return -1
res = self.stack.pop()
return res
def increment(self, k, val):
"""
:type k: int
:type val: int
:rtype: None
"""
for i in range(min(k,len(self.stack))):
self.stack[i]+=val给你一棵二叉搜索树，请你返回一棵 平衡后 的二叉搜索树，新生成的树应该与原来的树有着相同的节点值。
如果一棵二叉搜索树中，每个节点的两棵子树高度差不超过 1 ，我们就称这棵二叉搜索树是 平衡的 。
如果有多种构造方法，请你返回任意一种。
1.利用BST中序有序的特点也到排序数组res
2.利用res构造符合要求的树
class Solution:
def balanceBST(self, root: TreeNode) -> TreeNode:
res = []
def dfs(root):
if not root:
return
dfs(root.left)
res.append(root.val)
dfs(root.right)
dfs(root)
def build(l):
if not l:
return None
mid = len(l)//2
root = TreeNode(l[mid])
root.left = build(l[:mid])
root.right = build(l[mid+1:])
return root
return build(res)公司有编号为 1 到 n 的 n 个工程师，给你两个数组 speed 和 efficiency ，其中 speed[i] 和 efficiency[i] 分别代表第 i 位工程师的速度和效率。请你返回由最多 k 个工程师组成的 最大团队表现值 ，由于答案可能很大，请你返回结果对 10^9 + 7 取余后的结果。
团队表现值 的定义为：一个团队中「所有工程师速度的和」乘以他们「效率值中的最小值」。
示例 1：
输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 2
输出：60
解释：
我们选择工程师 2（speed=10 且 efficiency=4）和工程师 5（speed=5 且 efficiency=7）。他们的团队表现值为 performance = (10 + 5) * min(4, 7) = 60 。方法：贪心，本质上是最看重效率就是说最大值比较看重效率。维护一个堆，堆里存最大的k位工程师的速度，因为遍历的效率越来越小，所以直接把堆里和当前工程师的总速度乘以当前效率就是目前最大值。
from heapq import heappush,heappop
class Solution:
def maxPerformance(self, n: int, speed: List[int], efficiency: List[int], k: int) -> int:
a=sorted([(i,j) for i,j in zip(speed,efficiency)],key=lambda x:-x[1])
q=[]
ans=0
sum=0
for x,y in a:
if len(q)==k:
b=heappop(q)
sum-=b
else:
b=0
heappush(q,max(b,x))
sum+=max(b,x)
ans=max(ans,y*sum)
return ans%1000000007