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

LeetCode977: 有序数组平方

题目链接977
这道题的题目描述是：给定一个按非递减顺序排序的整数数组 nums，返回每个数字的平 组成的新数组，要求也按非递减顺序排序。
示例 1：

输入：nums = [-4,-1,0,3,10] 
输出：[0,1,9,16,100]

解释：平方后，数组变为 [16,1,0,9,100] 排序后，数组变为 [0,1,9,16,100]
进阶的要求是设计时间复杂度为 O(n) 的算法解决本问题。
这道题看起来非常简单，最直观的解决办法就是先将数组里的值平方，然后用sort排序。但是sort排序(快排）的时间复杂度是O(nlogn)不符合进阶要求。
–以Python代码为例：
简单解法：

for i in range(len(nums)):
	nums[i]*=nums[i]
return sorted(nums)

或者直接一行AC

return sorted(x*x for x in nums)

这样的解法在Leectcode上是可以通过的，且时间空间都还算优秀。但是！大家刷题的时候不必太在意leetcode上执行用时，打败多少多少用户，因为这个的计算并不准确。还是要参考大O方法去看时间和空间复杂度。
下面来说一下时间复杂度为O(n)的一种方法。
虽然平方后的数组“无序”，但其实是有一定规律的，就是负数可能会由于平方变大。这样就可以先比较nums两头的数的平方来进行排序。我们来直接看代码吧。

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        res = [float('inf')] * len(nums)# 需要提前定义列表，存放结果
        l, r, i = 0, len(nums)-1, len(nums)-1 #定义左右指针和一个存放较大结果的指针
        while l <= r:
            if nums[l]*nums[l] <= nums[r]*nums[r]: #把比较大的结果从后开始放进res中
                res[i] = (nums[r]*nums[r])
                r -= 1
            else:
                res[i] = (nums[l]*nums[l])
                l += 1
            i -= 1 #每次将i向前移动一位
        return res

此时的时间复杂度为O(n)，相对于暴力排序的解法O(n + nlog n)还是提升不少的。

C++代码如下：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        int k = A.size() - 1;
        vector<int> result(A.size(), 0);
        for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
            if (A[i] * A[i] < A[j] * A[j])  {
                result[k--] = A[j] * A[j];
                j--;
            }
            else {
                result[k--] = A[i] * A[i];
                i++;
            }
        }
        return result;
    }
};

---

LeetCode209: 长度最小的子数组

题目链接209
这道题的描述是：给定一个含有 n 个正整数的数组和一个正整数 target，找出该数组中满足其总和大于等于 target 的长度最小的连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2

解释：子数组 [4,3] 是该条件下的长度最小的子数组。

这道题拿到手最直观的想法就是暴力解法，首先遍历数组的每个元素，计算第i元素加到前面的j个元素的时候满足条件>=target，就计算一下这个j-i的值，然后更新这个值一直取最小。
代码实现（python举例）

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

时间复杂度：O(n^2)
空间复杂度：O(1)
显然这样的做法的时间复杂度是O(n*2),无法通过全部的用例，但是这也是最直观的思路。为了更好的实现这种类型的题，可以考虑用滑动窗口方法，时间复杂度O(n)就可以解决。
具体是怎么做的呢。我们可以用一个指针left指向从头开始（逐渐后移）的元素作为窗口的开口，一个指针right指向满足窗口内元素>=target的第一个元素作为窗口的闭口。这样的话将right指针持续的一个一个向后移动，随之left也会逐渐变化，窗口内始终满足条件，即>=target，然后不断更新窗口的大小（长度）。
tips:在本题中实现滑动窗口，主要确定如下三点：

• 窗口内是什么: 满足其和 ≥ target 的长度最小的连续子数组。
• 窗口的起始位置如何移动：如果当前窗口的值大于target了, 起始位置就要向后移动了（也就是窗口该缩小了）。
• 窗口的结束位置如何移动：就是遍历数组的指针，即for循环里的索引。

总结：根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。

我们以一个动图来更直观的理解这个过程吧。

动图引用自代码随想录。

def minSubArrayLen(self, target: int, nums: List[int]) -> int:
	l=len(nums)
    left=0
    right=0
    min_len=float('inf')
    cur_sum=0
    while right<l:
    	cur_sum+=nums[right]
    	while cur_sum>=target: # 当前累加值大于目标值进行窗口更新
    		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

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

