代码随想录训练营 Day 2

977.有序数组的平方

老样子，不看讲解先自己做，题目要求进阶时间复杂度o(n)，于是想到了双向双指针：

循环的每次迭代都比较 nums[left] 和 nums[right] 的平方，并执行一次数组操作（添加元素到 res）。最坏情况下，循环执行次数等于 nums 的长度 n。

时间复杂度：o(n)

空间复杂度：o(n)

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        n = len(nums)
        left = 0
        right = n - 1
        res = []

        while left <= right:
            if nums[left] ** 2 >= nums[right] ** 2:
                res.append(nums[left]** 2)
                left += 1
            else:
                res.append(nums[right]** 2)
                right -= 1
        
        return res[::-1]

 讲解思路一样，就不重复了。

209.长度最小的子数组

首先自己做，一个滑动窗口的思想：

使用两个指针，fast指向终止位置，slow指向起始位置。当sum小于target的时候，不断更新fast，继续累加，直到sum >= target，将当前的子数组的长度记录下来，然后更新slow，直到fast达到最后nums的最后一个元素。

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        slow = 0
        fast = 0
        res = []

        while fast <= len(nums):
            if sum(nums[slow:fast+1]) < target:
                fast += 1
            elif sum(nums[slow:fast+1]) >= target:
                res.append(fast-slow+1)
                slow += 1
                
        if not res:
            return 0

        return min(res)

用别的语言还能ac，但是用python就会超时。。。

分析后，发现影响时间的是“sum(nums[slow:fast+1])”因为每次更新sum都会从头算起，这就造成时间复杂度是o(nk)的，k是子数组的长度。

然后我改用sum变量实时记录跟踪子数组的和，遇到sum >= target，就更新sum减去slow和fast对应元素的值，更新slow，继续迭代，实现o(n)复杂度的滑动窗口。

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        slow = 0
        fast = 0
        sum = 0
        res = []

        while fast < len(nums):
            sum += nums[fast]
            if sum < target:
                fast += 1
            elif sum >= target:
                res.append(fast-slow+1)
                sum = sum - nums[slow] - nums[fast]
                slow += 1

        if not res:
            return 0

        return min(res)

看了讲解，思路和我的第二种差不多，就不再实现。

59.螺旋矩阵II

没有思路，直接看讲解，使用了和二分法核心思想左闭右开区间：

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        if n == 1:
            return [[1]]
        loop, mid = n//2, n//2
        startX = 0
        startY = 0
        offset = 1
        count = 1
        nums = [[0] * n for _ in range(n)]

        for _ in range(loop): # (i, j)
            for j in range(startY, n-offset):
                nums[startX][j] = count
                count += 1
            for i in range(startX, n-offset):
                nums[i][n-offset] = count
                count += 1
            for j in range(n-offset, startY, -1):
                nums[n-offset][j] = count
                count += 1
            for i in range(n-offset, startX, -1):
                nums[i][startY] = count
                count += 1
            
            startX += 1
            startY += 1
            offset += 1

        if n % 2:
            nums[mid][mid] = count
        return nums