今日任务：

1. LeetCode977 有序数组的平方
2. LeetCode209 长度最小的子数组
3. LeetCode59 螺旋矩阵Ⅱ

今日心情：今天一天的课，在椅子上缩着坐了一天，腰好累。

资料来源：

977.有序数组的平方

209.长度最小的子数组

59.螺旋矩阵II

1 LeetCode977 有序数组的平方

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

在一开始看到这道题的时候，我原本是有思路的，想着从数组的两端同时向中间循环，被循环的值进行比较。但是只想着在原数组中进行操作了，想着根据比较的结果交换位置，但是越换越乱，在看了视频之后才如梦初醒。

python
from typing import List

# 对于取绝对值和insert函数这种 还是允许我稍微偷个懒吧（）
# 毕竟这里insert起到的作用起到的作用和反向填充数组是一样的
class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        first = 0
        last = len(nums) - 1
        return_list = list()
        while first <= last:
            if abs(nums[first]) < abs(nums[last]):
                return_list.insert(0, nums[last] * nums[last])
                last -= 1
            else:
                return_list.insert(0, nums[first] * nums[first])
                first += 1
        return return_list

2 LeetCode209 长度最小的子数组

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

输入：target = 4, nums = [1,4,4]
输出：1

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

在看到窗口之后，大致就知道这题是个什么思路了，只是在最后一轮要根据left结束循环的时候，总是数组越界，最后烦不胜烦直接while True然后在left += 1之后找条件break掉。

python
from typing import List

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        right, left, summary, return_len = 0, 0, nums[0], float('inf')
        # float('inf')即为python的无穷大
        while True:
            if summary >= target:
                if (left - right + 1) < return_len:
                    return_len = left - right + 1
                summary -= nums[right]
                right += 1
            else:
                left += 1
                if left >= len(nums):
                    break
                summary += nums[left]
        if return_len == float('inf'):
            return 0
        return return_len

3 LeetCode59 螺旋矩阵Ⅱ

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

输入：n = 1
输出：[[1]]

简而言之晕晕，晕的地方倒不是说怎么固定每次填充的区间，主要是体现在坐标上的加加减减有点晕。看了代码随想录的文档之后逐渐摸清了思路，然后写出来了。

python
from typing import List

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        return_list = list()
        for _ in range(n):
            return_list.append([0] * n)
        count, offset = 1, 1
        x, y = 0, 0  # 竖向是x 横向是y
        for _ in range(int(n / 2)):  # 圈数
            for y in range(y, n - offset):
                return_list[x][y] = count
                count += 1
            y += 1
            for x in range(x, n - offset):
                return_list[x][y] = count
                count += 1
            x += 1
            for y in range(y, offset - 1, -1):
                return_list[x][y] = count
                count += 1
            y -= 1
            for x in range(x, offset - 1, -1):
                return_list[x][y] = count
                count += 1
            y += 1
            offset += 1
        if (n % 2) != 0:
            return_list[int(n / 2)][int(n / 2)] = count
        return return_list