数组 - 标签 - 豆浆小屋

Q1314 矩阵区域和

Tue, 04 Aug 2026 00:00:00 +0000

![](Pasted image 20260605194937.png)

题目类型：前缀和

当你发现是在求某个大的集合下一系列具体的子集时，你可以考虑下前缀和，它可以把遍历，变成值相减。

我的写法是：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64


#include 
#include  // for std::max, std::min
using namespace std;

// 二维前缀和类，用于快速计算任意矩形子矩阵的和
class SumMatrix {
public:
    // preSum[i][j] 表示原始矩阵中前 i 行、前 j 列（即区域 [0, i) × [0, j)）所有元素的和
    // 维度为 (m+1) x (n+1)，其中 m、n 为原始矩阵的行数和列数
    vector<vector<int>> preSum;

    // 构造函数：根据原始矩阵 matrix 构建前缀和数组
    SumMatrix(vector<vector<int>>& matrix) {
        int m = matrix.size();          // 原始矩阵的行数
        int n = matrix[0].size();       // 原始矩阵的列数
        // 初始化前缀和数组，多一行一列用于简化边界处理
        preSum.resize(m + 1, vector<int>(n + 1, 0));

        // 计算前缀和：preSum[i][j] = preSum[i-1][j] + preSum[i][j-1] - preSum[i-1][j-1] + matrix[i-1][j-1]
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                preSum[i][j] = preSum[i - 1][j] + preSum[i][j - 1]
                               + matrix[i - 1][j - 1] - preSum[i - 1][j - 1];
            }
        }
    }

    // 计算原始矩阵中闭区间 [x1, x2] 行、[y1, y2] 列所围成的子矩阵的和
    // 注意：x1, x2, y1, y2 都是原始矩阵的有效索引（0-based）
    int Addmatrix(int x1, int x2, int y1, int y2) {
        // 利用前缀和公式：sum = preSum[x2+1][y2+1] - preSum[x1][y2+1] - preSum[x2+1][y1] + preSum[x1][y1]
        // 因为 preSum 的行/列索引比原始矩阵大 1，所以需要 +1 转换
        return preSum[x2 + 1][y2 + 1] - preSum[x1][y2 + 1]
               - preSum[x2 + 1][y1] + preSum[x1][y1];
    }
};

class Solution {
public:
    // 计算矩阵区域和：对于每个位置 (i, j)，求以该位置为中心、边长为 2k+1 的正方形区域的和
    // （边界超出矩阵时只取有效部分）
    vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int k) {
        int m = mat.size();      // 矩阵行数
        int n = mat[0].size();   // 矩阵列数
        // 结果矩阵，大小与原始矩阵相同
        vector<vector<int>> answer(m, vector<int>(n, 0));
        // 构建原始矩阵的前缀和对象
        SumMatrix mt = SumMatrix(mat);
        // 遍历每个位置 (i, j)
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                // 计算以 (i, j) 为中心、半径为 k 的矩形区域的边界（需限制在矩阵范围内）
                int x1 = max(i - k, 0);        // 上边界（行最小索引）
                int x2 = min(i + k, m - 1);    // 下边界（行最大索引）
                int y1 = max(j - k, 0);        // 左边界（列最小索引）
                int y2 = min(j + k, n - 1);    // 右边界（列最大索引）

                // 通过前缀和快速得到该区域的和，并填入结果矩阵
                answer[i][j] = mt.Addmatrix(x1, x2, y1, y2);
            }
        }
        return answer;
    }
};

这题说白了就是：给你一个矩阵，对于每个格子 (i,j)，把它周围 k 圈范围内的所有数加起来，填回去。

暴力做法也简单，每个格子都去遍历它的 k 邻域，但那是 $O(m \cdot n \cdot k^2)$，k 一大直接炸。

关键思路就是——前缀和把遍历变成值相减。

二维前缀和的构造其实就一句话：preSum[i][j] 表示从 (0,0) 到 (i-1, j-1) 这片矩形区域的和。多开一圈 m+1 × n+1 是为了省掉边界判空。

构造公式拆开看很直观：

1
2
3
4


preSum[i][j] = preSum[i-1][j]        // 上面那块
             + preSum[i][j-1]        // 左边那块
             + matrix[i-1][j-1]      // 当前这个数
             - preSum[i-1][j-1]      // 左上角被算了两次，扣掉

画个图就是：上加左，减重叠，加自己。

查子矩阵和也一个道理。想求 (x1,y1) 到 (x2,y2) 这个矩形（闭区间，0-index）的和：

1
2
3
4


