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

螺旋矩阵

59. 螺旋矩阵 II

根据第一次循环去写样例,但要记得其中的条件要设置成之后也要使用的循环变量

【用0作为边界条件判断,忽略了循环量】

代码如下,已经详细注释了每一步的目的,可以看出while循环里判断的情况是很多的,代码里处理的原则也是统一的左闭右开。

/*
 * @lc app=leetcode.cn id=59 lang=cpp
 *
 * [59] 螺旋矩阵 II
 */

// @lc code=start
class Solution {
public:
    vector> generateMatrix(int n) {
        //判断有几行几列
        vector> res(n, vector(n,0));
        //起始位置
        int startX = 0;
        int startY = 0;
        //循环次数
        int loop = n / 2;
        //每次循环边界-1
        int offset = 1;
        //赋值
        int count = 1;
        //中间位置
        int mid = n / 2;

        //旋转的各个边界如何判定
        while(loop--){
            //向右移动
            //坚持循环不变量原则 区间取左闭右开
            int i = 0;
            int j = 0;

            for(j = startY; j < n - offset; j++){
                res[startX][j] = count;
                count++;
            }

            //向下移动
            for(i = startX; i < n - offset; i++){
                res[i][j] = count;
                count++;
            }

            //向左移动
            // for(; j > 0; j--){
            //     res[i][j] = count;
            //     count++;
            // }
            //需要比初始值大,而不是0(只考虑了第一次循环)
            for(; j > startY; j--){
                res[i][j] = count;
                count++;
            }

            //向上移动
            for(; i > startX; i--){
                res[i][j] = count;
                count++;
            }
            //起始位置的添加要在下一次循环开始之前
            startX++;
            startY++;

            //每一次循环后,再下一次循环开始前需要修改的变量
            //都需要在这一次循环结束前进行修改
            offset++;
        }
        // //起始位置
        // startX++;
        // startY++;

        

        //奇数偶数判断中间值
        if(n % 2 != 0){
            res[mid][mid] = n * n;
        }

        return res;

    }
};
// @lc code=end
// 时间复杂度 O(n^2): 模拟遍历二维矩阵的时间
// 空间复杂度 O(1)

大家还记得我们在这篇文章数组:每次遇到二分法,都是一看就会,一写就废 (opens new window)中讲解了二分法,提到如果要写出正确的二分法一定要坚持循环不变量原则

而求解本题依然是要坚持循环不变量原则。

模拟顺时针画矩阵的过程:

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

由外向内一圈一圈这么画下去。

可以发现这里的边界条件非常多,在一个循环中,如此多的边界条件,如果不按照固定规则来遍历,那就是一进循环深似海,从此offer是路人

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

那么我按照左闭右开的原则,来画一圈,大家看一下:

代码随想录算法训练营第二天| 59. 螺旋矩阵、209.长度最小的子数组、 977.有序数组的平方_第1张图片

这里每一种颜色,代表一条边,我们遍历的长度,可以看出每一个拐角处的处理规则,拐角处让给新的一条边来继续画。

这也是坚持了每条边左闭右开的原则。

滑动窗口

209. 长度最小的子数组

暴力解法:两个for循环,一个for循环为滑动窗口的终止位置,用两个for循环 完成了一个不断搜索区间的过程。

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

如果只用一个for循环来表示 滑动窗口的起始位置,那么如何遍历剩下的终止位置?

此时难免再次陷入 暴力解法的怪圈。

所以 只用一个for循环,那么这个循环的索引,一定是表示 滑动窗口的终止位置。

实现滑动窗口,主要确定如下三点:

  • 窗口内是什么?
  • 如何移动窗口的起始位置?
  • 如何移动窗口的结束位置?
class Solution {
public:
    int minSubArrayLen(int target, vector& nums) {
        //滑动窗口也可以理解为双指针
        //但是slow永远追不上fast
        int slow = 0;
        int subLength = 0;
        int sum = 0;
        //加入result 筛选结果
        // int result = 0;因为初值要比sublength大,所以初值要赋最大值
        // INT32_MAX指32位有符号整数类型int的最大值 2^32-1
        int result = INT32_MAX;
        for(int fast = 0; fast < nums.size(); fast++){
            sum += nums[fast];
            //符合条件、进入判断
            while(sum >= target){
                //更新subLength
                subLength = fast - slow + 1;
                result = result < subLength ? result : subLength;
                //保存最小的窗口长度,然后移动前面指针,继续判断
                sum -= nums[slow];
                slow++;
            }
        }
        //如果不加入对于result对最大值的筛选,每次返回的都是最新的值,得加入一个对于历史值的筛选
        return result == INT32_MAX ? 0 : result;
    }
};

窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。

窗口的起始位置如何移动:如果当前窗口的值大于s了,窗口就要向前移动了(也就是该缩小了)。

窗口的结束位置如何移动:窗口的结束位置就是遍历数组的指针,也就是for循环里的索引。

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

977. 有序数组的平方

重构一个数组存放结果,不需要在原地移动

双指针:前后两个指针比较结果,然后存放在新空间内,新空间从后向前存放元素。

因为两边平方后比较最大值,最大值在数组的两头,方便比较

class Solution {
public:
    vector sortedSquares(vector& nums) {
        //创建跟原数组长度一致的新数组存放
        vector new_nums;
        int size = nums.size();
        new_nums.resize(size);

        //建立双指针
        int slow = 0;
        int fast = size - 1;
        int n = size - 1;
        //为何取到“=”没有考虑进去 当fast = slow的时候,该元素并不能被忽略
        //代码随想录:因为要处理最后两个元素
        while(fast >= slow){
            if(nums[slow] * nums[slow] >= nums[fast] * nums[fast]){
                new_nums[n--] = nums[slow] * nums[slow];
                slow++;
            }else if(nums[slow] * nums[slow] < nums[fast] * nums[fast]){
                new_nums[n--] = nums[fast] * nums[fast];
                fast--;
            }
        }
        return new_nums;

    }
};

你可能感兴趣的:(Leetcode,算法,矩阵,leetcode)