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

977.有序数组的平方

题目描述 ：给你一个按 非递减顺序 排序的整数数组 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]

思考：这道题涉及排序，奈何我半天想不起来快排怎么写，为了先AC，用了sort()。
可以先平方再排序
也可以先绝对值后排序再平方

1. 偷懒做法——暴力排序

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        for i in range(len(nums)):
            nums[i] = nums[i] ** 2
        nums.sort()  # 快速排序
        return nums

时间复杂度：$$O(n+nlogn)$$

3. 双指针做法：
   有序数组平方后最大值只能在数组两端，非左端即右端，不可能是中间
   故可以考虑双指针法，i指向起始位置， j指向终止位置
   定义一个新数组result，和A一样大，让k指向result的终止位置

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

时间复杂度：$$O(n)$$

209. 长度最小的子数组

题目描述：给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

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

1. 暴力解法

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

时间复杂度： $$O(n^2)$$
leetcode超出时间限制

2. 滑动窗口解法
   滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。
   在暴力解法中，是一个for循环滑动窗口的起始位置，一个for循环为滑动窗口的终止位置，用两个for循环 完成了一个不断搜索区间的过程。
   而滑动窗口只用一个for循环，且该循环的索引表示 滑动窗口 的终止位置，如图
   
   在本题中实现滑动窗口，主要确定如下三点：

• 窗口内是什么？
• 如何移动窗口的起始位置？
• 如何移动窗口的结束位置？

窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。

窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

解题的关键在于 窗口的起始位置如何移动，如图所示：

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        i, sum = 0, 0
        n = len(nums)
        sub_length = 0
        result = float(inf)
        for j in range(n):
            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 == float(inf):
            return 0
        return result

滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。

59. 螺旋矩阵 II

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        start_x, start_y = 0, 0
        loop = n // 2
        mid = n // 2
        count = 1
        res = [[0]*n for _ in range(n)]
        for offset in range(1, loop+1):
            for i in range(start_y, n - offset):
                res[start_x][i] = count
                count += 1
            for i in range(start_x, n - offset):
                res[i][n-offset] = count
                count += 1
            for i in range(n-offset, start_y, -1):
                res[n-offset][i] = 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

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