Leetcode算法题 打卡day02

Leetcode算法题 打卡day02

有序数组的平方

Leetcode 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]

使用双指针解决，非递减顺序的整数数组，使用left和right两个指针，实际上是从两端向中间分别遍历两个非递减数组。只需要比较两侧指针对应的平方大小即可，将更大的反向填入new_nums数组中。

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        left = 0
        right = len(nums) - 1
        new_nums = [0]*len(nums)
        cur = len(nums) - 1
        while(left<=right):
            if nums[left]*nums[left] < nums[right]*nums[right]:
                new_nums[cur] = nums[right]*nums[right]
                right-=1
            else:
                new_nums[cur] = nums[left]*nums[left]
                left+=1
            cur-=1
        return new_nums

长度最小的子数组

给定一个含有 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

滑动窗口，使用两个while维护一个滑动窗口，第一个while寻找可行解，第二个while寻找最优解。

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        # 滑动窗口
        winSum = 0 # 表示窗口内数的总和
        maxSum = float('inf')
        left = right = 0
        flag = False
        while(right<len(nums)):
            c = nums[right] # 即将放入window的元素
            winSum+=c# 加入窗口
            right+=1
            while(winSum>=target):
                flag = True
                maxSum = min(maxSum, right-left) # 因为先放入window之后移动right,此处只需要right+1
                d = nums[left]
                winSum-=d
                left+=1
        return maxSum if flag else 0

螺旋矩阵

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

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        if n == 1:
            return [[1]]
        # 模拟过程
        x = 1
        # matrix = [[0] * n] * n
        matrix = [[0 for _ in range(n)] for _ in range(n)]
        startx = 0
        starty = 0

        # 对于一个正整数n会转n//2圈 对于奇数额外需要填充最后一个数据
        stride = n-1

        for _ in range(int(n/2)):
            for i in range(stride):
                matrix[startx][i+starty] = x
                x+=1 
            for j in range(stride):
                matrix[j+startx][stride+starty]= x
                x+=1
            for _i in range(stride,0,-1):
                matrix[stride+startx][_i+starty]= x
                x+=1
            for _j in range(stride,0,-1):
                matrix[_j+startx][starty]= x
                x+=1

            startx += 1
            starty += 1
            stride -= 2

        if n%2 == 0:
            return matrix
        else:
            matrix[startx][starty] = x
            return matrix

reference

代码随想录 (programmercarl.com)

我写了首诗，把滑动窗口算法变成了默写题 | labuladong 的算法笔记