常想一二，不思八九 https://even629.com/icon.png blog 2026-03-25T02:28:13.000Z https://even629.com/ even629 Hexo leetcode每日一题 P3546 等和矩阵分割 I https://even629.com/posts/3546/ 2026-03-25T02:28:13.000Z 2026-03-25T02:28:13.000Z

时间轴

2026-03-25

init

题目：

P3546 等和矩阵分割 I

https://leetcode.cn/problems/equal-sum-grid-partition-i/description/?envType=daily-question&envId=2026-03-25

前缀和换皮题目，注意相加时可能超过int表示的最大值

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
65
66
67
68
69
70
71
72
73
#include <vector>
using std::vector;

class Solution {
    public:
        bool canPartitionGrid(vector<vector<int> > &grid)
        {
                // 1 <= m == grid.length <= 105
                // 1 <= n == grid[i].length <= 105
                // 2 <= m * n <= 105
                // 1 <= grid[i][j] <= 105
                int i, j, m = grid.size(), n = grid[0].size();
                int total = m * n;
                long last;
                vector<long> prefix_sum(total, 0);
                vector<long> suffix_sum(total, 0);

                // 水平分割
                last = grid[0][0];
                for (i = 0; i < m; i++) {
                        for (j = 0; j < n; j++) {
                                if (i == 0 && j == 0)
                                        continue;
                                prefix_sum[i * n + j] = last + prefix_sum[i * n + j - 1];
                                last = grid[i][j];
                        }
                }

                last = grid[m - 1][n - 1];
                for (i = m - 1; i >= 0; i--) {
                        for (j = n - 1; j >= 0; j--) {
                                if (i == m - 1 && j == n - 1)
                                        continue;
                                suffix_sum[i * n + j] = last + suffix_sum[i * n + j + 1];
                                last = grid[i][j];
                        }
                }

                for (i = 0; i < m - 1; i++) {
                        if (prefix_sum[i * n + n - 1] + grid[i][n - 1] == suffix_sum[i * n + n - 1])
                                return true;
                }

                // 垂直分割
                prefix_sum[0] = 0;
                last = grid[0][0];
                for (j = 0; j < n; j++) {
                        for (i = 0; i < m; i++) {
                                if (i == 0 && j == 0)
                                        continue;
                                prefix_sum[j * m + i] = last + prefix_sum[j * m + i - 1];
                                last = grid[i][j];
                        }
                }

                suffix_sum[total - 1] = 0;
                last = grid[m - 1][n - 1];
                for (j = n - 1; j >= 0; j--) {
                        for (i = m - 1; i >= 0; i--) {
                                if (i == m - 1 && j == n - 1)
                                        continue;
                                suffix_sum[j * m + i] = last + suffix_sum[j * m + i + 1];
                                last = grid[i][j];
                        }
                }
                for (j = 1; j < n; j++) {
                        if (prefix_sum[j * m] == suffix_sum[j * m] + grid[0][j])
                                return true;
                }

                return false;
        }
};
]]> 前缀和 leetcode每日一题 P2906 构造乘积矩阵 https://even629.com/posts/2906/ 2026-03-24T09:01:13.000Z 2026-03-24T09:01:13.000Z

时间轴

2026-03-24

init

题目：

P2906 构造乘积矩阵

https://leetcode.cn/problems/construct-product-matrix/description/?envType=daily-question&envId=2026-03-24

前缀和换皮题目，注意相乘时可能超过int表示的最大值

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
#include <vector>
using std::vector;

#define MODULO_NUM 12345

class Solution {
    public:
        vector<vector<int> > constructProductMatrix(vector<vector<int> > &grid)
        {
                // 1 <= n == grid.length <= 105
                // 1 <= m == grid[i].length <= 105
                // 2 <= n * m <= 105
                // 1 <= grid[i][j] <= 109
                int i, j, m = grid.size(), n = grid[0].size();
                int total = m * n, last;
                vector<vector<int> > product_matrix(m, (vector<int>(n, 0)));
                vector<int> prefix_product(total, 1);
                vector<int> suffix_product(total, 1);

                // prefix
                last = grid[0][0];
                for (i = 0; i < m; i++) {
                        for (j = 0; j < n; j++) {
                                if (i == 0 && j == 0)
                                        continue;

                                prefix_product[i * n + j] =
                                        (long)((long)last * (long)prefix_product[i * n + j - 1]) %
                                        MODULO_NUM;
                                last = grid[i][j];
                        }
                }
                // suffix
                last = grid[m - 1][n - 1];
                for (i = m - 1; i >= 0; i--) {
                        for (j = n - 1; j >= 0; j--) {
                                if (i == m - 1 && j == n - 1)
                                        continue;
                                suffix_product[i * n + j] =
                                        (long)((long)last * (long)suffix_product[i * n + j + 1]) %
                                        MODULO_NUM;
                                last = grid[i][j];
                        }
                }

                for (i = 0; i < m; i++) {
                        for (j = 0; j < n; j++) {
                                product_matrix[i][j] = (long)((long)prefix_product[i * n + j] *
                                                              (long)suffix_product[i * n + j]) %
                                                       MODULO_NUM;
                        }
                }

                return product_matrix;
        }
};
]]> 前缀和 leetcode热题100 P1143 最长公共子序列 https://even629.com/posts/1143/ 2026-03-21T09:09:13.000Z 2026-03-21T09:09:13.000Z

