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

977.有序数组的平方 - 🔗

💡这道题最开始的时候理解题目花了很长时间。首先，对于非递减顺序我是存在疑惑的。字面意思上理解，非递减顺序是不是就代表只要有一组元素不是递减的，那么整个数组就不算递减。出于这个思想，就整个被带偏了。后来，正确理解了非递减顺序之后，想到了要用暴力解法。有尝试过去思考怎么用双指针，但是想着想着又绕回暴力解法了。后来无奈去看了视频讲解才恍然大悟。还是对双指针没有理解透彻啊！

class Solution:
   def sortedSquares(self, nums: List[int]) -> List[int]:
       # result = []
       # slow, fast = 0, len(nums)-1
       # while(slow <= fast):
       #     if nums[slow] * nums[slow] >= nums[fast] * nums[fast]:
       #         result.insert(0,nums[slow] * nums[slow])
       #         slow += 1
       #     else:
       #         result.insert(0,nums[fast] * nums[fast])
       #         fast -= 1
       # return result

       result = [float('inf')] * len(nums) # 需要提前定义列表，存放结果
       slow, fast, key = 0, len(nums)-1, len(nums)-1
       while(slow <= fast):
           if nums[slow] * nums[slow] >= nums[fast] * nums[fast]:
               result[key] = nums[slow] * nums[slow]
               slow += 1
               key -= 1
           else:
               result[key] = nums[fast] * nums[fast]
               fast -= 1
               key -= 1
       return result

注释部分是最开始没看参考代码自己写的。因此没有提前给数据留好空间，后面不得不用insert去一个一个插入元素。看了参考代码后，也学到了如何用python创建一个特定长度的数组：result = [float('inf')] * len(nums)或者result = [0] * len(nums)，前者每个元素为无限大，后者每个元素为0。

209.长度最小的子数组 - 🔗

💡只想到了暴力解法，也很难得的竟然一次就写对了，很开心。但是不会用滑动窗口，甚至后面看了视频讲解和文档🔗，也还是不理解为什么参考代码里的时间复杂度是O(n)而不是O(n^2)。后来问了群友加上自己思考，right会执行n次，但是left也最多执行n次。

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        # 暴力解法 - 超出时间限制
        # length = len(nums)+1
        # for slow in range(len(nums)):
        #     sum = 0
        #     for fast in range(slow, len(nums)):
        #         sum += nums[fast]
        #         if sum >= target:
        #             if fast - slow + 1 <= length:
        #                 length = fast - slow + 1
        #             break
        # if length == len(nums)+1:
        #     return 0
        # else:
        #     return length

        # 滑动窗口法 - 繁琐
        # sums, i = 0, 0
        # length = len(nums)+1
        # for j in range(len(nums)):
        #     sums += nums[j]
        #     if sums >= target:
        #         if j - i +1 <= length:
        #             length = j - i + 1
        #         while (sums - nums[i]) >= target:
        #             i += 1
        #             sums -= nums[i]
        #             if j - i +1 <= length:
        #                 length = j - i + 1

        # if length == len(nums) + 1:
        #     return 0
        # else:
        #     return length

        # 滑动窗口法 - 简约
        total = 0
        left = 0
        min_length = float('inf')

        for right in range(len(nums)):
            total += nums[right]
            while(total >= target):
                min_length = min(min_length, right - left + 1)
                total -= nums[left]
                left += 1
        return min_length if min_length != float('inf') else 0

59.螺旋矩阵II - 🔗

💡这道题目感觉很绕，一直把自己绕在左闭右闭里，所以也一直不理解题目提示里说的要注意区间一致性。好像这题用左闭右闭很难做出来？因为不像左闭右开一样能找到规律。感觉另一个复杂点在于，如何把四种情况下，横纵坐标的区间定义清楚。

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        matrix = [[0] * n for i in range(n)] # 定义二维矩阵
        count = 1
        circle_count = 1  # 圈数
        max_circle_count = n // 2
        if n % 2 == 1:
            matrix[max_circle_count][max_circle_count] = n * n
        while circle_count <= max_circle_count:
            i, j = circle_count - 1, circle_count - 1
            # 左->右
            for j in range(circle_count - 1, n - circle_count):
                matrix[i][j] = count
                count += 1
            j += 1
            # 上->下
            for i in range(circle_count - 1, n - circle_count):
                matrix[i][j] = count
                count += 1
            i += 1
            # 右->左
            for j in range(n - circle_count, circle_count - 1, -1):
                matrix[i][j] = count
                count += 1
            j -= 1
            # 下->上
            for i in range(n - circle_count, circle_count - 1, -1):
                matrix[i][j] = count
                count += 1
            # 圈数增加
            circle_count += 1
        return matrix