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

易亿

已于 2024-06-10 22:20:38 修改

阅读量631

点赞数 14

文章标签：算法 leetcode python

于 2024-06-10 22:13:46 首次发布

本文链接：https://blog.csdn.net/dyy3642/article/details/139562903

版权

LeetCode 977.有序数组的平方

文档讲解：代码随想录

视频讲解：双指针法经典题目 | LeetCode：977.有序数组的平方_哔哩哔哩_bilibili

题目链接：. - 力扣（LeetCode）

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

示例 1：

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

1、思路

1.1 暴力排序

每个数平方后，再排序

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

1.2 双指针法

数组是有序的，只不过负数平方之后可能成为最大数了。

数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。

考虑双指针法：i指向起始位置，j 指向终止位置。

定义一个新数组result,和A数组一样的大小，让k指向result数组终止位置。

如果 A[i] * A[i] < A[j] * A[j], 那么 result[k--] = A[j] * A[j]

如果 A[i] * A[i] > A[j] * A[j], 那么 result[k--] = A[i] * A[i]

时间复杂度：O(n)

2、代码

2.1 暴力排序

class Sloution:
    def sortedSquares(self,nums:List[int]) -> List[int]:
        for i in range(len(nums)):
            nums[i] *= nums[i]
        nums.sort()
        return nums

2.2 双指针法

class Solution:
    def sortedSquares(self,nums:List[int]) -> List[int]:
        l,r,i=0,len(nums)-1,len(nums)-1
        res= [float('inf')] * len(nums) #需要提前定义列表，存放结果
        while l <= r:
            if nums[l] ** 2 > nums[r] ** 2 : #左右边界进行对比，找出最大值
                res[i] = nums[l] ** 2 
                l += 1
            else:
                res[i] = nums[r] ** 2
                r -= 1
            i -= 1
        return res

LeetCode 209.长度最小的子数组

文档讲解：代码随想录

视频讲解：拿下滑动窗口！ | LeetCode 209 长度最小的子数组_哔哩哔哩_bilibili

题目链接：. - 力扣（LeetCode）

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

1、思路

1.1 暴力解法

两个for循环，然后不断地寻找符合条件的子序列。

时间复杂度：O(n^2)

空间复杂度：O(1)

1.2 滑动窗口

滑动窗口：不断地调节子序列的起始位置和终止位置，从而得出我们想要的结果。

窗口内是什么？

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

如何移动窗口的起始位置？

如果当前窗口的值大于等于 s 了，窗口就要向前移动了（也就是该缩小了）。

如何移动窗口的结束位置？

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

此块代码的精髓就是动态调节滑动窗口的起始位置。

while (sums >= s) {
    subLength=(j-i+1); //取子序列的长度
    result = rusult < sumLength ? result : sumLength; 
    sum -= nums[i++]; // 这里体现出滑动窗口的精髓之处，不断变更i(子序列的起始位置）
}

时间复杂度：O(n)

2、代码

2.1 暴力解法

class Solution:
    def minSubArrayLen(self,s:int,nums:List[int])->int:
        l=len(nums)
        min_len=float('inf')
        for i in range(l):
            cur_sum=0
            for j in range(i,l):
                cur_sum += nums[j]
                if cur_sum >= s:
                    min_len = min(min_len,j-i +1)
                    break
        return min_len if min_len != float('inf') else 0

2.2 滑动窗口法

class Solution:
    def minSubArrayLen(self,s:int,nums:List[int])-> int:
        left=0
        right=0
        l=len(nums)
        min_len=float('inf')
        cur_sum=0 #当前的累加值


        while right < l:
            cur_sums += nums[right]
            while cur_sum >= s:  #当前累加值大于目标值
                min_len=min(min_len,right-left+1)
                cur_sum -= nums[left]
                left += 1
            right += 1
        return  min_len if min_len != float('inf') else 0

LeetCode 59.矩阵矩阵II

文档讲解：代码随想录

视频讲解：一入循环深似海 | LeetCode：59.螺旋矩阵II_哔哩哔哩_bilibili

题目链接：. - 力扣（LeetCode）

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

示例 1：

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

示例 2：

输入：n = 1
输出：[[1]]

1、思路

坚持循环不变量原则。

模拟顺时针画矩阵的过程：

填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上

每一种颜色，代表一条边，每条边坚持左闭右开原则。

时间复杂度：O(n^2)

空间复杂度：O(1)

2、代码

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):  #从右至左
                res[n-offset][i]=count
                count += 1
            for i in range(n-offset,startx,-1):  #从下至上
                res[i][starty]=count
                count += 1

            startx += 1  #更新起始点
            starty += 1
        if n % 2 != 0:  #n为奇数时，填充中心点
            nums[mid][mid]=count
        return nums