sum = preSum[x2+1][y2+1]      // 整块从原点到右下
    - preSum[x1][y2+1]        // 砍掉上面
    - preSum[x2+1][y1]        // 砍掉左边
    + preSum[x1][y1]          // 左上角被砍了两次，补回来

就是大减小，补重叠，对称得很。

最后一步，每个格子的 k 邻域怎么定界？用 max/min 把越界的部分夹住就行——左边界不能小于 0，右边界不能超过 m-1，上下同理。这样每个格子 O(1) 就能出结果，总复杂度 $O(m \cdot n)$。

一句话总结：构造一次前缀和，然后每个格子的答案就是四次查表加减。前缀和的本质就是预计算，用空间换掉内层遍历。

Q238 除自身以外数组的乘积

Tue, 04 Aug 2026 00:00:00 +0000

1 题目类型：前缀和

本题本质上是 前缀积 + 后缀积 问题，属于前缀和思想在乘法上的扩展。

![](Pasted image 20260605202341.png)

这也是道前缀和类型的题，准确的说，这是一道前缀乘积。

我们看题，可以得到，他想要的效果其实就是把除了自身以外的数的积求出。

假设某个数组为 [a, b, c, d, e]
要求 answer[c]，则有
answer[c] = a * b * d * e
即 前缀乘积 × 后缀乘积。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


class PrefixSuffixProduct
{public:
    vector<int> prefix;
    vector<int> suffix;
    PrefixSuffixProduct(vector<int>& nums)
    {
        int sz = nums.size();
        prefix.resize(sz+1,1);
        suffix.resize(sz+1,1);
        for(int i=1;i<=sz;i++)
        {
            prefix[i] = prefix[i-1] * nums[i-1];
        }
        for(int i=sz-1;i>=0;i--)
        {
            suffix[i] = suffix[i+1] * nums[i];
        }
    }
    int plus_matrix(int x1)
    {
        return prefix[x1] * suffix[x1+1];
    }
};

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        vector<int> res;
        PrefixSuffixProduct am(nums);
        int sz = nums.size();
        res.resize(sz,1);
        for(int i = 0;i<sz;i++)
        {
           res[i] = am.plus_matrix(i);
        }
        return res;
    }
};

2 优化说明与复杂度分析

算法思想

prefix[i] 表示 nums[0] * nums[1] * ... * nums[i-1]（前 i 个元素的乘积）
suffix[i] 表示 nums[i] * nums[i+1] * ... * nums[n-1]（从 i 到末尾的乘积）
对于下标 i，答案 = prefix[i] * suffix[i+1]，即左边所有数的乘积 × 右边所有数的乘积。

时间复杂度

构建前缀/后缀数组：O(n)
计算每个位置的答案：O(n)
总复杂度：O(n)

空间复杂度

前缀/后缀数组各 O(n)，结果数组 O(n)（不计入输出时可选 O(1) 额外空间）
当前实现：O(n)

改进建议

可以只用一个输出数组，先从左到右累乘，再从右到左乘一次，将空间优化到 O(1)（不含输出数组）。

示例验证
输入：nums = [1,2,3,4]

prefix = [1, 1, 2, 6, 24]
suffix = [24, 24, 12, 4, 1]
计算结果：
- i=0 → 1 * 24 = 24
- i=1 → 1 * 12 = 12
- i=2 → 2 * 4 = 8
- i=3 → 6 * 1 = 6
  输出 [24,12,8,6]，正确。

数组理论基础

Tue, 04 Aug 2026 00:00:00 +0000

数组理论基础

一句话概括 数组是存放在一段连续内存空间中的同类型数据集合，因此支持按下标 $O(1)$ 随机访问，但在中间插入或删除时通常需要移动后续元素，时间复杂度为 $O(n)$。

1 简易回答

数组有三个核心特点：

元素类型相同。
内存空间连续。
可以通过从 0 开始的下标直接访问元素。

连续内存让数组可以根据"首地址 + 偏移量"直接定位元素，所以随机访问是 $O(1)$；代价是中间插入或删除会破坏原有顺序，需要移动其他元素，通常是 $O(n)$。

2 详细回答

2.1 1. 数组如何存储

假设有一个 int 数组：

1

int nums[5] = {10, 20, 30, 40, 50};

它在内存中可以理解为：

1
2
3
4
5


下标：   0      1      2      3      4
      ┌─────┬─────┬─────┬─────┬─────┐
元素：│  10 │  20 │  30 │  40 │  50 │
      └─────┴─────┴─────┴─────┴─────┘
地址： 1000   1004   1008   1012   1016

