算法训练营 Day2| 数组 - 双指针 滑动窗口 / 2D Matrix

977.有序数组的平方

暴力法 - O(n)

把所有平方数都放入新建的res列表里

并且sort res

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        res = []
        for i in range(len(nums)):
            res.append(int(math.pow(nums[i],2)))
        return sorted(res)

双指针

因为最左边和最右边最可能存在最大的平方值 所以左指针和右指针从这两个地方开始比较

新建一个有五个列表的空数组 从len(res)-1开始替换数字 最大的数字放入数组 并且指针向左/向右移动 依次填入数组 当 l == r 的时候填入最后一个剩下的数字

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        res = [[] for i in range(len(nums))]
        l = 0 
        r = len(nums)-1
        pointer = r
        while l <= r:
            right = int(math.pow(nums[r],2))
            left  = int(math.pow(nums[l],2))
            if right >= left:
                res[pointer] = right
                r -=1
            else:
                res[pointer] = left
                l += 1
            pointer -= 1
        return res

 

209: 长度最小的子数组

对滑动窗口方法基本掌握 但是左右指针的起始点容易弄错 就会导致结果out of range的情况 如下：

**#output: close out of range**

def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        res = len(nums)  
        close = 1
        begin = 0
        hold = nums[begin] + nums[close]

        while close < len(nums):
            print(begin,close,hold,res)
            if hold == target:
                res = min(res,close-begin+1)
                hold -= nums[begin]
                begin += 1                
            elif hold < target:
                close += 1
                hold += nums[close]
            else:
                hold -= nums[begin]
                begin += 1
        return res

复盘点

1）左右指针起始点为0

2）相比把所有情况都用if总结 也可以用while循环 - coding简洁

3） 与其用len作为最大的值 可以利用’inf’作为一个最大的数字 这样不会和[1,1,1,1] target = 11的case混淆

看了教程的改进版本

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        if not nums:
            return 0

        res = float('inf')
        close = 0
        begin = 0
        hold = 0
        while close < len(nums):
            hold += nums[close]
            while hold >= target:
                res = min(res,close-begin+1)
                hold -= nums[begin]
                begin += 1
            close += 1
                            
        if res == float('inf'):
            return 0
        else:
            return res

59. 螺旋矩阵 II

螺旋矩阵有四个方向

如果是左闭右闭情况会出现重复的坐标 所以需要利用左闭右开的形式 如直接 x < n 会有超出x范围的情况 所以用n - offset来避免此情况的发生

螺旋的层数： n // 2

同时需要注意 n %2 不等于 0 的情况 这样就剩下最后一个最中间的数

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        startx = 0
        starty = 0
        cur = 1
        grid = [[0]*n for i in range(n)]
        row,col = 0,0

        for offset in range(1,n//2+1):
            for i in range(starty,n-offset):
                grid[startx][i] = cur
                cur += 1

            for i in range(startx,n-offset):
                grid[i][n-offset] =cur
                cur += 1
            
            for i in range(n-offset,starty,-1):
                grid[n-offset][i] =cur
                cur += 1
            
            for i in range(n-offset,startx,-1):
                grid[i][starty] =cur
                cur += 1
            startx += 1
            starty += 1

        
        if n%2 != 0:
            grid[n//2][n//2] = cur
        
        return grid