代码随想录Day2|209长度最小的子数组 59.螺旋矩阵II

209长度最小的子数组

（读题题意理解能力，举例，将n变为具体的数值）

识别

子串问题：寻找符合某个条件的最长/最短子数组。左右指针滑窗口，一前一后齐头进。

核心/易错

左闭右开（初始化无元素0）
时间复杂度为O(n)，窗口一直往右滑动嵌套while循环。
滑动后更新数据sum等

难点/亮点

窗口何时缩小：
sum的值大于等于target；
窗口何时扩大：
sum的值小于target

算法设计思路

1.初始化最小长度为一个很大的数（INT_MAX），表示开始时没有找到满足条件的子数组。
2.使用两个指针（left和right）来表示窗口的左右边界。
3.通过移动right指针来增加窗口的和，直到窗口的和大于等于目标值。
4.当窗口的和大于等于目标值时，尝试通过移动left指针来缩小窗口，同时更新最小长度。
5.重复上述过程，直到right指针遍历完整个数组。

代码实现

代码框架

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

// 假设我们使用一个整型数组来记录窗口中字符的出现次数
// 这里假设字符集是ASCII，即0-127
#define CHAR_SET_SIZE 128

void slidingWindow(char* s) {
    int window[CHAR_SET_SIZE] = {0}; // 初始化窗口
    int left = 0, right = 0;
    int s_length = strlen(s);

    while (right < s_length) {
        // c 是将移入窗口的字符
        char c = s[right];
        window[(int)c]++; // 增加字符c的计数

        // 增大窗口
        right++;

        // 进行窗口内数据的一系列更新
        // ...

        // *** debug 输出的位置 ***
        // 注意在最终的解法代码中不要 print
        // 因为 IO 操作很耗时，可能导致超时
        printf("window: [%d, %d)\n", left, right);
        // ***********************

        // 判断左侧窗口是否要收缩
        while (left < right && /* window needs shrink condition */) {
            // d 是将移出窗口的字符
            char d = s[left];
            window[(int)d]--; // 减少字符d的计数
            // 缩小窗口
            left++;
            // 进行窗口内数据的一系列更新
            // ...
        }
    }
}

int main() {
    char s[] = "your_string_here";
    slidingWindow(s);
    return 0;
}

#include <stdio.h>
#include <limits.h> // 引入INT_MAX的定义

int minSubArrayLen(int target, int* nums, int numsSize) {
    // 初始化最小长度为INT_MAX
    int minLength = INT_MAX;
    int sum = 0;

    int left = 0, right = 0;
    // 右边界向右扩展
    for (; right < numsSize; ++right) {
        sum += nums[right];
        // 当sum的值大于等于target时，保存长度，并且收缩左边界
        while (sum >= target) {
            int subLength = right - left + 1;
            minLength = minLength < subLength ? minLength : subLength;
            sum -= nums[left++];
        }
    }
    // 若minLength不为INT_MAX，则返回minLength
    return minLength == INT_MAX ? 0 : minLength;
}

int main() {
    int nums[] = {2, 7, 11, 15}; // 测试数组
    int target = 9; // 目标和
    int numsSize = sizeof(nums) / sizeof(nums[0]); // 数组大小

    int result = minSubArrayLen(target, nums, numsSize);
    if (result != 0) {
        printf("The minimum length of a subarray with sum greater than or equal to %d is %d.\n", target, result);
    } else {
        printf("No subarray found with sum greater than or equal to %d.\n", target);
    }

    return 0;
    } 

59.螺旋矩阵II

识别

1.螺旋矩阵是一个二维数组，其元素按照螺旋顺序填充，从外圈向内圈逐层填充。
2.不变量即不处理最后一个点，这个点要留给下条边遍历的时候再来处理。考虑这个边界这个点究竟是怎么处理。

核心/易错

核心逻辑在于模拟螺旋填充的过程中：
1.左闭右开
2.循环不变量处理边界
3.循环终止：圈数（n/2）
易错：
1.循环边界的设置，需要确保不会超出数组边界。
2.循环的顺序，需要按照上、右、下、左的顺序填充。
3.奇数和偶数行数的处理遗忘，特别是当矩阵的行数为奇数时，中间的元素需要单独处理。

难点/亮点

如何正确地控制循环的边界和方向，以及如何处理矩阵的边缘情况（如奇数行数）。
亮点在于使用一个简单的循环结构（循环不变量的思想）来模拟复杂的螺旋填充过程。

算法设计思路

1.初始化一个n*n的矩阵，并分配内存。
2.使用四个循环分别模拟填充矩阵的上、右、下、左四个边界。
3.每次循环后，更新起始位置和偏移量，以模拟螺旋的移动。
4.如果矩阵的行数n为奇数，最后在中心位置填充最后一个元素。

代码实现

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

int** generateMatrix(int n, int* returnSize, int** returnColumnSizes) {
    // 初始化返回的结果数组的大小
    *returnSize = n;
    *returnColumnSizes = (int*)malloc(sizeof(int) * n); // 为返回的列大小数组分配内存

    // 初始化返回结果数组result
    int** result = (int**)malloc(sizeof(int*) * n); // 为矩阵的指针数组分配内存
    for(int i = 0; i < n; i++) {
        result[i] = (int*)malloc(sizeof(int) * n); // 为每一行分配内存
        (*returnColumnSizes)[i] = n; // 设置每一行的大小为n
    }

    // 设置每次循环的起始位置
    int startX = 0;
    int startY = 0;
    // 设置二维数组的中间值，若n为奇数。需要最后在中间填入数字
    int mid = n / 2;
    // 循环圈数
    int loop = n / 2;
    // 偏移数
    int offset = 1;
    // 当前要添加的元素
    int count = 1;

    while(loop) {
        int i = startX;
        int j = startY;
        // 模拟上侧从左到右
        for(; j < startY + n - offset; j++) {
            result[startX][j] = count++; // 填充上侧元素并递增计数
        }
        // 模拟右侧从上到下
        for(; i < startX + n - offset; i++) {
            result[i][j] = count++; // 填充右侧元素并递增计数
        }
        // 模拟下侧从右到左
        for(; j > startY; j--) {
            result[i][j] = count++; // 填充下侧元素并递增计数
        }
        // 模拟左侧从下到上
        for(; i > startX; i--) {
            result[i][j] = count++; // 填充左侧元素并递增计数
        }
        // 偏移值每次加2，为下一次循环做准备
        offset += 2;
        // 遍历起始位置每次+1，为下一次循环做准备
        startX++;
        startY++;
        loop--; // 减少循环圈数
    }
    // 若n为奇数需要单独给矩阵中间赋值
    if(n % 2) // 判断n是否为奇数
        result[mid][mid] = count; // 填充中间元素

    return result; // 返回生成的矩阵
}

int main() {
    int n = 5; // 可以修改这个值来测试不同大小的矩阵
    int returnSize;
    int* returnColumnSizes;
    int** matrix = generateMatrix(n, &returnSize, &returnColumnSizes);

    // 打印矩阵
    for(int i = 0; i < returnSize; i++) {
        for(int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    // 释放内存
    for(int i = 0; i < n; i++) {
        free(matrix[i]);
    }
    free(matrix);
    free(returnColumnSizes);

    return 0;
}