有序数组的平方+长度最小的子数组+螺旋矩阵II

有序数组的平方

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

示例 1：

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

暴力法

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        squred_nums = [i**2 for i in nums]
        squred_nums.sort()
        return squred_nums

双指针法

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

此时可以考虑双指针法了，i 指向起始位置，j 指向终止位置。

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: 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[r] ** 2
                r -= 1
            else:
                res[i] = nums[l] ** 2
                l += 1
            i -= 1
        return res

长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的 

子数组

 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 1：

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

暴力法

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        l = len(nums)
        result = float('inf')
        for i in range(l):
            sum = 0
            for j in range(i,l,1):
                sum += nums[i]
                if sum >= target:
                    result = min(result, j - i + 1)
                    break
        return result if result != float('inf') else 0

滑动窗口法

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

滑动窗口如何用一个 for 循环来完成这个操作呢。

首先要思考，如果用一个 for 循环，那么应该表示滑动窗口的起始位置，还是终止位置。如果只用一个 for 循环来表示滑动窗口的起始位置，那么如何遍历剩下的终止位置？所以只用一个 for 循环，那么这个循环的索引，一定是表示滑动窗口的终止位置。

注意 for loop 中依旧嵌套 while loop，如果使用 for loop，则又会回归到 O(n^2) 的复杂度，此算法的复杂度为 O(n)，因为每个 entry 只被操作了两次，进来操作一次，出去操作一次。

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        l, r = 0, 0
        result = float('inf')
        sum = 0
        for r in range(len(nums)):
            sum += nums[r]
            while sum >= target:
                result = min(result, r - l + 1)
                sum -= nums[l]
                l += 1
            r += 1
        return result if result != float('inf') else 0

螺旋矩阵II

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

示例 1：

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

这里一圈下来，我们要画每四条边，这四条边怎么画，每画一条边都要坚持一致的左闭右开，或者左开右闭的原则，这样这一圈才能按照统一的规则画下来。

需注意 loop 为不带余数的整除结果，即如果 n 为奇数，中心点不被覆盖，需要单独处理，同时注意 2D array 的创建方法。

class Solution(object):
    def generateMatrix(self, n):
        """
        :type n: int
        :rtype: List[List[int]]
        """
        nums = [[0] * n for _ in range(n)]
        startx, starty = 0, 0 
        loop, mid = n // 2, n // 2
        count = 1
        for offset in range(1, loop + 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:
            nums[mid][mid] = count 
        return nums