时间轴

2026-03-21

init

题目：

P1143 最长公共子序列

https://leetcode.cn/problems/longest-common-subsequence/description/?envType=study-plan-v2&envId=top-100-liked

经典问题了，dp[i][j] 表示 text1[0..=i] 和 text2[0..=j] 的最长公共子序列长度，状态转移方程为

  • text1[i]==text2[j] text1[i] == text2[j] 时：
    • dp[i][j]=dp[i−1][j−1]+1 dp[i][j] = dp[i-1][j-1] + 1
  • otherwise:
    • dp[i][j]=max(dp[i−1][j],dp[i][j−1]) dp[i][j] = max(dp[i-1][j], dp[i][j-1]) 
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
#include <string>
#include <vector>

using std::string;
using std::vector;

class Solution {
    public:
        int longestCommonSubsequence(string text1, string text2)
        {
                int i, j, n1 = text1.size(), n2 = text2.size();
                vector<vector<int> > dp(n1, vector<int>(n2, 0));

                for (i = 0; i < n1; i++) {
                        if (text1[i] == text2[0]) {
                                while (i < n1)
                                        dp[i++][0] = 1;
                                break;
                        }
                }

                for (j = 0; j < n2; j++) {
                        if (text2[j] == text1[0]) {
                                while (j < n2)
                                        dp[0][j++] = 1;
                                break;
                        }
                }

                // dp[i][j] 表示 text1[0..=i] 和 text2[0..=j] 的最长公共子序列长度

                // dp[i][j] = dp[i-1][j-1] + 1 (text1[i] == text2[j])
                // dp[i][j] = max(dp[i-1][j], dp[i][j-1])
                for (i = 1; i < n1; i++) {
                        for (j = 1; j < n2; j++) {
                                if (text1[i] == text2[j])
                                        dp[i][j] = dp[i - 1][j - 1] + 1;
                                else
                                        dp[i][j] = std::max(dp[i - 1][j], dp[i][j - 1]);
                        }
                }

                return dp[n1 - 1][n2 - 1];
        }
};

]]> 动态规划 leetcode热题100 P62 不同路径 https://even629.com/posts/62/ 2026-03-21T07:15:13.000Z 2026-03-21T07:15:13.000Z

时间轴

2026-03-21

init

题目：

P62 不同路径

https://leetcode.cn/problems/unique-paths/description/?envType=study-plan-v2&envId=top-100-liked

动态规划

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <vector>
using std::vector;

class Solution {
    public:
        int uniquePaths(int m, int n)
        {
                int i, j;
                vector<vector<int> > dp(m, vector<int>(n, 0));
                // dp[i][j] 表示到(i,j)的不同路径总数
                for (i = 0; i < m; i++)
                        dp[i][0] = 1;

                for (j = 0; j < n; j++)
                        dp[0][j] = 1;

                for (i = 1; i < m; i++) {
                        for (j = 1; j < n; j++)
                                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }

                return dp[m - 1][n - 1];
        }
};
]]> 动态规划 leetcode热题100 P32 最长有效括号 https://even629.com/posts/32/ 2026-03-21T06:22:13.000Z 2026-03-21T06:22:13.000Z

时间轴

2026-03-21

init

题目：

P416 分割等和子集

https://leetcode.cn/problems/longest-valid-parentheses/description/?envType=study-plan-v2&envId=top-100-liked

  • 用栈模拟一遍，将所有无法匹配的括号的位置全部置1,
    • 例如: ()(() 的mark为[0, 0, 1, 0, 0]
    • 再例如: )()((()) 的mark为[1, 0, 0, 1, 0, 0, 0, 0]
  • 经过这样的处理后, 此题就变成了寻找最长的连续的0的长度
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
#include <string>
#include <vector>
#include <stack>

using std::string;
using std::vector;
using std::stack;

class Solution {
    public:
        int longestValidParentheses(string s)
        {
                int i, j, n = s.size();
                int max_len = 0;
                stack<int> stk;
                vector<int> arr(n, 0);

                for (i = 0; i < n; i++) {
                        if (s[i] == '(') {
                                stk.push(i);
                        } else {
                                if (stk.empty())
                                        arr[i] = 1;
                                else
                                        stk.pop();
                        }
                }
                while (!stk.empty()) { //未匹配的括号
                        arr[stk.top()] = 1;
                        stk.pop();
                }
                // 找最长连续为0
                i = 0;
                while (i < n) {
                        if (arr[i] == 0) {
                                j = i;

                                while (j < n && arr[j] == 0)
                                        j++;

                                max_len = std::max(max_len, j - i);
                                i = j + 1;
                        } else {
                                i++;
                        }
                }

                return max_len;
        }
};
]]> 动态规划，栈 leetcode热题100 P416 分割等和子集 https://even629.com/posts/416/ 2026-03-21T04:06:13.000Z 2026-03-21T04:06:13.000Z

