leetcode每天三道新题

leetcode每日一题

3033. 修改矩阵 - 力扣（LeetCode）

今天这道题是非常简单，估计大家看看代码就会了。

时间复杂度：O（m * n）

空间复杂度：O（m）

class Solution:
    def modifiedMatrix(self, matrix: List[List[int]]) -> List[List[int]]:
        arr = []
        n,m = len(matrix),len(matrix[0])
        for i in range(m):
            a = -inf
            for j in range(n):
                a = max(a,matrix[j][i])
            arr.append(a)
        for i in range(m):
            for j in range(n):
                if matrix[j][i] == -1:
                    matrix[j][i] = arr[i]
        return matrix

这里有一个小小的优化，优化一下空间

这种做法就是每次求的时候先把这一行的最大值求出来，就不用额外再开一个数组了。

时间复杂度：O（n * m）

空间复杂度：O（1）

class Solution:
    def modifiedMatrix(self, matrix: List[List[int]]) -> List[List[int]]:
        for j in range(len(matrix[0])):
            mx = max(row[j] for row in matrix)
            for row in matrix:
                if row[j] == -1:
                    row[j] = mx
        return matrix

leetcode139（微软题库）

139. 单词拆分 - 力扣（LeetCode） 

这道题我用的动态规划，用一个dp来判断是否被选，两层循环来看是否可以一直到最后，到了最后就是True，没到就是False。

时间复杂度：O（n**2）

空间复杂度：O（n**2）

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> bool:       
        n=len(s)
        dp=[False]*(n+1)
        dp[0]=True
        wordDict = set(wordDict)
        for i in range(n):
            for j in range(i+1,n+1):
                if(dp[i] and (s[i:j] in wordDict)):
                    dp[j]=True
        return dp[-1]

leetcode253会员题目（微软题库）

这道题折磨了我好久，我也不知道为啥我的想法有问题

大家有空帮我看看到底咋回事呀，为什么到最后几个测试用例过不去了

我得想法是先搞一个arr，用来统计需要的会议室，然后再把题目给的那个数组按照第一个元素排序，然后一个一个往里面加，如果能合并，那就给他合并一下，不能合并，就在arr里面加

class Solution:
    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
        intervals.sort(key = lambda x : x[0])
        arr = []
        for i in intervals:
            a = True
            for y in arr:
                if y[1] <= i[0]:
                    y[1] = i[1]
                    arr.sort(key = lambda x : x[1])
                    a = False
            if a:
                arr.append(i)
        return len(arr)

下面就是别人的代码，我照着学了学，也理解了别人是咋做的

找到每次有会议开始时占用会议室数目的最大值即可

时间复杂度：O（nlogn）

空间复杂度：O（n）

class Solution:
    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
        intervals.sort(key = lambda x:x[0])
        pq = []
        ans = 0
        for a in intervals:
            heapq.heappush(pq, a[1])
            while(len(pq) and pq[0] <= a[0]):
                heapq.heappop(pq)
            ans = max(ans, len(pq))
        return ans