如果一个 int 占 4 字节，那么：

$$ \text{nums}[i]\text{ 的地址}=\text{首地址}+i\times 4 $$

更一般地：

$$ \operatorname{addr}(a[i])=\operatorname{base}(a)+i\times \operatorname{sizeof}(T) $$

这就是数组能够通过下标在 $O(1)$ 时间内访问任意元素的原因。

2.2 2. 为什么下标从 0 开始

下标可以看成元素相对首地址的偏移量：

a[0]：从首地址偏移 0 个元素。
a[1]：从首地址偏移 1 个元素。
a[i]：从首地址偏移 $i$ 个元素。

因此从 0 开始可以直接使用 base + i × sizeof(T) 计算地址。

2.3 3. 插入和删除为什么慢

假设要删除下标 2 的元素，并保持其他元素的相对顺序：

1
2
3


删除前：10  20  30  40  50
删除后：10  20  40  50
                 ←   ←

原来位于后面的 40、50 都要向前移动。因此：

访问指定下标：$O(1)$
修改指定下标：$O(1)$
尾部插入：固定数组视实现而定；vector 通常均摊 $O(1)$
中间插入或删除：$O(n)$
按值查找（无序数组）：$O(n)$

“数组不能删除元素"怎么理解 固定长度数组的内存块和长度不会因为一次删除操作自动缩短。所谓"删除”，一般是覆盖目标元素、移动后续元素，再用一个逻辑长度表示有效范围。vector::erase 能提供删除接口，但底层仍需要移动元素。

2.4 4. C++ 中的数组与 vector

对比项	原生数组 `T a[N]`	`std::array`	`std::vector`
长度	编译期固定	编译期固定	运行期可变
内存	连续	连续	连续
自动扩容	否	否	是
获取长度	需额外处理	`.size()`	`.size()`
边界检查	`[]` 不检查	`.at()` 可检查	`.at()` 可检查

vector 是一个动态顺序容器，底层使用连续内存管理元素。扩容时通常需要申请新空间并移动或复制旧元素，相关迭代器、指针和引用可能失效。详见 vector深度解析。

2.5 5. 二维数组的内存布局

2.5.1 C++ 原生二维数组

1
2
3
4


int matrix[2][3] = {
    {0, 1, 2},
    {3, 4, 5}
};

C++ 原生二维数组按行连续存储，可以把它理解为：

1
2
3


matrix[0][0] → matrix[0][1] → matrix[0][2]
                                      ↓
matrix[1][0] → matrix[1][1] → matrix[1][2]

对一个有 cols 列的二维数组，行优先布局下：

$$ \operatorname{addr}(a[i][j]) =\operatorname{base}(a)+(i\times cols+j)\times \operatorname{sizeof}(T) $$

2.5.2 Java 二维数组

Java 的 int[][] 本质上是"数组的数组"：外层数组保存对各行数组的引用，各行可以分别创建，长度也可以不同。

1
2
3
4
5


int[][] matrix = {
    {1, 2, 3},
    {4, 5},
    {6, 7, 8, 9}
};

因此不能假设不同行在内存中彼此连续；而且 Java 不向程序员暴露可直接运算的真实内存地址。

3 知识扩展

3.1 1. 连续内存为什么通常更快

数组元素相邻，CPU 读取一个元素时通常会把附近的一块数据一起加载到缓存中。顺序遍历数组时，后续数据很可能已经在缓存里，因此具有较好的缓存局部性。

3.2 2. 数组与链表的核心取舍

特性	数组	链表
内存布局	连续	通常不连续
按下标访问	$O(1)$	$O(n)$
已知节点后的插入删除	通常 $O(n)$，需要移动	$O(1)$，修改指针
缓存友好性	较好	较差
额外空间	少	需要保存指针

3.3 3. 越界访问

C++ 原生数组和 vector::operator[] 不会自动检查越界。越界访问属于未定义行为，可能读到错误数据，也可能导致程序崩溃。调试时可使用 vector::at() 获得边界检查。

3.4 易错点

把 vector 直接等同于原生数组：二者都使用连续内存，但抽象层级和能力不同。
认为数组中间删除是 $O(1)$：定位可以是 $O(1)$，移动元素仍是 $O(n)$。
认为所有语言的二维数组布局都一样：C++ 原生二维数组与 Java 的数组嵌套模型不同。
忘记下标范围是 [0, size - 1]。
混淆"物理长度"和"逻辑长度"。

3.5 自测