时间轴

2026-03-21

init

题目：

P416 分割等和子集

https://leetcode.cn/problems/partition-equal-subset-sum/?envType=study-plan-v2&envId=top-100-liked

将子数组求和，然后将和除以2，转化找到数组一个子集为总和的一半，即为 0-1 背包问题

dp[i][j] 表示从数组的 [0,i] 下标范围内选取若干个正整数（可以是 0 个），是否存在一种选取方案使得被选取的正整数的和等于 j。初始时，dp 中的全部元素都是 false。

初始化：

  • 如果不选取任何正整数，则被选取的正整数之和等于 0。因此对于所有 0 ≤ i < n，都有 dp[i][0]=true。
  • 当 i==0 时，只有一个正整数 nums[0] 可以被选取，因此 dp[0]nums[0]]=true。

状态转移：

  • dp[i][j] = dp[i−1][j] ∣ dp[i−1][j−nums[i]] (j >= nums[i])
  • dp[i][j] = dp[i-1][j] (j < nums[i])
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
#include <vector>
using std::vector;

class Solution {
    public:
        bool canPartition(vector<int> &nums)
        {
                int i, j, n = nums.size();
                int sum = 0, target;

                for (i = 0; i < n; i++)
                        sum += nums[i];

                if (sum % 2 != 0) // 奇数
                        return false;

                target = sum / 2;

                for (i = 0; i < n; i++) { // 有一个数超过总和的一半
                        if (nums[0] > target)
                                return false;
                }

                // 0-1 背包问题
                // dp[i][j] 表示从数组的 [0,i] 下标范围内选取若干个正整数（可以是 0 个）
                // 是否存在一种选取方案使得被选取的正整数的和等于 j。初始时，dp 中的全部元素都是 false。
                vector<vector<bool> > dp(n, vector<bool>(target + 1, false));

                // 如果不选取任何正整数，则被选取的正整数之和等于 0。因此对于所有 0 ≤ i < n，都有 dp[i][0]=true。
                for (i = 0; i < n; i++)
                        dp[i][0] = true;
                // 当 i==0 时，只有一个正整数 nums[0] 可以被选取，因此 dp[0][nums[0]]=true。
                dp[0][nums[0]] = true;

                // dp[i][j] = dp[i−1][j] ∣ dp[i−1][j−nums[i]] (j >= nums[i])
                // dp[i][j] = dp[i-1][j] (j < nums[i])
                for (i = 1; i < n; i++) {
                        for (j = 1; j <= target; j++) {
                                if (j >= nums[i])
                                        dp[i][j] = dp[i - 1][j] | dp[i - 1][j - nums[i]];
                                else
                                        dp[i][j] = dp[i - 1][j];
                        }
                }

                return dp[n - 1][target];
        }
};

]]> 动态规划 leetcode热题100 P152 乘积最大子数组 https://even629.com/posts/152/ 2026-03-21T02:44:13.000Z 2026-03-21T02:44:13.000Z

时间轴

2026-03-21

init

题目：

P152 乘积最大子数组

https://leetcode.cn/problems/maximum-product-subarray/description/?envType=study-plan-v2&envId=top-100-liked

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
#include <vector>
#include <algorithm>
using std::vector;

class Solution {
    public:
        int maxProduct(vector<int> &nums)
        {
                int i, n = nums.size();
                int max_val = nums[0];
                // dp[i][0] 表示以nums[i]结尾的 乘积最大的非空连续 子数组
                // dp[i][1] 表示以nums[i]结尾的 乘积最小的非空连续 子数组
                // dp[i][0] = max{ dp[i-1][0] * nums[i],dp[i-1][1] *nums[i] , nums[i]}
                // dp[i][1] = min{ dp[i-1][0] * nums[i],dp[i-1][1] *nums[i] , nums[i]}

                vector<vector<int> > dp(n, vector<int>(2));

                dp[0][0] = nums[0];
                dp[0][1] = nums[0];

                for (i = 1; i < n; i++) {
                        dp[i][0] = std::max(
                                { dp[i - 1][0] * nums[i], dp[i - 1][1] * nums[i], nums[i] });
                        dp[i][1] = std::min(
                                { dp[i - 1][0] * nums[i], dp[i - 1][1] * nums[i], nums[i] });
                        max_val = std::max(max_val, dp[i][0]);
                }
                return max_val;
        }
};
]]> 动态规划 leetcode热题100 P279 完全平方数 https://even629.com/posts/279/ 2026-03-20T13:17:13.000Z 2026-03-20T13:17:13.000Z

时间轴

2026-03-20

init

题目：

P279 完全平方数

https://leetcode.cn/problems/perfect-squares/description/?envType=study-plan-v2&envId=top-100-liked

动态规划

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
#include <vector>
using std::vector;