C++代码如下：

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0; // 滑动窗口数值之和
        int i = 0; // 滑动窗口起始位置
        int subLength = 0; // 滑动窗口的长度
        for (int j = 0; j < nums.size(); j++) {
            sum += nums[j];
            // 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
            while (sum >= s) {
                subLength = (j - i + 1); // 取子序列的长度
                result = result < subLength ? result : subLength;
                sum -= nums[i++]; // 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

时间复杂度：O(n)
空间复杂度：O(1)

tips: 关于时间复杂度为什么是O(n)，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。

---

LeetCode59: 螺旋矩阵||

题目链接59
题目要求：给定一个正整数 n ，生成一个包含 1 到 n*n所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
示例 1：

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

这道题拿到手其实会有一点懵，不知道怎么下手，但其实就是找到建立矩阵的规律，把1到n方的所有数据根据规律逐个填入到矩阵对应的位置即可。
很重要的一点是寻找这个循环不变量的区间。
模拟顺时针画矩阵的过程:

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

由外向内一圈一圈这么画下去。
每一次循环都要走这四个步骤。不要试图简化这里，可以直接这么写。
然后需要注意的就是边界条件，也就是每个角上的点。为了让循环有规律可循，依然遵循左闭右开原则就好，比如以第一个循环举例，第一行我们说从第一列遍历到n-1列的第一个元素（➡️），然后第n列的第一行第一个元素遍历到n-1行（⬇️），然后从第n行第n列的元素，遍历到第n行第2列（⬅️），然后从第1列的第n行遍历到第2行（⬆️）。完成一次循环。
然后第二次循环的时候起始的行列都要变化（加一），同时n-x的x也要变化，相当于往内缩圈，所以始末都要减1。

找到了基本的循环规律后还需要注意的是：

• 遍历的次数是n//2 而不是n，画图一下就可以理解。
• 处理n的奇偶数情况，n为奇数的时候循结束后，中间点没处理，加上即可。
  我们直接看代码吧
  python代码如下：

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        nums=[[0]*n for _ in range(n)] #建立一个n*n矩阵且元素都是0
        i,j=0,0 # i，j分别代表行列
        loop=mid=n//2 #判断中心点和循环次数
        offset=1 #需要控制每一条边遍历的长度，每次循环右边界收缩一位
        count=1 #用来计数n从1到n平方的值
        for offset in range(1,loop+1):
        	# 下面开始的四个for就是模拟转了一圈
            for x in range(j,n-offset):
                nums[i][x]=count
                count+=1
            for x in range(i,n-offset):
                nums[x][n-offset]=count
                count+=1
            for x in range(n-offset,j,-1):
                nums[n-offset][x]=count
                count+=1
            for x in range(n-offset,i,-1):
                nums[x][j]=count
                count+=1
            i+=1
            j+=1 
        if n % 2 != 0 :			# n为奇数时，填充中心点
            nums[mid][mid] = count 
        return nums

时间复杂度 O(n^2): 模拟遍历二维矩阵的时间
空间复杂度 O(1)

C++代码如下：

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0)); // 使用vector定义一个二维数组
        int startx = 0, starty = 0; // 定义每循环一个圈的起始位置
        int loop = n / 2; // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
        int mid = n / 2; // 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
        int count = 1; // 用来给矩阵中每一个空格赋值
        int offset = 1; // 需要控制每一条边遍历的长度，每次循环右边界收缩一位
        int i,j;
        while (loop --) {
            i = startx;
            j = starty;
            // 下面开始的四个for就是模拟转了一圈
            // 模拟填充上行从左到右(左闭右开)
            for (j = starty; j < n - offset; j++) {
                res[startx][j] = count++;
            }
            // 模拟填充右列从上到下(左闭右开)
            for (i = startx; i < n - offset; i++) {
                res[i][j] = count++;
            }
            // 模拟填充下行从右到左(左闭右开)
            for (; j > starty; j--) {
                res[i][j] = count++;
            }
            // 模拟填充左列从下到上(左闭右开)
            for (; i > startx; i--) {
                res[i][j] = count++;
            }

            // 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
            startx++;
            starty++;
            // offset 控制每一圈里每一条边遍历的长度
            offset += 1;
        }

        // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
        if (n % 2) {
            res[mid][mid] = count;
        }
        return res;
    }
};

时间复杂度 O(n^2): 模拟遍历二维矩阵的时间
空间复杂度 O(1)

以上内容有部分转自代码随想录，指路b站，里面有详细的视频版解答思路

点击链接🔗可跳转