为什么数组可以在 $O(1)$ 时间内访问第 $i$ 个元素？
删除数组中间的元素为什么通常是 $O(n)$？
C++ 原生二维数组和 Java int[][] 的内存模型有什么区别？
vector 扩容后，旧指针、引用和迭代器为什么可能失效？
连续内存除了支持随机访问，还带来了什么性能优势？

3.6 我的补充

用自己的话重写 注意，某些列优先（Column-Major，如 Fortran）语言和 C++ 相反，先存完一列再存下一列，顺序是： [0][0]→[1][0]→[0][1]→[1][1]→[0][2]→[1][2] C/C++/Python 都是行优先，只有少数科学计算语言用列优先。

3.7 相关笔记

二分查找模板
链表常用操作总结

Q209 长度最小的子数组

Sat, 01 Aug 2026 00:00:00 +0000

题目：给定一个含有 n 个正整数的数组和一个正整数 s，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

1 我的想法

我看到这个问题，首先发现它是连续的、并且要求区间大小，会想到用前缀和操作——前缀和可以快速求出连续元素的值，但我对它的时间复杂度了解程度不够好。

核心结论：滑动窗口如果是求值的话，右窗口滑动的同时，大概率会有某个参数要进行操作，后续进行比较从而操作左窗口，这是一个连续过程，所以题目得是连续问题。

2 简要回答

因为数组元素都是正数，可以使用滑动窗口。右指针不断扩展并累加区间和；当区间和大于等于 target 时，持续移动左指针缩短区间并更新最小长度。两个指针都只向右移动，时间复杂度是 $O(n)$。

3 详细回答

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int left = 0;//左指针
        int right = 0;//右指针
        int sz = nums.size();
        int res = sz+1;
        int sum = 0;
        while(right != sz){
            sum += nums[right];
            while(sum >= target){//注意,判断left移动是一个连续过程
                res = min(res , right-left+1);
                sum -= nums[left++];
            }
            right++;
        }
        if(res == sz+1){
            return 0;
        }else{
            return res;
        }
    }
};

4 前缀和思路是否可行

可以。 设前缀和为 prefix，因为题目中的元素都是正整数，所以 prefix 严格递增。对每个左端点，可以二分查找第一个满足区间和大于等于 target 的右端点。

只用前缀和枚举左右端点：$O(n^2)$
前缀和 + 二分查找：$O(n\log n)$
滑动窗口：$O(n)$

滑动窗口更快的关键也是"元素全为正数"：右端点右移时区间和只会增大，左端点右移时区间和只会减小，因此两个指针都不需要回退。

易错或补充：比如数组 [1,1,1,1,100]，target = 100，滑动窗口的 res 初始值（sz+1）要够大，否则取不到正确答案。

Q704 二分查找

Fri, 31 Jul 2026 00:00:00 +0000

题目：给定一个升序整数数组 nums 和目标值 target。如果目标值存在，返回它的下标；否则返回 -1。题目保证数组中的元素不重复。

1 简要回答

二分查找适用于有序数组。每次比较中间元素与目标值，根据大小关系排除一半搜索范围，直到找到目标值或区间为空。

真正容易出错的地方不是算法思想，而是区间边界。写代码前必须先确定搜索区间是 [left, right] 还是 [left, right)，并让循环条件与边界更新始终遵守这个定义，这就是循环不变量。

时间复杂度：$O(\log n)$
空间复杂度：$O(1)$

2 核心思想

设数组为：

1
2
3


下标：  0   1   2   3   4   5
数组： -1   0   3   5   9  12
目标： target = 9

查找过程：

1
2
3
4
5


第 1 次：[0, 5]，mid = 2，nums[2] = 3 < 9
         排除下标 0～2，下一轮搜索 [3, 5]

第 2 次：[3, 5]，mid = 4，nums[4] = 9
         找到目标，返回下标 4

每次至少排除当前区间的一半，所以最多查找约 $\log_2 n$ 次。

3 什么是循环不变量

在循环开始、执行过程中和结束时，搜索目标所在区间的定义始终不变。

例如选择左闭右闭区间 [left, right] 后：

left 指向的元素在搜索范围内。
right 指向的元素也在搜索范围内。
每次更新后，新的区间仍然必须是左闭右闭。

因此不能一会儿按照闭区间写 right = mid - 1，一会儿又按照开区间写 right = mid。

4 size 与 size - 1 的区别

假设数组中有 6 个元素：

1
2
3


元素个数 size = 6
有效下标：0、1、2、3、4、5
最后一个有效下标：size - 1 = 5

因此，size 表示的是元素个数，而 size - 1 才是最后一个元素的下标。

