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

目录

977.有序数组的平方

209.长度最小的子数组

59.螺旋矩阵II

---

977.有序数组的平方

题目建议： 本题关键在于理解双指针思想 

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

文章讲解：代码随想录

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

思路：

        不得不说，用python写算法题真的容易很多，我第一反应是直接遍历数组的每一个元素，直接平方后返回去，最后调用一个sort（）函数结束。  事实证明也是可以的。

原来的代码:

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

aa=Solution()
nums=eval(input())
print(aa.sortedSquares(nums))

        当然出题者肯定不是这个意图（doge），题解这道题用的是双指针法，通过分析可以看出，原来的数组是非递减排序，平方之后最大只有可能出现在两边，绝对值越大的数平方之后会更大。所以我们手动定义一个数组result[]来存放最后的结果。 对原来的数组采用双指针法，一个指针在原数组最前面，一个在最后面，每一次比较一下哪个数的平方更大，将大的写到result的最后面，不断循环，结束。

代码：

from typing import List


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


aa = Solution()
nums = eval(input())
print(aa.sortedSquares(nums))

209.长度最小的子数组

题目建议： 本题关键在于理解滑动窗口，这个滑动窗口看文字讲解 还挺难理解的，建议大家先看视频讲解。  拓展题目可以先不做。 

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

文章讲解：代码随想录

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

思路：

        第一反应还是两层for循环，大力出奇迹，（但是这样会超时）。所以用的是一个叫滑动窗口的东西，之前听蓝桥杯也有听过滑动窗口这个东西，现在明白为什么Carl哥说要记笔记了，因为真的会忘记啊啊啊啊啊，一个月前的学的滑动窗口马上就忘了。。。

        我认为滑动窗口的思想就是先判断当前窗口内的右端 j 减去左端 i 是否大于我的目标值target，如果大于target就一直用while 把这个窗口缩小（即左指针i不断加1），直到当前窗口右端减去左端小于target，然后把窗口右端点j+1，扩大窗口后再次调用前面那个while，不断循环直到右端点j到达数组最右边。

代码：

from typing import List


class Solution():
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        minimum = len(nums)
        nums.insert(0, 0)
        sum = [0] * len(nums)
        for i in range(1, len(nums)):
            sum[i] = sum[i - 1] + nums[i]
        if sum[-1] < target:
            return 0
        i = 0
        j = 1
        while j < len(sum):
            while sum[j] - sum[i] >= target:
                minimum = min(minimum, j - i)
                i += 1
            j += 1

        return minimum


aa = Solution()
target = int(input())
nums = eval(input())
print(aa.minSubArrayLen(target, nums))

59.螺旋矩阵II

题目建议：  本题关键还是在转圈的逻辑，在二分搜索中提到的区间定义，在这里又用上了。 

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

文章讲解：代码随想录

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

思路：

        这题没有套路，没有算法， 理清逻辑，Carl哥说得对，坚持循环不变量原则，每一条边都坚持左闭右开原则，按照两层for循环，第一层循环，控制矩阵画到第几圈由外到内一圈圈画，第二层for循环，控制每次画四条边。我写的代码有点乱，建议直接看上面的文章讲解。

from typing import List


class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        lst = [[0] * n for _ in range(n)]

        if n % 2 != 0:  # 根据边长，单独判断矩阵有没有正中心
            lst[n // 2][n // 2] = n * n

        x, y = -1, -1
        k = 1

        for i in range(n - 1, 0, -2):  # 每画一圈边长就-2
            x += 1
            y += 1
            for j in range(4):  # 四次循环，控制四个方向
                if j == 0:
                    for _ in range(i):
                        lst[x][y] = k
                        y += 1
                        k += 1

                elif j == 1:
                    for _ in range(i):
                        lst[x][y] = k
                        x += 1
                        k += 1

                elif j == 2:
                    for _ in range(i):
                        lst[x][y] = k
                        y -= 1
                        k += 1

                elif j == 3:
                    for _ in range(i):
                        lst[x][y] = k
                        x -= 1
                        k += 1
        return lst


aa = Solution()
n = int(input())
print(aa.generateMatrix(n))