算法训练营第2天

题目链接 977.有序数组的平方 & 209.长度最小的子数组 & 59.螺旋矩阵II

今日学习的文章链接 977.有序数组的平方 & 209.长度最小的子数组 & 59.螺旋矩阵II 和视频链接 977.有序数组的平方 & 209.长度最小的子数组 & 59.螺旋矩阵II

977.有序数组的平方

自己看到题目的第一想法

暴力：
如果使用sort()库函数还可以将时复提高到$O(nlogn)$

// 时间复杂度 O(n^2)，空间复杂度 O(1)
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for (int i = 0; i < nums.size(); i++) {
            nums[i] = nums[i] * nums[i];
        }

        for (int i = 0; i < nums.size(); i++) {
            for (int j = i; j < nums.size(); j++) {
                if (nums[i] > nums[j]) {
                    nums[i] = nums[i] ^ nums[j];
                    nums[j] = nums[i] ^ nums[j];
                    nums[i] = nums[i] ^ nums[j];
                }
            }
        }

        return nums;
    }
};

前后双指针：
因为题干没要求原地求解，所以可以使用第二个数组。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result(nums.size(), 0);

        for (int i = 0; i < nums.size(); i++) {
            nums[i] = nums[i] * nums[i];
        }

        for (int i = 0, j = nums.size() - 1, k = nums.size() - 1; i <= j; k--) {
            result[k] = nums[i] >= nums[j] ? nums[i++] : nums[j--];
        }

        return result;
    }
};

看完代码随想录之后的想法

与我的想法相同

自己实现过程中遇到哪些困难

构造一个指定长度的vector，使用条件运算符 ?:简化代码

今日收获，记录一下自己的学习时长

前后双指针、vector的构造、条件运算符?:

209.长度最小的子数组

自己看到题目的第一想法

拒绝两层for循环的暴力解法。使用快慢双指针达到$o(n)$的时复。
有点像尺蠖，快指针寻找子数组的前端，慢指针在每次找到子数组后往前挪一位，同时sum减去这个值因为不属于新数组，此时快指针不需要移动，因为此时新生成一个子数组，需要先判断是否满足target。

// 时复 O(n)，空复 O(1)
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int i = 0, j = 0, sum = nums[0], length = nums.size();
        bool flag = false;

        while (i < nums.size() && j < nums.size()) {            

            if (sum < target) {                
                j++;
            } else {
                flag = true;
                length = (j - i + 1) < length ? (j - i + 1) : length;
                sum -= nums[i];
                i++;
                continue;
            }

            if (j < nums.size()) sum += nums[j];

        }
        
        return (flag == false) ? 0 : length;
    }
};

看完代码随想录之后的想法

原来有个专有名词滑动窗口，不过思想就是双指针。
这里实现对于慢指针移动用的是while循环，好在不需要continue和特判，不过多了一个while我第一时间没想到，并且看上去好像有两个循环。不过这个方法比我的方法判断少一点儿。
滑动窗口，代码随想录思想，按照我的写法：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int i = 0, j = 0, sum = 0, length = nums.size() + 1;

        for (; j < nums.size(); j++) {
            sum += nums[j];

            while (sum >= target) {
                length = (j - i + 1) < length ? (j - i + 1) : length;
                sum -= nums[i];
                i++;
            }

        }

        return (length == (nums.size() + 1)) ? 0 : length; 
    }
};

对我的第一想法的代码改进，因为在length等于全部元素数量时，可能是刚刚好或者没有符合条件的子数组，所以设置length初始值为nums.size() + 1即可解决这个判断。改进找不到子数组的情况：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int i = 0, j = 0, sum = nums[0], length = nums.size() + 1;

        while (i < nums.size() && j < nums.size()) {            

            if (sum < target) {                
                j++;
            } else {
                length = (j - i + 1) < length ? (j - i + 1) : length;
                sum -= nums[i];
                i++;
                continue;
            }

            if (j < nums.size()) sum += nums[j];

        }
        
        return (length == nums.size() + 1) ? 0 : length;
    }
};

自己实现过程中遇到哪些困难

1. 先判断再调整子数组，因为每次调整完都是一个新的子数组。这个顺序是我在手动模拟之后调整好的。
2. 对于刚刚好或者不能找到子数组的，用flag判断其是否找到一个子数组。
3. 对于边界的判断，测试用例3的越界情况，需要在调用nums[j]之前判断。

今日收获，记录一下自己的学习时长

59. 螺旋矩阵 II

自己看到题目的第一想法

应该是模拟，但是里面的判断较麻烦。

看完代码随想录之后的想法

为什么提到二分法？实际上是用到了循环不变量的思想。原来我自己在模拟的时候没有坚持循环不变量，也就是我并没有考虑区间，更没有考虑区间不变。
此处用了左闭右开区间，用到了每个循环的起点坐标，四个循环分为两类，一类是++，一类是–。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> result(n, vector<int>(n, 0));
        int start_x = 0, start_y = 0; // 每个圈开始的坐标，行列
        int loop = n / 2; // 完整的圈数，除了n = 1
        int middle = n / 2; // n为奇数时，矩阵中间的位置
        int count = 1; // 给矩阵元素赋值
        int offset = 1; // 每个方向循环的长度，每次循环右边界收缩一位
        int i, j; // 分别代表行列
        
        while (loop--) {
            i = start_x, j = start_y;

            // 接下来4个for循环模拟
            // 右
            for (; j < n - offset; j++) result[i][j] = count++;

            // 下
            for (; i < n - offset; i++) result[i][j] = count++;

            // 左
            for (; j > start_y; j--) result[i][j] = count++;

            // 上
            for (; i > start_x; i--) result[i][j] = count++;
 
            // 下一圈，开始坐标各加一
            start_x++, start_y++;

            // 每圈每条边的长度减少
            offset++;
        }

        // 当 n 为奇数的时候，中间的单独赋值
        if (n % 2 == 1) result[middle][middle] = count;

        return result;
    }
};

自己实现过程中遇到哪些困难

自己没有实现，应该多模拟几个找找规律

今日收获，记录一下自己的学习时长

这种题好像只能多做