算法训练 | leetcode 977. 有序数组的平方 209. 长度最小的子数组 59. 螺旋矩阵 II

977. 有序数组的平方

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

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

python3:采用双指针的方法，因为是递增，所以最大值一定在两边，所以指针分别从两边出发。

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

注意：边界处理和指针的移动

209. 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

• 1 <= target <= 109
• 1 <= nums.length <= 105
• 1 <= nums[i] <= 105

示例：

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

python3:滑动窗口的典型用法，借助双指针，实现o(n)时间复杂度。

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        num_sum, slow, fast = 0, 0, 0
        n = len(nums)
        ans = n +1
        while fast <n:
            num_sum += nums[fast]
            while num_sum >= target:
                ans = min(ans, fast-slow+1)
                num_sum-=nums[slow]
                slow+=1
            fast+=1
        return 0 if ans==n+1  else ans

59. 螺旋矩阵 II

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

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

python:

class Solution(object):
    def generateMatrix(self, n):
        offset, count= 1, 1
        x, y = 0, 0 
        matrix = [[0]*n for _ in range(n)]
        for _ in range(n//2):
            for j in range(x, n-offset):
                matrix[x][j] = count
                count += 1
            j+=1
            for i in range(y, n-offset):
                matrix[i][j] = count
                count +=1 
            i+=1
            for j in range(n-offset, x, -1):
                matrix[i][j] = count
                count+=1
            j-=1
            for i in range(n-offset, y, -1):
                matrix[i][j] =count
                count+=1
            x+=1
            y+=1
            offset+=1
        if n%2 !=0:
            matrix[n//2][n//2] = count
        return matrix

python3:

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        nums = [[0] * n for _ in range(n)]
        startx, starty = 0, 0               # 起始点
        loop, mid = n // 2, n // 2          # 迭代次数、n为奇数时，矩阵的中心点
        count = 1                           # 计数

        for offset in range(1, loop + 1) :      # 每循环一层偏移量加1，偏移量从1开始
            for i in range(starty, n - offset) :    # 从左至右，左闭右开
                nums[startx][i] = count
                count += 1
            for i in range(startx, n - offset) :    # 从上至下
                nums[i][n - offset] = count
                count += 1
            for i in range(n - offset, starty, -1) : # 从右至左
                nums[n - offset][i] = count
                count += 1
            for i in range(n - offset, startx, -1) : # 从下至上
                nums[i][starty] = count
                count += 1                
            startx += 1         # 更新起始点
            starty += 1

        if n % 2 != 0 :			# n为奇数时，填充中心点
            nums[mid][mid] = count 
        return nums

注意：一定要注意边界条件，代码一直采用左闭右开的方式处理边界，也可以采用左开右闭方式（不常用），感谢Carl哥的指导进一步理解边界处理。

题目来源：力扣（LeetCode）