977.有序数组的平方 209.长度最小的子数组 59.螺旋矩阵II

977.有序数组的平方

给你一个按  非递减顺序 排序的整数数组  nums，返回  每个数字的平方 组成的新数组，要求也按  非递减顺序 排序。

力扣

数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间

双指针法: i指向起始位置，j指向终止位置

时间复杂度为O(n)   (暴力排序时间复杂度为O(n))

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        i = 0
        size = len(nums)
        j = size - 1
        result = [-1] * size
        k = size - 1
        while i <= j:
            if nums[i] * nums[i] > nums[j] * nums[j]:
                result[k] = nums[i] * nums[i]
                i += 1
            else:
                result[k] = nums[j] * nums[j]
                j -= 1
            k -= 1
        return result

209.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 

滑动窗口 (其实也是双指)

只用一个for循环，那么这个循环的索引，一定是表示滑动窗口的终止位置

时间复杂度: 看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        i = 0
        sum = 0
        result = len(nums) + 1
        for j in range(len(nums)):
            sum += nums[j]
            while sum >= target:
                sub_length = j - i + 1
                if sub_length < result:
                    result = sub_length
                sum -= nums[i]
                i += 1
        if result == len(nums) + 1:
            return 0
        return result

59.螺旋矩阵II

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

边界条件： 要注意有固定规则， 循环不变量原则

注意初始化res

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        # loop n // 2, if n is an odd number, special process to the middle value
        offset = 1
        start_x = 0
        start_y = 0
        count = 1
        loop = n // 2
        #res = [[0] * n] * n
        # ** initailize res, the above line does't work
        res = [[0 for _ in range(n)] for _ in range(n)]
        for _ in range(loop, 0, -1):
            for j in range(start_y, n - offset):
                res[start_x][j] = count
                count += 1
            j += 1
            for i in range(start_x, n - offset):
                res[i][j] = count
                count += 1
            i += 1
            for j in range(n - offset, start_y , -1):
                res[i][j] = count 
                count += 1
            for i in range(n - offset, start_x, -1):
                res[i][start_y] = count
                count += 1
            start_x += 1
            start_y += 1
            offset += 1

        if n % 2:
            mid = n // 2
            res[mid][mid] = count
        return res