【Leetcode刷题足迹Day2】977 有序数组的平方 209 长度最小的子数组 59 螺旋矩阵

977 有序数组的平方

题目

#双指针
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]

思路

• 抓住数组有序这一特点，当数组存在负数时，数组平方一般呈现的是“两头大中间小”的情况。
• 那么我们只需要从两头开始比较数组元素平方的大小，将大的倒放入新的数组，最后能够得到题解
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6GpstgcI-1670497938427)(https://code-thinking.cdn.bcebos.com/gifs/977.%E6%9C%89%E5%BA%8F%E6%95%B0%E7%BB%84%E7%9A%84%E5%B9%B3%E6%96%B9.gif)]

方法

暴力解法

只需要将每个数平方之后再快排

for i in range(0,nums.size):
	nums[i] *= nums[i]
sort(nums)
return nums

这样的时间复杂度是O(n+logn)

双指针

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        head = 0
        tail = len(nums) - 1
        flag = len(nums) - 1
        #这里直接从数组的最后一位开始加入
        new_num = [-1] * len(nums)
		#首先要为数组声明定量的空间地址，这点很重要
        while(head <= tail):
        #这里while中有=，不然会有一个元素取不到
            if(abs(nums[head]) <= abs(nums[tail])):
        #当然可以直接用 nums[i] ** 2 进行比较
                new_num[flag] = nums[tail] ** 2
                tail -= 1
            else:
                new_num[flag] = nums[head] ** 2
                head += 1
            flag -= 1
        return new_num

------
209 长度最小的子数组
给定一个含有 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

## 思路
- 不断调节子序列的起始位置和终止位置，从而得出我们所想要的结果——==滑动窗口==
- 只用一个for循环的话，只能用这个for循环来表示==终止位置==

![华东窗口](https://code-thinking.cdn.bcebos.com/gifs/209.%E9%95%BF%E5%BA%A6%E6%9C%80%E5%B0%8F%E7%9A%84%E5%AD%90%E6%95%B0%E7%BB%84.gif)
- 窗口内是什么？
	- 窗口内是满足所有元素之和大于s的连续子数组
- 窗口的起始位置如何移动？
	- 如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）
- 窗口的结束位置如何移动？
	- 窗口的结束位置是索引，随for循环移动

滑动窗口的==精妙之处==在于根据当前**子序列和大小**的情况，不断调节子序列的起始位置，从而将`O(n^2)`暴力解法降维`O(n)`

```python
class Solution:

    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        start = 0 #起始位置
        sum = 0 #滑动窗口和
        res = float("inf") #定义一个无限大的数

        for end in range(0, len(nums)):
            sum += nums[end]
            while(sum >= target):
                length = end - start + 1
                res = min(res, length)
                sum -= nums[start]
                start += 1
        return 0 if res == float("inf") else res

---

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

思路

• 每条边的处理逻辑要相同——循环不变量

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) : # 从右至左
                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 :			# n为奇数时，填充中心点
            nums[mid][mid] = count 
        return nums