Day2代码随想录-977.有序数组的平方、209. 长度最小的子数组、59. 螺旋矩阵II

977有序数组的平方

思路：这是一个有序数组，虽然其中有负数，但是平方后的最大元素出现在数组的两端不可能是中间，例如[-4, -1, 0, 1, 4, 5]→[16,1,0,16,25]所以考虑到双指针的思想

（1）暴力：

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        nums = [nums[i] * nums[i] for i in range(len(nums))]
        for i in range(len(nums)-1):
            for j in range(i+1, len(nums)):
                if nums[i] > nums[j]:
                    t = nums[i]
                    nums[i] = nums[j]
                    nums[j] = t
        return nums

（2）双指针

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        nums = [nums[i] * nums[i] for i in range(len(nums))]
        left = 0
        right = len(nums)-1
        k = len(nums)-1
        result = [float('inf')] * len(nums) # 注意创建的方式
        while k>=0:
            if nums[left] > nums[right]:
                result[k] = nums[left]
                k -=1
                left +=1
            else:
                result[k] = nums[right]
                k -=1
                right -=1
        return result

209 长度最小的子数组

思路：滑动窗口（类似双指针），一个for循环做两个for循环的事情

循环的j是终止位置，先在i不动的情况下移动j++直到窗口内数的总和大于target（扩），然后移动i++在保持大于target的情况下进一步缩短窗口长度（缩）；直到小于target时再移动j，以此重复

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        i = 0 # 左端
        sum_sub = 0 # 总和
        min_sub = float('inf') # 最小长度
        for j in range(len(nums)):
            sum_sub += nums[j] # 扩
            while sum_sub >=target: #缩
                min_sub = min(min_sub, j-i+1)
                sum_sub -= nums[i]
                i += 1
        if sum_sub<target and min_sub > len(nums):
            min_sub = 0
        return min_sub

59 螺旋矩阵II

**思想：（1）**左闭右开的区间，要统一每条边移动的处理方式，比如这里都不算最后一个点；（2）需要循环的圈数为n/2，如果是奇数边要单独处理中间的值：为什么是n/2呢？因为每次循环相当于缩了2列，所以要遍历的圈数是2的倍数

想法进阶：用偏移量表示，用bool变量控制

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        nums = [[0] * n for _ in range(n)]
        startx, starty = 0, 0               # 起始点
        loop, mid = n // 2, n // 2          # 迭代次数、n为奇数时，矩阵的中心点
        count = 1                           # 计数

        for offset in range(1, loop + 1) :      # 每循环一层偏移量加1，偏移量从1开始
            for i in range(starty, n - offset) :    # 从左至右，左闭右开
                nums[startx][i] = count
                count += 1
            for i in range(startx, n - offset) :    # 从上至下
                nums[i][n - offset] = count
                count += 1
            for i in range(n - offset, starty, -1) : # 从右至左
                nums[n - offset][i] = count
                count += 1
            for i in range(n - offset, startx, -1) : # 从下至上
                nums[i][starty] = count
                count += 1                
            startx += 1         # 更新起始点
            starty += 1

        if n % 2 != 0 :			# n为奇数时，填充中心点
            nums[mid][mid] = count 
        return nums

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        dx = [0, 1, 0, -1] # x的偏移量，注意x是行
        dy = [1, 0, -1, 0] # y的偏移量
        if n ==0:
            return []
        bool_ma = [[False]*n for _ in range(n)] # 标记已经使用过的点
        res = [[0]*n for _ in range(n)]
        i = 1 # 计数
        x,y,d =0,0,0 # d是偏移转向转换
        while i <=n*n:
            res[x][y] = i
            bool_ma[x][y] =True
            # print(res)
            a = x+dx[d] #先模拟一下会不会越界
            b = y+dy[d]
            if n>a>=0 and n>b>=0 and bool_ma[a][b] ==False:
                i+=1
            else:
                d = (d+1)%4
                i +=1
            x = x+dx[d]
            y = y+dy[d]
        return res