4.1 为什么左闭右闭使用 size - 1

左闭右闭区间 [left, right] 包含 right：

1
2


数组有效下标：[0, 5]
搜索区间：    [0, 5]

所以 right 必须指向最后一个有效元素：

1

int right = static_cast<int>(nums.size()) - 1;

如果这里写成 right = nums.size()，就会把不存在的 nums[6] 也放进搜索范围，可能造成越界。

4.2 为什么左闭右开使用 size

左闭右开区间 [left, right) 不包含 right：

1
2


数组有效下标：[0, 5]
搜索区间：    [0, 6)

虽然 right = 6，但右端点不参与搜索，真正包含的仍然是下标 0～5：

1

int right = static_cast<int>(nums.size());

记忆方法：

右边界包含在区间里：它必须是有效下标，所以使用 size - 1。

右边界不包含在区间里：它可以指向末尾元素的后一个位置，所以使用 size。

5 写法一：左闭右闭区间

因为左右端点都有效，所以：

初始化：right = nums.size() - 1
循环条件：left <= right
去左半边：right = mid - 1
去右半边：left = mid + 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = static_cast<int>(nums.size()) - 1;

        // 搜索区间始终是 [left, right]
        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (nums[mid] == target) {
                return mid;
            }
            if (nums[mid] < target) {
                left = mid + 1;   // 下一轮：[mid + 1, right]
            } else {
                right = mid - 1;  // 下一轮：[left, mid - 1]
            }
        }

        return -1;
    }
};

初学时可以先固定使用左闭右闭写法。循环条件和边界更新比较对称：<=、mid + 1、mid - 1。

6 写法二：左闭右开区间

因为右端点不在搜索范围内，所以：

初始化：right = nums.size()
循环条件：left < right
去左半边：right = mid
去右半边：left = mid + 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = static_cast<int>(nums.size());

        // 搜索区间始终是 [left, right)
        while (left < right) {
            int mid = left + (right - left) / 2;

            if (nums[mid] == target) {
                return mid;
            }
            if (nums[mid] < target) {
                left = mid + 1;  // 下一轮：[mid + 1, right)
            } else {
                right = mid;     // 下一轮：[left, mid)
            }
        }

        return -1;
    }
};

7 两种写法对照

对比项	左闭右闭	左闭右开
搜索区间	`[left, right]`	`[left, right)`
`right` 初值	`size - 1`	`size`
循环条件	`left <= right`	`left < right`
向左收缩	`right = mid - 1`	`right = mid`
向右收缩	`left = mid + 1`	`left = mid + 1`
区间为空	`left > right`	`left == right`

不要混用：[left, right] 配套的是 left <= right 和 right = mid - 1；[left, right) 配套的是 left < right 和 right = mid。混用会漏查元素、越界或造成死循环。

8 为什么这样计算 mid

推荐写法：

1

int mid = left + (right - left) / 2;

不推荐：

1

int mid = (left + right) / 2;

数学结果相同，但当 left 和 right 很大时，left + right 可能发生整数溢出。先计算差值更加安全。

9 二分查找的真正前提

基础二分查找需要搜索空间具有单调性。在本题中表现为数组升序，因此比较 nums[mid] 与 target 后能够确定目标只可能位于哪一半。

数组中有重复元素还能二分吗？可以。重复元素不会让普通二分查找失效，但返回的可能是任意一个匹配位置。如果题目要求第一个或最后一个匹配位置，就需要使用边界二分（lower_bound / upper_bound）。

9.1 常见应用

在有序数组中查找某个值。
查找第一个大于等于目标值的位置，即 lower_bound。
查找最后一个小于等于目标值的位置。
对具有单调性的答案范围进行"二分答案"。

相关练习：LeetCode 35 搜索插入位置、LeetCode 34 查找元素首末位置、LeetCode 69 x 的平方根、LeetCode 367 有效的完全平方数。

10 空数组的细节

vector::size() 返回无符号整数。如果直接计算 nums.size() - 1，空数组时会发生无符号下溢。因此左闭右闭版本先转换为有符号整数：

1

int right = static_cast<int>(nums.size()) - 1;

11 易错点

没先定义搜索区间，就开始拼凑边界代码。
左闭右闭写成 while (left < right)，漏掉只剩一个元素的情况。
左闭右开写成 right = mid - 1，额外漏掉一个元素。
写成 left = mid 或 right = mid 时没有证明区间一定缩小，可能死循环。
使用 (left + right) / 2，忽略整数溢出风险。
看到重复元素就认为不能二分；真正的问题是返回哪一个匹配位置。