209.长度最小的子数列

*******

209.长度最小的子数列

方法一：双指针（滑动窗口）

（今天就不暴力了，好歹文静（过不了）一会）

（昨天花了一天完成打卡，今天听卡尔哥的话先去（暴力了一发）直接看视频讲解再去做的题目）

（之前不知道在哪看见说不会的题 先去看思路，自己做，做不出来，再看代码）

思路

其实没太搞懂双指针与暴力的做法有啥区别

也许比较明显的是双指针的遍历次数更多，滑动窗口移动次数更少（这不是废话嘛😢）

暴力就是挨个试一下；滑动窗口就是用两个指针模拟可伸缩窗口（比如爷爷屋里一串菱形的木头晾衣架？小时候玩着可喜欢了），

int minSubArrayLen(int target, int* nums, int numsSize) {
    int sum = 0;
    int min = 0;
    int p = 0;
    int l;
    for (int i = 0, j = 0; i < numsSize; i++) // i是结尾指针，j是开头指针
    {
        sum += nums[i]; // 结尾走过的数据都装起来；
        while (sum >= target) {
            l = i + 1 - j;
            if (p == 0) {
                p = 1;
                min = l;
            }
            if (l < min) {
                min = l; // 更新最短长度；
            }
            sum = sum - nums[j];
            j++;
        }
    }
    return min;
}

（夹带私货）malloc（）与free（）二维数组

（来自GPT的教学！！！）

（高速时代的产物解救被高速时代隔离的孤独）

（省流：问人类不如问AI，真讽刺）

（这部分总是会忘记怎么写，而且也不太理解，所以就一起写在博客里吧）

#include <stdio.h>
#include <stdlib.h>

int main() {
    int m = 3, n = 4;  // 假设二维数组的大小是 3 行 4 列

    // 创建一个指针数组，指向每一行的起始地址
    int **array = (int **)malloc(m * sizeof(int *));
    
    if (array == NULL) {
        printf("内存分配失败！\n");
        return -1;
    }

    // 为每一行分配内存（每行有 n 列）
    for (int i = 0; i < m; i++) {
        array[i] = (int *)malloc(n * sizeof(int));
        if (array[i] == NULL) {
            printf("内存分配失败！\n");
            return -1;
        }
    }

    // 使用二维数组并初始化它
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            array[i][j] = i * n + j;  // 给每个元素赋值
        }
    }

    // 打印二维数组的内容
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", array[i][j]);
        }
        printf("\n");
    }

    // 释放内存
    for (int i = 0; i < m; i++) {
        free(array[i]);  // 释放每一行的内存
    }
    free(array);  // 释放指针数组的内存

    return 0;
}

59.螺旋矩阵

（第一眼看成旋转矩阵了😶）

这是一道模拟题（有模有样~）

方法一：模拟/双指针？（没有方法二）

这是收获满满的一道题

思路

把矩阵拆解成n/2层，每一层用四个for循环处理四个边， 若n是奇数，最后再填入中心元素

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume
 * caller calls free().
 */
int** generateMatrix(int n, int* returnSize, int** returnColumnSizes) {

    /*
    int**returnColumnSizes，returnColumnSizes是一个指向数组的指针，由于数组就可以看做指针，
    于是returnColumnSizes就成了指向一串指针的一个指针(有点这种感觉的[]->[][][][])
    */
    *returnSize = n;
    *returnColumnSizes = (int*)malloc(sizeof(int) * n);
    for (int i = 0; i < n; i++)
        (*returnColumnSizes)[i] = n;
    // 不太懂，returnColumnSizes指针指向的第[i]个？可不可以写成returnColumnSizes[0][i]？

    int** a = (int**)malloc(sizeof(int*) * n);
    for (int i = 0; i < n; i++)
        a[i] = (int*)malloc(sizeof(int) * n);

    // 预备工作总算完成了
    int count = 1;
    int q = 1;
    int i = 0, j = 0;
    // 这居然是道模拟题，谁再瞧不起模拟题（哼哼）
    while (q <= n / 2) {
        for (; j < n - q; j++)
            a[i][j] = count++;

        for (; i < n - q; i++)
            a[i][j] = count++;

        for (; j > q - 1; j--)
            a[i][j] = count++;

        for (; i > q - 1; i--)
            a[i][j] = count++;

        q++;
        i++; // 别忘了进入下一层循环
        j++;
    }

    if (n % 2 == 1)
        a[i][j] = count;

    return a;
}

我看不懂leetcode给的注释于是找gpt了

1. *Return an array of arrays of size returnSize.
这句话的意思是：

你需要返回一个“二维数组”，也就是一个数组的数组（int**）。
这个二维数组的大小由 *returnSize 来决定，*returnSize 表示二维数组的行数，也就是你要返回的矩阵的行数。

2. *The sizes of the arrays are returned as returnColumnSizes array.
这句话的意思是：

除了返回二维数组，你还需要返回一个 int 数组，这个数组包含每一行的列数。
*returnColumnSizes 是一个 int* 类型的指针，表示一个一维数组，其中每个元素代表二维数组中每一行的大小。
例如，如果矩阵是 3x3 的，则 *returnColumnSizes 数组可能是 [3, 3, 3]，每一行有 3 个元素。

3. *Note: Both returned array and columnSizes array must be malloced, assume caller calls free().
这句话的意思是：

你返回的二维数组和 *returnColumnSizes 数组都需要通过 malloc 动态分配内存。
函数的调用者（也就是调用 generateMatrix 函数的地方）将负责调用 free() 来释放这些动态分配的内存。
你作为函数的实现者，不需要在函数中释放内存，只需要确保内存是通过 malloc 动态分配的，并且返回给调用者

数组完结撒花✿✿ヽ(°▽°)ノ✿

（白嫖的思维图很清晰）

训练营第二天写起来就比较快了，只花了一晚上大约半天时间吧（碎碎念也少了╰(°▽°)╯）