24暑假算法刷题 | Day2 | LeetCode 977. 有序数组的平方，209. 长度最小的子数组，59. 螺旋矩阵 II

---

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]

提示：

• 1 <= nums.length <= 104
• -104 <= nums[i] <= 104
• nums 已按 非递减顺序 排序

进阶：

• 请你设计时间复杂度为 O(n) 的算法解决本问题

题解

暴力算法很容易想到：遍历数组 ➡️ 将其中每个数都平方 ➡️ 将数组排序，直接调用库函数就行。

vector<int> sortedSquares_Violence(vector<int> &nums)
{
    // 暴力解法：先平方再排序
    for (int i = 0; i < nums.size(); i++)
        nums[i] = pow(nums[i], 2);
    sort(nums.begin(), nums.end());
    return nums;
}

但是这种算法没意思 (🐶)，而且时间复杂度较高——遍历一遍要 $O(n)$ ， std::sort() 要 $O(nlogn)$ 。

我们考虑用双指针：定义左、右两个指针指向数组的最左和最右元素，由于数组有序且可能有负数，平方之后最大的数总是在最左和最右端。因此，可以：

• 比较左右指针指向元素的平方值
• 将大的加到结果数组中（倒序加入，因为要求结果是升序排列）
• 相应的那个指针向中间移动
• 重复上述步骤直到双指针交汇，结束

代码

vector<int> sortedSquares(vector<int> &nums)
{
    // 思路：左右双指针
    // 原数组可能有负数，这样平方之后，“两头”的数总是最大的
    vector<int> res(nums.size());
    int curLast = res.size() - 1; // 待填入的位置
    int left = 0, right = nums.size() - 1;
    while (left <= right)
    {
        int ls = pow(nums[left], 2);
        int rs = pow(nums[right], 2);
        if (ls > rs)
        {
            res[curLast--] = ls;
            left++;
        }
        else
        {
            res[curLast--] = rs;
            right--;
        }
    }
    return res;
}

---

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

提示：

• 1 <= target <= 109
• 1 <= nums.length <= 105
• 1 <= nums[i] <= 105

进阶：

• 如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。

题解

典型的双指针构造滑动窗口题目。定义快慢双指针，其中：

1️⃣ 快慢双指针都初始化为0

2️⃣ 快指针前进一个单位（越界则返回）

3️⃣ 当前快慢指针之间（含指针所指元素）这个 “窗口” 中元素之和是否大于等于 target ：是则下一步，否则上一步

4️⃣ 更新最小长度，慢指针前进一个单位，回到上一步

这样就做到了整体上只遍历一次数组，动态更新最小长度来求解。

代码

int minSubArrayLen(int target, vector<int> &nums)
{
    // 思路：采用快慢双指针，构成一个滑动窗口，动态更新最短长度
    int slow = 0, fast = 0;
    const int MAX = numeric_limits<int>::max();
    int minLen = MAX;
    int curSum = nums[fast];
    while (1)
    {
        if (curSum >= target)
        {
            minLen = min(minLen, fast - slow + 1);
            curSum -= nums[slow];
            slow++;
        }
        else
        {
            fast++;
            if (fast >= nums.size())
                break;
            curSum += nums[fast];
        }
    }
    return minLen == MAX ? 0 : minLen;
}

下面附上Carl哥的版本，思路一致，代码比我更简洁规范些：

int minSubArrayLen_Carl(int target, vector<int> &nums)
{
    int left = 0, right = 0;
    int length = 1e6;
    int sum = 0;

    for (right = 0; right < nums.size(); right++)
    {
        sum += nums[right];
        while (sum >= target)
        {
            int curLength = right - left + 1;
            length = curLength < length ? curLength : length;
            sum -= nums[left++];
        }
    }

    return length == 1e6 ? 0 : length;
}

本题进一步解析见卡哥文章：代码随想录 (programmercarl.com)

---

59. 螺旋矩阵 II

点此跳转题目链接

题目描述

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

示例 1：

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

示例 2：

输入：n = 1
输出：[[1]]

提示：

• 1 <= n <= 20

题解

这题其实算法上没啥难度，主要要求对数组有清晰的控制。印象深刻的是第一次做这道题的时候debug疯了，究其原因是没有个统一、清晰的处理思路，导致最后总有个别地方数字错误，难以完全通过。

这次是二刷还是三刷了，终于一次性搞定，思路也比较清晰，核心就是：

• 从外向内逐层处理
• 每一层中，按上-右-下-左的顺序（顺时针）处理每条边，且每条边按照 “前闭后开” 的原则处理：

如上图所示，同种颜色代表处理这条边的时候需要填数的位置。这样，边长为n的正方形层里，每条边都统一地处理自己的n-1个单位即可。

图片来源：卡哥解析文章

代码

各变量都有注释说明，建议拿3x3和4x4的矩阵对照着过一遍，应该就能get到了。

vector<vector<int>> generateMatrix_II(int n)
{
    vector<vector<int>> res(n, vector<int>(n));
    int curLayer = 0;   // 当前正在处理的层号，从外到内计数
    int curSideLen = n; // 当前在处理的这层正方形的边长
    int curNum = 1;     // 当前要填入矩阵的数字

    // 一层层处理，每层的各条边采用“前闭后开”的原则
    while (curSideLen > 0)
    {
        // 处理上边
        for (int j = curLayer; j < curLayer + curSideLen - 1; j++)
            res[curLayer][j] = curNum++;
        // 处理右边
        for (int i = curLayer; i < curLayer + curSideLen - 1; i++)
            res[i][curLayer + curSideLen - 1] = curNum++;
        // 处理下边
        for (int j = curLayer + curSideLen - 1; j > curLayer; j--)
            res[curLayer + curSideLen - 1][j] = curNum++;
        // 处理左边
        for (int i = curLayer + curSideLen - 1; i > curLayer; i--)
            res[i][curLayer] = curNum++;

        curLayer++;      // 往内处理下一层
        curSideLen -= 2; // 下一层边长减2
    }

    // 如果是奇数阶矩阵，还要填中心元素
    if (n % 2 == 1)
        res[n / 2][n / 2] = n * n;

    return res;
}