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

超出时间复杂度

这个超出时间限制了
class Solution {
public:
    int sumNums(int& i, int& j, vector<int>& nums) {
        int su = 0;
        if (i == j) return i;
        while (i <= j) {
            su += nums[i];
            i++;
        }
        return su;
    }
    int minSubArrayLen(int target, vector<int>& nums) {
        int i = 0, j = 0, x = INT32_MAX;
        
        while (j < nums.size()) {
            if (target < sumNums(i, j, nums)) {
                j++;
            } else {
                while (target >= sumNums(i, j, nums)) {
                    x = (x > (j - i + 1) ? (j - i + 1) : x);
                    i++;
                }
            }
        }
        return x != INT32_MAX ? x : 0;
    }
};

滑动窗口法

所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

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

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

首先要思考 如果用一个for循环，那么应该表示 滑动窗口的起始位置，还是终止位置。

如果只用一个for循环来表示 滑动窗口的起始位置，那么如何遍历剩下的终止位置？ 所以只用一个for循环，那么这个循环的索引，一定是表示滑动窗口的终止位置。

那么问题来了， 滑动窗口的起始位置如何移动呢？

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

窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。

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

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int i = 0, x = INT32_MAX;
        
        int sumTa = 0;
        for (int j = 0; j < nums.size(); j++) {
            sumTa += nums[j];
            // 下面应该用while，而不是if,因为i不一定只减1
            // 第二个问题是sumTa >= target写成了target >= sumTa，要细心
            while (sumTa >= target) { 
                x = (x > (j - i + 1) ? (j - i + 1) : x);
                sumTa -= nums[i++];
            }
        }
        return x != INT32_MAX ? x : 0;
    }
};

by the way 我喜欢这个算法，喜欢窗口

59. 螺旋矩阵 II

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

我这种暴力解法超出时间复杂度，但是我感觉和代码随想录题解差不多啊，反正在vscode上面能跑通

//超出时间复杂度 我透
class Solution {
public:
    //超出时间复杂度 我透
    vector<vector<int>> generateMatrix(int n) {
        int x = 0, y = 0;
        int i1 = n - 1, i2 = n - 1, i3 = n - 1, i4 = n - 1;
        // int insertNum = 1;
        vector<vector<int>> squareOut(n, vector<int>(n, 0));
        if (n == 1) {
            squareOut[x][y] = 1;
            return squareOut;
        }
        for (int insertNum = 1; insertNum <= n * n; ) {
            for (int j = 0; j < i1; j++) {
                squareOut[x][y] = insertNum;
                insertNum++;
                y++;
            }
            if (insertNum >= n * n) break;
            i1 /= 2;
            
            for (int j = 0; j < i2; j++) {
                squareOut[x][y] = insertNum;
                insertNum++;
                x++;
            }
            i2 /= 2;
            for (int j = 0; j < i3; j++) {
                squareOut[x][y] = insertNum;
                insertNum++;
                y--;
            }
            i3 /= 2;
            for (int j = 0; j < i4; j++) {
                squareOut[x][y] = insertNum;
                insertNum++;
                x--;
            }
            x++;
            y++;
            i4 /= 2;
        }
        return squareOut;
    }
};

按代码随想录写了一遍，确实简洁了一点

如果要写出正确的二分法一定要坚持循环不变量原则。

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

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

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

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

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

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

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        // 按圈数循环
        int x = 0, y = 0; // 数组下标
        int starx = 0, stary = 0; // 每次循环完一圈开始的位置，[0][0] [1][1] [2][2]
        int loop = n / 2; // 循环圈数
        int lengthxy = n - 1; // 每次循环的一边长度
        int insertNum = 1; // 要在数组里插入的元素
        vector<vector<int>> squareOut(n, vector(n, 0));

        // while (insertNum <= n * n)
        while (loop --) {
            x = starx;
            // 下面开始的四个for就是模拟转了一圈
            // 模拟填充上行从左到右(左闭右开)
            for (y = stary; y < lengthxy; y++) {
                squareOut[starx][y] = insertNum++;
            }
            // 模拟填充右列从上到下(左闭右开)
            for (; x < lengthxy; x++) {
                squareOut[x][y] = insertNum++;
            }
            // 模拟填充下行从右到左(左闭右开)
            for (; y > stary; y--) {
                squareOut[x][y] = insertNum++;
            }
            // 模拟填充左列从下到上(左闭右开)
            for (; x > starx; x--) {
                squareOut[x][y] = insertNum++;
            }
            starx ++;
            stary ++;
            lengthxy -= 1; // 不是-2，是-1，因为每次循环完一圈开始的位置starx，stary也+1，所以就相当于加了2，上面那个超出时间复杂度的算法+2是因为把lengthxy当成了每次循环的次数
        }
        if (n % 2) { squareOut[n / 2][n / 2] = insertNum; }
        return squareOut;
    }
};

参考文献：代码随想录