python leetcode 71-80

# 71

class Solution:
    def simplifyPath(self, path):
        path = path.split('/')
        stack = []
        for i in path:
            if i == '..':
                if stack:
                    stack.pop()
            elif i and i != '.':
                stack.append(i)
        return '/' + '/'.join(stack)

# 72
class Solution:
     def minDistance(self,word1,word2):
        n1, n2 = len(word1), len(word2)
        dp = [[0] * (n2+1) for _ in range(n1+1)]
        for j in range(1, n2+1):
            dp[0][j] = j
        for i in range(1, n1+1):
            dp[i][0] = i
        for i in range(1, n1+1):
            for j in range(1, n2+1):
                if word1[i-1] == word2[j-1]:
                    dp[i][j] = dp[i-1][j-1]
                else:
                    dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1]) + 1
        return dp[-1][-1]

# 73
class Solution:
    def setZeroes(self, matrix: List[List[int]]) -> None:
        m = len(matrix)
        n = len(matrix[0])
        A = []
        for i in range(m):
            for j in range(n):
                if matrix[i][j] == 0:
                    A.append(i)
                    A.append(j)
        d = 0
        while d < len(A):
            for i in range(n):
                matrix[A[d]][i] = 0
            d += 1
            for j in range(m):
                matrix[j][A[d]] = 0
            d += 1
        return matrix

# 74
class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        if not matrix: return False
        row = len(matrix)
        col = len(matrix[0])
        l , r = 0 , row * col
        while l < r:
            mid = l + (r - l) // 2
            if matrix[mid//col][mid%col] < target:
                l = mid + 1
            else:
                r = mid
        return l < row * col and matrix[l // col][l % col] == target

# 75 一行 or 正常
class Solution:
    def sortColors(self, nums: List[int]) -> None:
        return nums.sort()
class Solution:
    def sortColors(self, nums: List[int]) -> None:
        n = len(nums)
        l , i , r = 0 , 0 , n - 1
        while i <= r:
            if nums[i] == 0:
                nums[i] , nums[l] = nums[l] , nums[i]
                l += 1
                i += 1
            elif nums[i] == 2:
                nums[i] , nums[r] = nums[r] , nums[i]
                r -= 1
            else:
                i += 1
        return nums

# 76
class Solution:
    def minWindow(self, s: str, t: str) -> str:
        need = collections.Counter(t)
        needcnt = len(t)
        res = [0,float("inf")]; left = 0
        for right,val in enumerate(s):
            if need[s[right]] > 0:
                needcnt -= 1
            need[s[right]] -= 1
            if needcnt == 0:
                while True:
                    if need[s[left]] == 0:
                        break
                    need[s[left]] += 1
                    left += 1
                if right - left < res[1] - res[0]:
                    res = [left,right]
                need[s[left]] += 1
                needcnt += 1
                left += 1
        return s[res[0]:res[1]+1] if res[1] != float("inf") else ""

# 77
class Solution:
    def combine(self, n, k):
        res = []
        def backtrack(j , k , tmp):
            if k == 0:
                res.append(tmp)
                return
            for i in range(j , n + 1):
                backtrack(i + 1 , k - 1 , tmp + [i])
        backtrack(1 , k , [])
        return res

# 78
class Solution:
    def subsets(self, nums):
        result = [[]]
        for num in nums:
            for i in result[:]:
                item = i[:]
                item.append(num)
                result.append(item[:])
        return result

# 79
class Solution:
    def exist(self,board,word):
        m=len(board)
        n=len(board[0])
        def backtrack(i,j,k,tmp):
            if k==len(word):
                return True
            for x,y in [(-1,0),(0,-1),(0,1),(1,0)]:
                tmp_i, tmp_j = x + i, y + j
                if 0<=tmp_i<m and 0<=tmp_j<n and (tmp_i,tmp_j) not in tmp and board[tmp_i][tmp_j] == word[k]:
                    tmp.add((tmp_i,tmp_j))
                    if backtrack(tmp_i, tmp_j, k + 1, tmp):
                        return True
                    tmp.remove((tmp_i, tmp_j))
            return False
        for i in range(m):
            for j in range(n):
                if board[i][j]==word[0] and backtrack(i,j,1,{(i,j)}):
                    return True
        return False

# 80
class Solution:
    def removeDuplicates(self, nums): 
        if len(nums)<3:
            return len(nums)
        l = 0
        while l < len(nums) - 2:
            if nums[l] == nums[l + 2]:
                nums.pop(l + 2)
            else:
                l += 1
        return len(nums)