class Solution {
    public:
        int numSquares(int n) // 12
        {
                int i, j;
                vector<int> perfect_squares;
                vector<int> dp(n + 1, n + 1);

                for (i = 1; i * i <= n; i++)
                        perfect_squares.push_back(i * i); // 1 4 9

                dp[0] = 0;

                for (i = 1; i <= n; i++) {
                        for (j = 0; j < perfect_squares.size() && perfect_squares[j] <= i; j++)
                                dp[i] = std::min(dp[i], dp[i - perfect_squares[j]] + 1);
                }

                return dp[n];
        }
};

#include <cstdio>
int main()
{
        Solution S;
        int num = S.numSquares(12);
        printf("%d\n", num);
        num = S.numSquares(13);
        printf("%d\n", num);
}
]]> 动态规划 leetcode热题100 P118 杨辉三角 https://even629.com/posts/118/ 2026-03-20T10:43:13.000Z 2026-03-20T10:43:13.000Z

时间轴

2026-03-20

init

题目：

P118 杨辉三角

https://leetcode.cn/problems/pascals-triangle/description/?envType=study-plan-v2&envId=top-100-liked

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
#include <vector>
using std::vector;

class Solution {
    public:
        vector<vector<int> > generate(int numRows)
        {
                int i, j, n;
                int last = 0;
                vector<vector<int> > res;

                res.push_back({ 1 });
                if (numRows == 1)
                        return res;

                for (i = 1; i < numRows; i++) {
                        vector<int> &last_line = res.back();
                        vector<int> curr;

                        last = 0;
                        n = last_line.size();

                        for (j = 0; j < n; j++) {
                                curr.push_back(last_line[j] + last);
                                last = last_line[j];
                        }

                        curr.push_back(1);

                        res.push_back(curr);
                }

                return res;
        }
};
]]> 动态规划 leetcode热题100 P763 划分字母区间 https://even629.com/posts/763/ 2026-03-20T07:00:13.000Z 2026-03-20T07:00:13.000Z

时间轴

2026-03-20

init

题目：

P763 划分字母区间

https://leetcode.cn/problems/partition-labels/description/?envType=study-plan-v2&envId=top-100-liked

BFS 的做法：

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
#include <vector>
#include <string>
#include <queue>

using std::vector;
using std::string;
using std::queue;

class Solution {
    public:
        vector<int> partitionLabels(string s)
        {
                // 1 <= s.length <= 500
                // s 仅由小写英文字母组成
                int i, n = s.size();
                int start = 0;
                vector<int> res;
                vector<int> last_showed_pos(26, -1);

                for (i = n - 1; i >= 0; i--) { // 每个字母最后一次出现的位置
                        if (last_showed_pos[s[i] - 'a'] == -1)
                                last_showed_pos[s[i] - 'a'] = i;
                }

                while (start < n) {
                        queue<char> que;
                        vector<bool> visited(26, false);
                        int len = 0;

                        que.push(s[start]);
                        visited[s[start] - 'a'] = true;

                        while (!que.empty()) {
                                char ch = que.front();
                                que.pop();

                                int boundary = last_showed_pos[ch - 'a'];

                                len = std::max(len, boundary - start + 1);

                                for (i = 0; i <= boundary; i++) {
                                        if (!visited[s[i] - 'a']) {
                                                que.push(s[i]);
                                                visited[s[i] - 'a'] = true;
                                        }
                                }
                        }
                        res.push_back(len);
                        start = start + len;
                }
                return res;
        }
};

]]> 贪心 leetcode热题100 P347 前 K 个高频元素 https://even629.com/posts/347/ 2026-03-19T02:44:13.000Z 2026-03-19T02:44:13.000Z

时间轴

2026-03-19

init

题目：

P347 前 K 个高频元素

https://leetcode.cn/problems/top-k-frequent-elements/description/?envType=study-plan-v2&envId=top-100-liked

大顶堆

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
#include <vector>
#include <unordered_map>
#include <queue>
#include <utility>

using std::vector;
using std::unordered_map;
using std::priority_queue;
using std::pair;

class Solution {
    public:
        vector<int> topKFrequent(vector<int> &nums, int k)
        {
                vector<int> res;
                unordered_map<int, int> umap;
                priority_queue<pair<int, int>, vector<pair<int, int> >, std::less<pair<int, int> > >
                        max_heap;

                for (int val : nums)
                        umap[val]++;

                for (auto [val, times] : umap)
                        max_heap.push({ times, val });

                while (k > 0) {
                        res.push_back(max_heap.top().second);
                        max_heap.pop();
                        k--;
                }

                return res;
        }
};

实际上最优解是用快速排序：

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
#include <vector>
#include <unordered_map>
#include <utility>

using std::pair;
using std::vector;
using std::unordered_map;

class Solution {
    private:
        void quick_sort(vector<pair<int, int> > &arr, int k, int start, int end)
        {
                if (start >= end)
                        return;
                int pivot = arr[(start + end) / 2].first;
                int left = start - 1;
                int right = end + 1;

                while (left < right) {
                        do {
                                left++;
                        } while (arr[left].first > pivot);

                        do {
                                right--;
                        } while (arr[right].first < pivot);

                        if (left < right)
                                std::swap(arr[left], arr[right]);
                }

                // start ..=right, right+1..=end
                if (k <= right)
                        quick_sort(arr, k, start, right);
                else
                        quick_sort(arr, k, right + 1, end);
        }

