leetcode python刷题记录（八）（71~80）

leetcode python刷题记录（八）（71~80）

71. 简化路径

class Solution:
    def simplifyPath(self, path: str) -> str:
        stack=[]

        for p in path.split('/'):
            if p == '..':
                # 如果是'..'要返回上级目录
                if stack:
                    stack.pop()
            else:
                # 如果不是'..'
                # 是'.'的话就是当前目录本身，不需要加入stack
                if p and p != '.':
                    stack.append(p)

        return '/'+'/'.join(stack)

72. 编辑距离

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        n=len(word1)
        m=len(word2)
        dp=[[0 for _ in range(m+1)] for _ in range(n+1)]
        for i in range(n+1):
           dp[i][0]=i

        for i in range(m+1):
            dp[0][i]=i

        for i in range(1,n+1):
            for j in range(1,m+1):
                if word1[i-1]==word2[j-1]:
                    dp[i][j]=dp[i-1][j-1]
                else:
                    dp[i][j]=min(dp[i-1][j],dp[i][j-1],dp[i-1][j-1])+1

        return dp[-1][-1]

73. 矩阵置零

class Solution:
    def setZeroes(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        m=len(matrix)
        n=len(matrix[0])

        m_set=set()
        n_set=set()

        for i in range(m):
            for j in range(n):
                if matrix[i][j]==0:
                    m_set.add(i)
                    n_set.add(j)

        for i in range(m):
            for j in range(n):
                if i in m_set or j in n_set:
                    matrix[i][j]=0

        return matrix

74. 搜索二维矩阵

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        m=len(matrix)
        n=len(matrix[0])

        left=0
        right=m*n-1
        
        # 二分法，将矩阵看作一维升序序列
        while left <= right:
            mid=(left+right)//2
            cur=matrix[mid//n][mid%n]

            if target==cur:
                return True
            
            if cur > target:
                right=mid-1
            else:
                left=mid+1

        return False

75. 颜色分类

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        # 双指针，p1为0与1的边界，p2为1与2的边界
        p1,p2=0,len(nums)-1
        i=0

        while i <= p2:
            if nums[i]==0:
                nums[i],nums[p1]=nums[p1],nums[i]
                p1=p1+1
                i=i+1
            elif nums[i]==2:
                nums[i],nums[p2]=nums[p2],nums[i]
                p2=p2-1
            else:
                i=i+1

76. 最小覆盖子串

滑动窗口：

class Solution:
    def minWindow(self, s: str, t: str) -> str:

        # 使用哈希表来存储
        from collections import defaultdict
        window = defaultdict(int) # 哈希表维护的是[j,i]区间中各个字符出现多少次
        ht = defaultdict(int) # 哈希表维护的是t字符串各个字符出现多少次
        for char in t:
            ht[char] += 1

        res = ""
        # 滑动窗口内有效的字母个数，因为窗口内可能有些字母无效
        cnt = 0
        j = 0

        for i in range(len(s)):
            # 往滑动窗口加入当前元素
            window[s[i]] += 1

            # 假如加入当前元素后，当前元素在窗口内出现的次数没有超过要求的次数
            if window[s[i]] <= ht[s[i]]:
                cnt += 1

            # 检查 s[j]是否多余，因为s[i]有可能等于s[j], 如果是，则移除s[j]
            while j <= i and window[s[j]] > ht[s[j]]:
                window[s[j]] -= 1
                j += 1

            # 检查当前窗口已经包含了 T 中所有字符，更新答案
            if cnt == len(t):
                if res == "" or i - j + 1 < len(res):
                    res = s[j:i + 1]

        return res

77. 组合

dfs：

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        res=[]
        p=[]

        def dfs(k,step):
            if k==0:
                res.append(p[:])
                return

            for i in range(step,n+1):
                p.append(i)
                dfs(k-1,i+1) #是i+1保证升序，如[1,4],不会出现[4,1]
                p.pop()

        dfs(k,1)
        return res

78. 子集

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:

        res=[]
        path=[]

        def dfs(nums,step):
            
            if step==len(nums):
                res.append(path[:])
                return
            
            # 选 nums[i]
            path.append(nums[step])
            dfs(nums,step+1)
            path.pop()

            # 不选 nums[i]
            dfs(nums,step+1)
        
        dfs(nums,0)

        return res

79. 单词搜索

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        
        def dfs(board,word,step,x,y):
            if board[x][y]!=word[step]:
                return False
            
            if step==len(word)-1:
                return True
            
            dirs = [[-1,0],[0,1], [1,0],[0,-1]]
            temp  = board[x][y]
            board[x][y] = '.'

            for dx, dy in dirs:
                new_x = dx + x 
                new_y = dy + y 
                if new_x < 0 or new_x >= len(board) or new_y < 0 or new_y >= len(board[0]) or board[new_x][new_y] == '.':
                    continue
                if dfs(board, word, step + 1, new_x, new_y):
                    return True
                
            board[x][y] = temp

            return False

        for i in range(len(board)):
            for j in range(len(board[0])):
                if dfs(board, word, 0, i, j):
                    return True
                
        return False

80. 删除有序数组中的重复项 II

哈希表做法：

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        # 哈希表
        hashMap = Counter(nums)
        for k, v in hashMap.items():
            while v > 2:
                nums.remove(k)
                v = v - 1
        return len(nums)