数组章节的进阶54. 螺旋矩阵、904. 水果成篮、76. 最小覆盖子串、26. 删除有序数组中的重复项

54. 螺旋矩阵

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        m, n = len(matrix), len(matrix[0])
        res = [] #存放遍历后的结果
        startx = starty = 0

        for offset in range(min(m, n)//2): #offset初始值为0 左闭右开 range(1,1):不循环了

            for j in range(starty, n-offset-1): #从左到右
                res.append(matrix[startx][j])

            for i in range(startx, m-offset-1):#从上到下
                res.append(matrix[i][n-offset-1])

            for j in range(n-offset-1, starty,-1):#从右到左
                res.append(matrix[m-offset-1][j])

            for i in range(m-offset-1,startx, -1): #从下到上
                res.append(matrix[i][starty])
            
            startx += 1
            starty += 1
        
        if min(m, n) % 2 == 1:
            offset = min(m, n) // 2
            if m <= n:
                for j in range(offset, n-offset):
                    res.append(matrix[offset][j])
            else:
                for i in range(offset, m-offset):
                    res.append(matrix[i][n-offset-1])
        
        return res

 904. 水果成篮

滑动窗口+哈希表

class Solution:
    def totalFruit(self, fruits: List[int]) -> int:
        #哈希表（键：树的种类，值：出现的次数）记录滑动窗口内的数，以及出现的次数
        cnt = Counter()

        left = 0 #滑动窗口的左边界
        ans = 0 #记录收集水果的最大数目

        #滑动窗口的右边界在循环里迭代器里赋予初值
        for right, x in enumerate(fruits):
            cnt[x] += 1
            while len(cnt) > 2:
                cnt[fruits[left]] -= 1
                if cnt[fruits[left]] == 0:
                    cnt.pop(fruits[left])
                left += 1
            ans = max(ans, right-left+1)
        
        return ans

76. 最小覆盖子串

 滑动窗口+字典（哈希表）

class Solution:
    def minWindow(self, s: str, t: str) -> str:
        #哈希表维护窗口内的字符
        need = collections.defaultdict(int)
        #遍历子字符串t存储在need中
        for i in t:
            need[i] += 1
        #记录一共需要多少字符，无需遍历哈希表（字典）
        needCnt  = len(t)
        #初始化滑动窗口
        res = (0, float('inf'))
        i = 0

        for j, c in enumerate(s):
            if need[c] > 0:
                needCnt -= 1
            #need中的字符可为负，则说明滑动窗口内有多余的字符
            need[c] -= 1
            #滑动窗口包含了所有t的元素，但是有可能多包含了
            if needCnt == 0:
                while True:
                    c = s[i]
                    if need[c] == 0:
                        break
                    need[c] += 1 #删除多余字符
                    i += 1
                if j - i < res[1] - res[0]:
                    #更新滑动窗口
                    res = (i, j)
                #i增加一位，继续寻找满足条件的子串，直到j遍历完s
                need[s[i]] += 1
                needCnt += 1
                i += 1
        
        return '' if res[1] > len(s) else s[res[0]: res[1]+1]

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

快慢双指针

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        #双指针
        s = 0
        f = 1
        while f < len(nums):
            if nums[s] != nums[f]:
                s = s + 1
                nums[s] = nums[f]
            f += 1

        return s + 1

844. 比较含退格的字符串

匹配消除：栈；双指针

class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        #从后向前双指针
        #同时从后向前遍历S和T（i初始为S末尾，j初始为T末尾），记录#的数量，模拟消除的操作，如果#用完了，就开始比较S[i]和S[j]。
        #如果S[i]和S[j]不相同返回false，如果有一个指针（i或者j）先走到的字符串头部位置，也返回false。空间：O(1)
        sSkipNum = tSkipNum = 0
        i = len(s) - 1
        j = len(t) - 1
        while True:
            while i >= 0: #从后向前，消除S的#
                if s[i] == '#':
                    sSkipNum += 1
                else:
                    if sSkipNum > 0:
                        sSkipNum -= 1
                    else:
                        break
                i -= 1
            
            while j >= 0: #从后向前，消除T的#
                if t[j] == '#':
                    tSkipNum += 1
                else: 
                    if tSkipNum > 0:
                        tSkipNum -= 1
                    else:
                        break
                j -= 1
            #后半部分#消除完了，接下来比较S[i] != T[j]
            #S或者T遍历到头了
            if i < 0 or j < 0:
                break #这有跳出循环的条件
            if s[i] != t[j]:
                return False
            #相同就同时往下减
            i -= 1
            j -= 1
        
        #说明S和T同时遍历完毕
        if i == -1 and j == -1:
            return True
        return False