    public:
        vector<int> topKFrequent(vector<int> &nums, int k)
        {
                int i;
                vector<pair<int, int> > arr;
                unordered_map<int, int> umap;
                vector<int> res;

                for (int val : nums)
                        umap[val]++;

                for (auto [val, times] : umap)
                        arr.push_back({ times, val });

                quick_sort(arr, k, 0, arr.size() - 1);

                for (i = 0; i < k; i++)
                        res.push_back(arr[i].second);

                return res;
        }
};
]]> 堆 leetcode热题100 P84 柱状图中的最大矩形 https://even629.com/posts/84/ 2026-03-18T10:40:13.000Z 2026-03-18T10:40:13.000Z

时间轴

2026-03-18

init

题目：

P84 柱状图中的最大矩形

https://leetcode.cn/problems/largest-rectangle-in-histogram/description/?envType=study-plan-v2&envId=top-100-liked

这个案例是经典单调栈的场景，仔细想这道题，无非也是找到最左边第一个低于自己的矩形，和最右边第一个低于自己的矩形，其实这是经典The Next Greater问题

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
#include <vector>
#include <stack>
using std::vector;
using std::stack;

class Solution {
    public:
        int largestRectangleArea(vector<int> &heights)
        {
                int i, n = heights.size(), max_area = 0;
                vector<int> left(n, 0);
                vector<int> right(n, n - 1);
                stack<int> stk1, stk2;

                for (i = 0; i < n; i++) {
                        while (!stk1.empty() && heights[i] < heights[stk1.top()]) {
                                right[stk1.top()] = i - 1; // 右边界
                                stk1.pop();
                        }
                        stk1.push(i);
                }

                // while (!stk.empty()) {
                //         right[stk.top()] = n - 1;
                // }

                for (i = n - 1; i >= 0; i--) {
                        while (!stk2.empty() && heights[i] < heights[stk2.top()]) {
                                left[stk2.top()] = i + 1; // 左边界
                                stk2.pop();
                        }
                        stk2.push(i);
                }

                // while (!stk.empty()) {
                //         left[stk.top()] = 0;
                // }

                for (i = 0; i < n; i++)
                        max_area = std::max(max_area, (right[i] - left[i] + 1) * heights[i]);

                return max_area;
        }
};

int main()
{
        vector<int> heights = { 2, 1, 5, 6, 2, 3 };
        Solution S;
        S.largestRectangleArea(heights);
}
]]> 单调栈 leetcode热题100 P739 每日温度 https://even629.com/posts/739/ 2026-03-18T08:23:13.000Z 2026-03-18T08:23:13.000Z

时间轴

2026-03-18

init

题目：

P739 每日温度

https://leetcode.cn/problems/daily-temperatures/description/?envType=study-plan-v2&envId=top-100-liked

单调栈，栈中元素始终保持单调递减

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
#include <vector>
#include <stack>

using std::vector;
using std::stack;

class Solution {
    public:
        vector<int> dailyTemperatures(vector<int> &temperatures)
        {
                int i, n = temperatures.size();
                vector<int> res(n, 0);
                stack<int> stk; // 单调栈，单调递减

                for (i = 0; i < n; i++) {
                        while (!stk.empty() && temperatures[i] > temperatures[stk.top()]) {
                                res[stk.top()] = i - stk.top();
                                stk.pop();
                        }

                        stk.push(i);
                }

                while (!stk.empty()) {
                        res[stk.top()] = 0;
                        stk.pop();
                }
                res[n - 1] = 0;

                return res;
        }
};

#include <cstdio>
int main()
{
        Solution S;
        vector<int> temperatures = { 73, 74, 75, 71, 69, 72, 76, 73 };
        vector<int> res;

        res = S.dailyTemperatures(temperatures);

        for (int val : res)
                std::printf("%d ", val);

        printf("\n");
}
]]> 单调栈 leetcode热题100 P394 字符串解码 https://even629.com/posts/394/ 2026-03-18T05:00:13.000Z 2025-03-18T05:00:13.000Z

时间轴

2026-03-18

init

题目：

P394 字符串解码

https://leetcode.cn/problems/decode-string/description/?envType=study-plan-v2&envId=top-100-liked

例子：ab2[cd3[ef]], 用人脑是怎么读的？

  • 外层结构 ab + 2[ ... ]
  • 内层 cd + 3[ef]
  • 最里面 ef

关键点：每一层 […] 都是一个 独立子问题, 这个表达式本质是：

