代码随想录算法训练营第二天| 977.有序数组的平方、209.长度最小的子数组、59.螺旋矩阵II。

LC977 有序数组得平方https://leetcode.cn/problems/squares-of-a-sorted-array/description/

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

示例 1：

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

示例 2：

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

看到题目中提到按顺序排列就已经要想到指针了，指针法可以让暴力解法的复杂度下降一个指数级别。需要注意的点是什么时候退出循环，为了保证所有元素都被遍历所以不要忘记i=j的情况

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        i, j = 0, len(nums)-1
        result = []
        while i <= j:
            if abs(nums[i]) < abs(nums[j]):
                result.append(nums[j]**2)
                j -= 1
            else:
                result.append(nums[i]**2)
                i += 1
        result.reverse()
        return result

LC209 长度最小的子数组https://leetcode.cn/problems/minimum-size-subarray-sum/

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

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

示例 1：

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

示例 2：

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

示例 3：

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

这题是滑动窗口的入门题，用和值比较target值，来改变窗口左右界，在自写的代码中判断循环退出条件时，多考虑了一下如果窗口大小为1大于target情况滑动窗口左界右移的情况，仔细观察循环写冗杂了，因为右界是一定会走到数组最右的

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        i,j = 0, 0
        nums_sum = nums[0]
        min_len = float("inf")
        while i<len(nums) and j<len(nums) and i<=j:
            print(i,j)
            if nums_sum >= target:
                min_len = min(min_len, j-i+1)
                nums_sum -= nums[i]
                i += 1
            else:
                j += 1
                if j >= len(nums):
                    break
                nums_sum += nums[j]
        return 0 if min_len == float("inf") else min_len

修改了一下代码，通过for循环来遍历，在每次右界固定时考虑左界位置，在左界移动时会从和值中移除对应元素，再通过while循环判定时，当左界超过有界时和值为0就可以进入下一次for循环。在滑动窗口的题中，用for循环来控制右界是一个常用的思路。

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        length = len(nums)
        slow = 0
        fast = 0
        min_len = float("inf")
        cur_sum = 0

        for fast in range(length):
            cur_sum += nums[fast]
            while cur_sum >= target:
                min_len = min(min_len, fast-slow+1)
                cur_sum -= nums[slow]
                slow += 1
            
        return min_len if min_len != float("inf") else 0

59 螺旋矩阵Ⅱhttps://leetcode.cn/problems/spiral-matrix-ii/description/

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

示例 1：

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

示例 2：

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

此类题都使用同一种思路，螺旋遍历，为了保持遍历的一致性每次都空一个元素作为下一次遍历的起始元素，以转回来为一次循环，确定循环次数搞懂偏移量概念后，这题就没什么难点了，因为矩阵是正方形矩阵，所以中心值得补录只需要考虑单个值，我觉得更难的情况出现在LC54 螺旋矩阵之中，当矩阵不再一定是正方形矩阵的情况。

class Solution(object):
    def generateMatrix(self, n):
        """
        :type n: int
        :rtype: List[List[int]]
        """
        loop = n // 2
        start_x, start_y = 0, 0
        offset = 1
        matrix = [[0]*n for _ in range(n)]
        cur = 1
        for _ in range(loop):
            for y in range(start_y, n-offset):
                matrix[start_x][y] = cur
                cur += 1
            for x in range(start_x, n-offset):
                matrix[x][n-offset] = cur
                cur += 1
            for y in range(n-offset, start_y, -1):
                matrix[n-offset][y] = cur
                cur += 1
            for x in range(n-offset, start_x, -1):
                matrix[x][start_y] = cur
                cur += 1
            start_x += 1
            start_y += 1
            offset += 1
        if n % 2 == 1:
            matrix[(n-1)/2][(n-1)/2] = cur
        return matrix