python算法打卡：209. 长度最小的子数组、59.螺旋矩阵

长度最小的子数组

暴力破解

时间复杂度O(n^2)

def minSubArrayLen(self, s: int, nums: List[int]) -> int:
        l = len(nums)
        min_len = float('inf')
        
        for i in range(l):
            cur_sum = 0
            for j in range(i, l):
                cur_sum += nums[j]
                if cur_sum >= s:
                    min_len = min(min_len, j - i + 1)
                    break
        
        return min_len if min_len != float('inf') else 0

滑动窗口

可以发现滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。
从而将O(n^2)暴力解法降为O(n)

def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        left, right = 0, 0
        l = len(nums)
        min_len = float('inf')
        sum = 0
        while right < l:
            sum += nums[right]
            while sum >= target:
                sum -= nums[left]
                min_len = min(min_len, right - left + 1)
                left += 1
            right += 1

        return min_len if min_len != float('inf') else 0

螺旋矩阵

和二分法类似，写的时候注意坚持循环不变量，行和列的左右两个顶点坚持左闭右开[left,right)

def generateMatrix(self, n: int) -> List[List[int]]:
    startx, starty = 0, 0 # 起始点
    loop = n // 2 # 循环圈数
    mid= n // 2 # 中心点
    nums = [[0] * n for _ in range(n)] # 初始化矩阵
    count = 1 # 每个空格的数字填充
    for offset in range(1, loop + 1):
        for j in range(starty, n - offset): # 上行从左到右
            nums[startx][j] = count
            count += 1

        for i in range(startx, n - offset): # 右行从上到下
            nums[i][n-offset] = count
            count += 1

        for j in range(n-offset,starty, -1): # 下行从右到左
            nums[n-offset][j] = count
            count += 1

        for i in range(n-offset, startx, -1): # 左行从下到上
            nums[i][starty] = count
            count += 1

        startx += 1
        starty += 1

	# 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
    if n % 2 != 0:
        nums[mid][mid] = count

    return nums