当我们遇到 [ 的时候，必须保存状态：

  • 之前的字符串是啥？
  • 重复次数是多少？

总结一句话：

遇到 [ 就压栈保存现场，遇到 ] 就出栈恢复现场

代码如下：

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
#include <stack>
#include <string>

using std::stack;
using std::string;

class Solution {
    public:
        string decodeString(string s)
        {
                stack<int> times;
                stack<string> strs;

                string curr = "";
                int num = 0, k;

                for (char ch : s) {
                        if (ch >= '0' && ch <= '9') {
                                num = num * 10 + (ch - '0');
                        } else if (ch == '[') {
                                times.push(num);
                                strs.push(curr);
                                num = 0;
                                curr = "";
                        } else if (ch == ']') {
                                k = times.top();
                                times.pop();
                                string prev = strs.top();
                                strs.pop();

                                string tmp;
                                for (int i = 0; i < k; i++)
                                        tmp += curr;

                                curr = prev + tmp;
                        } else { // alpha
                                curr += ch;
                        }
                }

                return curr;
        }
};

#include <iostream>
int main()
{
        Solution S;
        string s1 = "2[abc]3[cd]ef";
        string s2 = "3[a2[c]]";
        string s3 = "2[2[y]pq]";

        std::cout << S.decodeString(s1) << '\n';

        std::cout << S.decodeString(s2) << '\n';

        std::cout << S.decodeString(s3) << '\n';
}
]]> 栈 leetcode热题100 P287 寻找重复数 https://even629.com/posts/287/ 2026-03-17T13:30:13.000Z 2026-03-17T13:30:13.000Z

时间轴

2026-03-17

init

题目：

P287 寻找重复数

https://leetcode.cn/problems/find-the-duplicate-number/description/?envType=study-plan-v2&envId=top-100-liked

鸽巢原理（也叫抽屉原理，英文 Pigeonhole Principle）是组合数学里一个非常基础但很强大的原理。

基本思想: 如果 n + 1 只鸽子放进 n 个鸽巢, 那么至少有一个鸽巢里有 ≥2 只鸽子

这个题利用 Floyd 判圈法，转换成 P142 这种问题

P142 环形链表 II

https://even629.com/posts/142

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
#include <vector>
using std::vector;

class Solution {
    public:
        int findDuplicate(vector<int> &nums)
        {
                // 1 <= n <= 105
                // nums.length == n + 1
                // 1 <= nums[i] <= n
                // nums 中 只有一个整数 出现 两次或多次 ，其余整数均只出现 一次

                int slow = 0, fast = 0;

                do {
                        slow = nums[slow];
                        fast = nums[nums[fast]];
                } while (slow != fast);
                // 相遇
                slow = 0;
                do {
                        slow = nums[slow];
                        fast = nums[fast];
                } while (slow != fast);

                return slow;
        }
};
]]> 双指针，鸽巢原理，Floyd判圈（ Floyd 龟兔赛跑 ） leetcode热题100 P31 下一个排列 https://even629.com/posts/31/ 2026-03-17T11:11:13.000Z 2026-03-17T11:11:13.000Z

时间轴

2026-03-17

init

题目：

P31 下一个排列

https://leetcode.cn/problems/next-permutation/description/?envType=study-plan-v2&envId=top-100-liked

例如 2, 6, 3, 5, 4, 1 这个排列， 我们想要找到下一个刚好比他大的排列，于是可以从后往前看, 我们先看后两位 4, 1 能否组成更大的排列，答案是不可以，同理 5, 4, 1也不可以, 直到3, 5, 4, 1这个排列，因为 3 < 5， 我们可以通过重新排列这一段数字，来得到下一个排列

因为我们需要使得新的排列尽量小，所以我们从后往前找第一个比3更大的数字，发现是4

然后，我们调换3和4的位置，得到4, 5, 3, 1这个数列, 因为我们需要使得新生成的数列尽量小，于是我们可以对5, 3, 1进行排序，可以发现在这个算法中，我们得到的末尾数字一定是倒序排列的，于是我们只需要把它反转即可

最终，我们得到了4, 1, 3, 5这个数列, 完整的数列则是2, 6, 4, 1, 3, 5

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
#include <vector>
#include <algorithm>
using std::vector;

class Solution {
    public:
        void nextPermutation(vector<int> &nums)
        {
                int i, n = nums.size();
                int pos = -1;

                for (i = n - 2; i >= 0; i--) {
                        if (nums[i] < nums[i + 1]) {
                                pos = i;
                                break;
                        }
                }
                
                if (pos != -1) {
                        for (i = n - 1; i >= 0; i--) {
                                if (nums[i] > nums[pos]) { // 找到第一个大于nums[pos]的数并交换
                                        std::swap(nums[i], nums[pos]);
                                        break;
                                }
                        }
                }

                std::reverse(nums.begin() + pos + 1, nums.end());
        }
};
]]> 双指针 leetcode热题100 P75 颜色分类 https://even629.com/posts/75/ 2026-03-17T11:11:13.000Z 2026-03-17T11:11:13.000Z

时间轴

2026-03-17

init

题目：

P75 颜色分类

https://leetcode.cn/problems/sort-colors/description/?envType=study-plan-v2&envId=top-100-liked

双指针

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
#include <vector>
using std::vector;

class Solution {
    public:
        void sortColors(vector<int> &nums)
        {
                // n == nums.length
                // 1 <= n <= 300
                // nums[i] 为 0、1 或 2
                int n = nums.size();
                int red = 0, blue = n - 1;
                int i = 1;

                while (red < blue && i <= blue) {
                        if (nums[i] == 0) {
                                if (i != red)
                                        std::swap(nums[i], nums[red]);
                                else
                                        i++;

                                red++;
                        } else if (nums[i] == 2) {
                                if (i != blue)
                                        std::swap(nums[i], nums[blue]);
                                else
                                        i++;

                                blue--;
                        } else {
                                i++;
                        }
                }
        }
};

int main()
{
        vector<int> nums = { 2, 0, 2, 1, 1, 0 };
        Solution S;
        S.sortColors(nums);
}
]]> 双指针 leetcode热题100 P51 N皇后 https://even629.com/posts/51/ 2026-03-17T03:11:13.000Z 2026-03-17T03:11:13.000Z

时间轴

2026-03-17

init

题目：

P51 N皇后

https://leetcode.cn/problems/n-queens/description/?envType=study-plan-v2&envId=top-100-liked

回溯：注意判断对角线时是两条对角线，方向分别为""和"/";

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#include <vector>
#include <string>
#include <unordered_set>

using std::vector;
using std::string;
using std::unordered_set;

class Solution {
    private:
        unordered_set<int> uset;

        bool queen_can_stand(vector<string> &board, int n, int posi, int posj)
        {
                int i, j;

                if (uset.count(posj))
                        return false;

                // 斜角 \

                i = posi;
                j = posj;
                while (i >= 0 && j >= 0) {
                        if (board[i][j] == 'Q')
                                return false;
                        i--;
                        j--;
                }

                // 斜角 \

                i = posi;
                j = posj;
                while (i < n && j < n) {
                        if (board[i][j] == 'Q')
                                return false;
                        i++;
                        j++;
                }

                // 斜角 /

                i = posi;
                j = posj;
                while (i >= 0 && j < n) {
                        if (board[i][j] == 'Q')
                                return false;
                        i--;
                        j++;
                }

                // 斜角 /
                i = posi;
                j = posj;
                while (i < n && j >= 0) {
                        if (board[i][j] == 'Q')
                                return false;
                        i++;
                        j--;
                }

                return true;
        }
        void __solveNQueens(vector<vector<string> > &res, vector<string> &board, int n, int row)
        {
                int j;

                if (row == n) { // 最后一行已经填满
                        res.push_back(board);
                        return;
                }

                for (j = 0; j < n; j++) {
                        if (queen_can_stand(board, n, row, j)) {
                                uset.insert(j); // 标识第j列已经有皇后
                                board[row][j] = 'Q';

                                __solveNQueens(res, board, n, row + 1);

                                board[row][j] = '.';
                                uset.erase(j);
                        }
                }
        }

    public:
        vector<vector<string> > solveNQueens(int n)
        {
                int i;
                string line;
                vector<string> board;
                vector<vector<string> > res;

                for (i = 0; i < n; i++)
                        line.push_back('.');

                for (i = 0; i < n; i++)
                        board.push_back(line);

                __solveNQueens(res, board, n, 0);

                return res;
        }
};
]]> 回溯 leetcode热题100 P131 分割回文串 https://even629.com/posts/131/ 2026-03-16T13:32:13.000Z 2026-03-16T13:32:13.000Z

时间轴

2026-03-16

init

题目：

P131 分割回文串

https://leetcode.cn/problems/palindrome-partitioning/description/?envType=study-plan-v2&envId=top-100-liked

回溯：找分割的字符串大小的组合，且每个组合都是回文

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
#include <vector>
#include <string>

using std::vector;
using std::string;

class Solution {
    private:
        void __partition(string &s, vector<vector<int> > &sum_vec, vector<int> &curr, int curr_sum)
        {
                int i, n = s.size();

                if (curr_sum == n) {
                        sum_vec.push_back(curr);
                        return;
                }

                for (i = 1; i <= n; i++) {
                        if (curr_sum + i <= n && isPalindrome(s.substr(curr_sum, i))) {
                                curr.push_back(i);
                                __partition(s, sum_vec, curr, curr_sum + i);
                                curr.pop_back();
                        }
                }
        }
        bool isPalindrome(string s)
        {
                int left = 0, right = s.size() - 1;
                while (left < right) {
                        if (s[left] != s[right])
                                return false;
                        left++;
                        right--;
                }
                return true;
        }

    public:
        vector<vector<string> > partition(string s)
        {
                int pos, n = s.size();
                bool flag = false;
                vector<vector<string> > ret;
                vector<vector<int> > sum_vec;
                vector<int> curr;

                __partition(s, sum_vec, curr, 0);

                for (vector<int> &combinatioin : sum_vec) {
                        vector<string> curr_str_vec;
                        pos = 0;

                        for (int size : combinatioin) {
                                curr_str_vec.push_back(s.substr(pos, size));
                                pos += size;
                        }
                        ret.push_back(curr_str_vec);
                }

                return ret;
        }
};

然而上面这种方法判断回文会有超级多的重复计算，考虑动态规划

我们可以将字符串 s 的每个子串 s[i…j] 是否为回文串预处理出来，使用动态规划即可。设 f(i,j) 表示 s[i…j] 是否为回文串，那么有状态转移方程：

f(i,j)=True,i≥jf(i,j) = True, i≥j

f(i,j)=f(i+1,j−1)∧(s[i]=s[j])f(i,j) = f(i+1,j−1) ∧ (s[i]=s[j])

优化后：

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
65
#include <vector>
#include <string>

using std::vector;
using std::string;

class Solution {
    private:
        void __partition(string &s, vector<vector<int> > &sum_vec, vector<int> &curr, int curr_sum,
                         vector<vector<bool> > &isPalindrome)
        {
                int i, n = s.size();

                if (curr_sum == n) {
                        sum_vec.push_back(curr);
                        return;
                }

                for (i = 1; i <= n; i++) {
                        if (curr_sum + i <= n && isPalindrome[curr_sum][curr_sum + i - 1]) {
                                curr.push_back(i);
                                __partition(s, sum_vec, curr, curr_sum + i, isPalindrome);
                                curr.pop_back();
                        }
                }
        }

    public:
        vector<vector<string> > partition(string s)
        {
                int pos, n = s.size();
                vector<vector<string> > ret;
                vector<vector<int> > sum_vec;
                vector<int> curr;

                vector<vector<bool> > isPalindrome(n, vector<bool>(n, false));


                for (int i = n - 1; i >= 0; i--) {
                        for (int j = i; j < n; j++) {
                                if (s[i] == s[j]) {
                                        if (j - i <= 2)
                                                isPalindrome[i][j] = true;
                                        else
                                                isPalindrome[i][j] = isPalindrome[i + 1][j - 1];
                                }
                        }
                }

                __partition(s, sum_vec, curr, 0, isPalindrome);

                for (vector<int> &combinatioin : sum_vec) {
                        vector<string> curr_str_vec;
                        pos = 0;

                        for (int size : combinatioin) {
                                curr_str_vec.push_back(s.substr(pos, size));
                                pos += size;
                        }
                        ret.push_back(curr_str_vec);
                }

                return ret;
        }
};

官方题解

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
class Solution {
private:
    vector<vector<int>> f;
    vector<vector<string>> ret;
    vector<string> ans;
    int n;

public:
    void dfs(const string& s, int i) {
        if (i == n) {
            ret.push_back(ans);
            return;
        }
        for (int j = i; j < n; ++j) {
            if (f[i][j]) {
                ans.push_back(s.substr(i, j - i + 1));
                dfs(s, j + 1);
                ans.pop_back();
            }
        }
    }

    vector<vector<string>> partition(string s) {
        n = s.size();
        f.assign(n, vector<int>(n, true));

        for (int i = n - 1; i >= 0; --i) {
            for (int j = i + 1; j < n; ++j) {
                f[i][j] = (s[i] == s[j]) && f[i + 1][j - 1];
            }
        }

        dfs(s, 0);
        return ret;
    }
};
]]> 动态规划 + 回溯 leetcode热题100 P78 子集 https://even629.com/posts/78/ 2026-03-16T07:34:13.000Z 2026-03-16T07:34:13.000Z

时间轴

2026-03-16

init

题目：

P78 子集

https://leetcode.cn/problems/subsets/description/?envType=study-plan-v2&envId=top-100-liked

我最开始想到的就是公式化回溯：

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
#include <vector>
#include <unordered_set>

using std::vector;
using std::unordered_set;

class Solution {
    private:
        void __subsets(vector<int> &nums, vector<vector<int> > &subsets, vector<int> &curr,
                       unordered_set<int> uset, int nr, int start)
        {
                if (curr.size() == nr) {
                        subsets.push_back(curr);
                        return;
                }

                int i, n = nums.size();
                for (i = start; i < n; i++) {
                        if (uset.count(nums[i]))
                                continue;

                        curr.push_back(nums[i]);
                        uset.insert(nums[i]);

                        __subsets(nums, subsets, curr, uset, nr, i + 1);

                        curr.pop_back();
                        uset.erase(nums[i]);
                }
        }

    public:
        vector<vector<int> > subsets(vector<int> &nums)
        {
                /*
                 * 1 <= nums.length <= 10
                 * -10 <= nums[i] <= 10
                 * nums 中的所有元素 互不相同
                 */
                vector<vector<int> > subsets;
                vector<int> curr;
                unordered_set<int> uset;
                int i, n = nums.size();

                subsets.push_back({}); // 空集

                for (i = 1; i < n; i++)
                        __subsets(nums, subsets, curr, uset, i, 0);

                subsets.push_back(nums); // 满集
                return subsets;
        }
};

leetcode 题解中方法推荐利用位运算，确实很巧妙

0/1 序列子集0/1 序列对应的二进制数
000{}0
0011
0102
0113
1004
1015
1106
1117
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
public:
    vector<int> t;
    vector<vector<int>> ans;

    vector<vector<int>> subsets(vector<int>& nums) {
        int n = nums.size();
        for (int mask = 0; mask < (1 << n); ++mask) {
            t.clear();
            for (int i = 0; i < n; ++i) {
                if (mask & (1 << i)) {
                    t.push_back(nums[i]);
                }
            }
            ans.push_back(t);
        }
        return ans;
    }
};
]]> 回溯