笺札

1141. 查询近30天活跃用户数

2026-10-11T16:00:00.000Z

1141. 查询近30天活跃用户数

难度：简单 | 题号：1141 | 链接：1141. 查询近30天活跃用户数 - 力扣（LeetCode） | 数据结构：SQL
关联：订单最多的用户（同为「按维度分组计数」）· 每月交易 I（同为日期函数 + 分组聚合）· 可对照 SQL原理_02（日期函数 / 分组聚合）。

🎯 问题描述

描述：写一条 SQL 查询，求出截至 2019-07-27（含）的近 30 天内，每天的活跃用户数。活跃用户指当天至少进行一次活动的用户，返回结果表的列名须为 day 和 active_users，且每天都可能出现重复用户（同一用户一天多次活动只算一次）。

表：Activity

+---------------+---------+
| Column Name   | Type    |
+---------------+---------+
| user_id       | int     |
| session_id    | int     |
| activity_date | date    |
| activity_type | enum    |
+---------------+---------+
该表没有主键，它可能有重复行。
activity_type 列是 ENUM ['open_session', 'end_session', 'scroll_down', 'send_message'] 之一。
该表包含用户 ID、会话 ID、活动日期与活动类型。

示例 1：

输入：
Activity table:
+---------+------------+---------------+---------------+
| user_id | session_id | activity_date | activity_type |
+---------+------------+---------------+---------------+
| 1       | 1          | 2019-07-20    | open_session  |
| 1       | 1          | 2019-07-20    | scroll_down   |
| 1       | 1          | 2019-07-20    | end_session   |
| 2       | 4          | 2019-07-20    | open_session  |
| 2       | 4          | 2019-07-21    | send_message  |
| 2       | 4          | 2019-07-21    | end_session   |
| 3       | 2          | 2019-07-21    | open_session  |
| 3       | 2          | 2019-07-21    | send_message  |
| 3       | 2          | 2019-07-21    | end_session   |
| 4       | 3          | 2019-06-25    | open_session  |
| 4       | 3          | 2019-06-25    | end_session   |
+---------+------------+---------------+---------------+
输出：
+------------+--------------+
| day        | active_users |
+------------+--------------+
| 2019-07-20 | 2            |
| 2019-07-21 | 2            |
+------------+--------------+
解释：
- 2019-06-25 不在近 30 天窗口内（早于 2019-06-28），被排除。
- 2019-07-20 有用户 1、2 活动 → 2 个活跃用户。
- 2019-07-21 有用户 2、3 活动 → 2 个活跃用户。

提示：

窗口是「左闭右开」的滑窗：activity_date 落在 [2019-06-28, 2019-07-27] 之间，即 DATEDIFF('2019-07-27', activity_date) < 30（等价于 <= 29）。
同一天同一用户多次活动只能计一次 → 必须 COUNT(DISTINCT user_id)。
结果按天分组，列名严格为 day / active_users（active_users 是保留歧义最小的别名，建议加反引号或双引号）。

💻 解题思路

思路1：WHERE 筛日期 + 按天分组去重计数（用户解法）

核心逻辑

三步走：① WHERE 用 DATEDIFF 把数据裁到近 30 天窗口；② GROUP BY activity_date 按天分组；③ COUNT(DISTINCT user_id) 数出当天不重复的活跃用户数，并把日期列取别名为 day。

代码实现

# Write your MySQL query statement below
SELECT activity_date AS day,
       COUNT(DISTINCT user_id) AS active_users
FROM Activity
WHERE activity_date <= '2019-07-27'
  AND DATEDIFF('2019-07-27', activity_date) < 30
GROUP BY activity_date;

💡 精简写法：BETWEEN '2019-06-28' AND '2019-07-27' 更直观（右边界含 27 号，左边界 28 号正好 30 天）；用 DATEDIFF 的好处是无需手算起始日期。

📊 性能分析

时间复杂度： $O(n)$ （扫描全表 + 分组聚合；activity_date 上有索引时可先 range scan 裁剪数据量）。
空间复杂度： $O(d)$ ， $d$ 为不同日期数（分组哈希表规模）。

思考

别用 >= 30：DATEDIFF('2019-07-27', '2019-06-27') = 30，已经出界；< 30 或 <= 29 才是「近 30 天」。
本题是滑动窗口计数的模板：先用日期函数把窗口裁出来，再分组去重计数。同类场景：日活 / 周活 / 月活（DAU/WAU/MAU）。
若题目改成「近 30 天总体活跃用户数」，就要去掉 GROUP BY，直接 COUNT(DISTINCT user_id)。

🔗 相关链接

所属 MOC：学习-数据结构与算法MOC
题集索引：LeetCode题集索引
关联概念：SQL原理_02（日期函数 / 分组聚合）
同类题目：每月交易 I · 订单最多的用户

📝 总结

「滑动窗口 + 按维度去重计数」模板：

用 DATEDIFF(ref_date, date_col) < N 或 BETWEEN ... AND ... 裁出窗口 → GROUP BY 日期 → COUNT(DISTINCT 用户)。
两个易错点：① 窗口边界左闭右开（< 30 不是 <= 30）；② 同一用户同一天多次活动必须 DISTINCT。

🔗 题集索引：LeetCode题集索引 · 算法地图：学习-数据结构与算法MOC
📎 同类题：每月交易 I · 订单最多的用户｜概念：SQL原理_02

1193. 每月交易 I

2026-10-11T16:00:00.000Z

1193. 每月交易 I

难度：中等 | 题号：1193 | 链接：1193. 每月交易 I - 力扣（LeetCode） | 数据结构：SQL
关联：查询近30天活跃用户数（同为日期函数 + 分组聚合）· 订单最多的用户（分组计数）· 可对照 SQL原理_02（日期格式化 / 条件聚合）。

🎯 问题描述

描述：写一条 SQL 查询，找出每个月、每个国家/地区的：① 交易总数；② 交易总金额；③ 已批准（state = 'approved'）的交易数；④ 已批准交易的总额。结果以任意顺序返回。

表：Transactions

+---------------+---------+
| Column Name   | Type    |
+---------------+---------+
| id            | int     |
| country       | varchar |
| state         | enum    |
| amount        | int     |
| trans_date    | date    |
+---------------+---------+
id 是该表的主键（具有唯一值的列）。
state 列类型为 ENUM ['approved', 'declined'] 之一。
该表包含有关传入交易的信息。

示例 1：

输入：
Transactions table:
+------+---------+----------+--------+------------+
| id   | country | state    | amount | trans_date |
+------+---------+----------+--------+------------+
| 121  | US      | approved | 1000   | 2018-12-18 |
| 122  | US      | declined | 2000   | 2018-12-19 |
| 123  | US      | approved | 2000   | 2019-01-01 |
| 124  | DE      | approved | 2000   | 2019-01-07 |
+------+---------+----------+--------+------------+
输出：
+----------+---------+-------------+----------------+--------------------+-----------------------+
| month    | country | trans_count | approved_count | trans_total_amount | approved_total_amount |
+----------+---------+-------------+----------------+--------------------+-----------------------+
| 2018-12  | US      | 2           | 1              | 3000               | 1000                  |
| 2019-01  | US      | 1           | 1              | 2000               | 2000                  |
| 2019-01  | DE      | 1           | 1              | 2000               | 2000                  |
+----------+---------+-------------+----------------+--------------------+-----------------------+

提示：

先按月 + 国家分组，再在组内同时计算「总计数 / 条件计数 / 总金额 / 条件金额」——典型条件聚合（Conditional Aggregation）。
月份要从 trans_date 抽出来：DATE_FORMAT(trans_date, '%Y-%m')（或 SUBSTRING(trans_date, 1, 7)）。
条件计数有两种写法：SUM(state = 'approved') 直接对布尔求和（MySQL 中真值 = 1）；或 COUNT(IF(state = 'approved', 1, NULL))（只数非 NULL，更通用）。
结果列名必须与要求完全一致。

💻 解题思路

思路1：DATE_FORMAT + 条件聚合（用户解法）

核心逻辑

用 DATE_FORMAT(trans_date, '%Y-%m') 造出月份列并按 (month, country) 分组；组内分别用 COUNT(*)、SUM(布尔)、SUM(amount)、SUM(IF(...)) 算出四个指标。

代码实现

# Write your MySQL query statement below
SELECT DATE_FORMAT(trans_date, '%Y-%m') AS month,
       country,
       COUNT(*) AS trans_count,
       COUNT(IF(state = 'approved', 1, NULL)) AS approved_count,
       SUM(amount) AS trans_total_amount,
       SUM(IF(state = 'approved', amount, 0)) AS approved_total_amount
FROM Transactions
GROUP BY month, country;

💡 更简洁的等价写法（利用 MySQL 布尔转 0/1）：

SELECT DATE_FORMAT(trans_date, '%Y-%m') AS month, country,
       COUNT(*) AS trans_count,
       SUM(state = 'approved') AS approved_count,
       SUM(amount) AS trans_total_amount,
       SUM(IF(state = 'approved', amount, 0)) AS approved_total_amount
FROM Transactions
GROUP BY 1, 2;

📊 性能分析

时间复杂度： $O(n)$ （全表扫描 + 哈希分组聚合；(trans_date, country) 有索引时可加速）。
空间复杂度： $O(g)$ ， $g$ 为 (月, 国家) 组合数。

思考

GROUP BY month 合法吗？ MySQL 允许按 SELECT 里的别名分组（GROUP BY month / GROUP BY 1），但标准 SQL 不支持，跨库迁移时建议写完整的 DATE_FORMAT(...)。
COUNT(IF(...)) vs SUM(IF(...))：计数用 COUNT(IF(cond, 1, NULL))（COUNT 忽略 NULL）；求和用 SUM(IF(cond, amount, 0))（补 0 避免 NULL 污染、也避免少加行）。用 SUM(state = 'approved') 最省，但依赖 MySQL 的布尔→整数转换。
NULL 陷阱：SUM 遇到全 NULL 组会返回 NULL 而非 0，所以条件求和务必显式补 0。
进阶：LeetCode 1194「每月交易 II」在此基础上要额外处理**退款（chargeback）**与原交易的配平，会用到自连接 / 窗口函数。

🔗 相关链接

所属 MOC：学习-数据结构与算法MOC
题集索引：LeetCode题集索引
关联概念：SQL原理_02（日期函数 / 条件聚合 / NULL 处理）
同类题目：查询近30天活跃用户数（窗口 + 分组）· 订单最多的用户（分组计数）

📝 总结

「条件聚合（Pivot 式多指标聚合）」模板：

先派生时间维度列（DATE_FORMAT / SUBSTRING）→ 按维度 GROUP BY → 组内用 COUNT / COUNT(IF()) / SUM / SUM(IF()) 一次算出多个指标。
三个关键点：① 月份抽取用日期函数，别手写 SUBSTRING 更稳；② 条件计数用 COUNT(IF(cond,1,NULL))、条件求和用 SUM(IF(cond,val,0))；③ SUM 对全 NULL 组返回 NULL，补 0 最安全。

🔗 题集索引：LeetCode题集索引 · 算法地图：学习-数据结构与算法MOC
📎 同类题：查询近30天活跃用户数 · 订单最多的用户｜概念：SQL原理_02

1341. 电影评分

2026-10-11T16:00:00.000Z

1341. 电影评分

难度：中等 | 题号：1341 | 链接：1341. 电影评分 - 力扣（LeetCode） | 数据结构：SQL
关联：订单最多的用户（同为「分组计数取 Top-1」）· 分数排名（同为「排名 / 并列处理」）· 部门工资最高的员工（分组最值）· 可对照 SQL原理_02（多表连接 / 排序 / UNION ALL）。

🎯 问题描述

描述：写一个解决方案，同时完成两件事：

找出评论电影数量最多的用户名。若并列，返回字典序较小的用户名。
找出 2020 年 2 月里平均评分最高的电影名称。若并列，返回字典序较小的电影名称。

返回结果表的列名为 results。

表：Movies / 表：Users / 表：MovieRating

+---------------+---------+      +---------------+---------+      +---------------+---------+
| Column Name   | Type    |      | Column Name   | Type    |      | Column Name   | Type    |
+---------------+---------+      +---------------+---------+      +---------------+---------+
| movie_id      | int     |      | user_id       | int     |      | movie_id      | int     |
| title         | varchar |      | name          | varchar |      | user_id       | int     |
+---------------+---------+      +---------------+---------+      | rating        | int     |
movie_id 是主键。                user_id 是主键。                 | created_at    | date    |
title 唯一。                     name 唯一。                      +---------------+---------+
                                                                 (movie_id, user_id) 是联合主键。
                                                                 created_at 为点评日期。

示例 1：

输入：
Movies 表：              Users 表：          MovieRating 表：
+----------+----------+  +--------+-------+  +----------+---------+--------+------------+
| movie_id | title    |  | user_id| name  |  | movie_id | user_id | rating | created_at |
+----------+----------+  +--------+-------+  +----------+---------+--------+------------+
| 1        | Avengers |  | 1      | Daniel|  | 1        | 1       | 3      | 2020-01-12 |
| 2        | Frozen 2 |  | 2      | Monica|  | 1        | 2       | 4      | 2020-02-11 |
| 3        | Joker    |  | 3      | Maria |  | 1        | 3       | 2      | 2020-02-12 |
+----------+----------+  | 4      | James |  | 1        | 4       | 1      | 2020-01-01 |
                         +--------+-------+  | 2        | 1       | 5      | 2020-02-17 |
                                             | 2        | 2       | 2      | 2020-02-01 |
                                             | 2        | 3       | 2      | 2020-03-01 |
                                             | 3        | 1       | 3      | 2020-02-22 |
                                             | 3        | 2       | 4      | 2020-02-25 |
                                             +----------+---------+--------+------------+
输出：
+----------+
| results  |
+----------+
| Daniel   |
| Frozen 2 |
+----------+
解释：
- Daniel 和 Monica 都点评了 3 部电影，但 Daniel 字典序较小 → 取 Daniel。
- Frozen 2 与 Joker 在 2 月的平均评分都是 3.5，但 Frozen 2 字典序较小 → 取 Frozen 2。

提示：

两问结果是两条独立的行，需要把两个查询的结果竖着拼起来 → 用 UNION ALL（不要用 UNION，语义上不清、还可能误去重）。
「并列取字典序较小」= ORDER BY 主指标 DESC, 名字 ASC 后 LIMIT 1，一次排序同时解决并列。
第二问要先 WHERE created_at 限定在 2020-02-01 ~ 2020-02-29，再按电影分组取平均分。
每问都要 LIMIT 1 —— 子查询里各自排序取一行，外层再 UNION ALL。

💻 解题思路

思路1：两个子查询各取 Top-1，再 UNION ALL（用户解法）

核心逻辑

把题目拆成两个互不相干的「Top-1」：① 用户名按「评论电影数」降序、名字升序 → 第一行；② 电影名按「2 月平均评分」降序、名字升序 → 第一行。两者列名都对齐成 results，用 UNION ALL 竖拼。

代码实现

# Write your MySQL query statement below
(
    SELECT u.name AS results
    FROM Users u
    JOIN MovieRating mr ON u.user_id = mr.user_id
    GROUP BY u.user_id
    ORDER BY COUNT(DISTINCT mr.movie_id) DESC, u.name ASC
    LIMIT 1
)
UNION ALL
(
    SELECT m.title AS results
    FROM Movies m
    JOIN MovieRating mr ON m.movie_id = mr.movie_id
    WHERE mr.created_at >= '2020-02-01'
      AND mr.created_at < '2020-03-01'
    GROUP BY m.movie_id
    ORDER BY AVG(mr.rating) DESC, m.title ASC
    LIMIT 1
);

📊 性能分析

时间复杂度： $O(n \log n)$ （两次分组聚合 + 两次排序；排序是主导项）。
空间复杂度： $O(n)$ （分组哈希表 / 排序临时表）。

思考

COUNT(DISTINCT movie_id) 的必要性：(movie_id, user_id) 是联合主键，理论上一个用户对同一部电影只有一条记录，COUNT(*) 也可行；但写 COUNT(DISTINCT movie_id) 语义更清晰（「评论了多少部电影」而非「多少条记录」），防御性更强。
ORDER BY 主指标 DESC, 名字 ASC 是处理「并列取字典序最小」的通用技巧——把并列打平逻辑交给排序，而不是写在 WHERE 里。
日期边界用左闭右开：>= '2020-02-01' AND < '2020-03-01' 比 BETWEEN ... AND '2020-02-29' 更稳（闰年 / 不同月天数都不会错）。
括号包裹子查询 + LIMIT：MySQL 里 UNION ALL 两侧的 ORDER BY ... LIMIT 必须用括号包起来，否则会被当成整体排序；若需要最终结果保持两个子查询的顺序，可在外层再套一层排序或依赖 MySQL 实现（题解一般允许）。
UNION vs UNION ALL：本题两行理论上可能同名（某用户名恰好等于某电影名），用 UNION 会被误去重 → 必须 UNION ALL。

思路2：用窗口函数替代 LIMIT（可扩展写法）

核心逻辑

如果题目改成「两个指标都要输出多个并列结果」或需要在同一查询里做更多排名，可把 ORDER BY ... LIMIT 1 换成 RANK() OVER (ORDER BY 指标 DESC, 名字 ASC) 再筛 rk = 1。本题只需一行，LIMIT 1 已足够，此处仅作对分数排名一类题的写法呼应。

代码实现

SELECT name AS results
FROM (
    SELECT u.name, RANK() OVER (ORDER BY COUNT(DISTINCT mr.movie_id) DESC, u.name ASC) AS rk
    FROM Users u JOIN MovieRating mr ON u.user_id = mr.user_id
    GROUP BY u.user_id
) t
WHERE rk = 1;

思考

用了 RANK 而非 DENSE_RANK：题目要求「并列取一个」，靠名字二次排序已保证唯一，其实 ROW_NUMBER() 也够；RANK 语义上更贴近「第一名」。
两套思路本质相同——先算指标，再排序取第一名；区别只是「筛选第一名」用 LIMIT 还是 rk = 1。

🔗 相关链接

所属 MOC：学习-数据结构与算法MOC
题集索引：LeetCode题集索引
关联概念：SQL原理_02（多表连接 / 排序 / UNION）· SQL原理_03（窗口函数）
同类题目：订单最多的用户 · 分数排名 · 部门工资最高的员工

📝 总结

「多个独立 Top-1 拼装」模板：

每问单独写「分组 → 排序（主指标 DESC, 次要键用于打平）→ LIMIT 1」，用括号包住 ORDER BY ... LIMIT，再用 UNION ALL 竖拼。
三个关键点：① 「并列取字典序最小」交给她 ORDER BY 主指标 DESC, 名字 ASC；② 日期边界用左闭右开；③ 竖拼两个同类结果用 UNION ALL（可能同名，别用 UNION）。

🔗 题集索引：LeetCode题集索引 · 算法地图：学习-数据结构与算法MOC
📎 同类题：订单最多的用户 · 分数排名 · 部门工资最高的员工｜概念：SQL原理_02 · SQL原理_03

596. 超过5名学生的课

2026-10-11T16:00:00.000Z

596. 超过5名学生的课

难度：简单 | 题号：596 | 链接：596. 超过 5 名学生的课 - 力扣（LeetCode） | 数据结构：SQL
关联：订单最多的用户（同为「分组计数 + 过滤」）· 查询近30天活跃用户数（分组去重计数）· 可对照 SQL原理_02（GROUP BY / HAVING / WHERE 与 HAVING 的区别）。

🎯 问题描述

描述：查询至少有 5 名学生的所有课程（班级）。结果以任意顺序返回。

表：Courses

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| student     | varchar |
| class       | varchar |
+-------------+---------+
(student, class) 是该表的联合主键（不同值的列的组合）。
该表的每一行表示学生的名字和他们注册的课程。

示例 1：

输入：
Courses table:
+---------+----------+
| student | class    |
+---------+----------+
| A       | Math     |
| B       | English  |
| C       | Math     |
| D       | Biology  |
| E       | Math     |
| F       | Computer |
| G       | Math     |
| H       | Math     |
| I       | Math     |
+---------+----------+
输出：
+---------+
| class   |
+---------+
| Math    |
+---------+
解释：
- Math 课有 6 名学生，包含它。
- English / Biology / Computer 各只有 1 名学生，不包含。

提示：

先按 class 分组计数，再对分组结果过滤 → 必须用 HAVING，不能用 WHERE（WHERE 在分组之前过滤行，看不到 COUNT）。
题目提示「同一学生在同一课程中不应被重复计算」→ 本表 (student, class) 是联合主键天然去重，COUNT(*) 即可；但写 COUNT(DISTINCT student) 更防御（防止数据重复时误算）。
HAVING 中不能引用列别名（HAVING cnt >= 5 会报 Unknown column），要写完整聚合表达式 COUNT(*) >= 5。

💻 解题思路

思路1：GROUP BY + HAVING（用户解法）

核心逻辑

按 class 分组，COUNT(*) 数出每门课的学生数，HAVING COUNT(*) >= 5 筛出人数达标的课程。

代码实现

# Write your MySQL query statement below
SELECT class
FROM Courses
GROUP BY class
HAVING COUNT(*) >= 5;

💡 更防御的写法（同一学生重复选课时也正确）：
1
2
3
4
SELECT class
FROM Courses
GROUP BY class
HAVING COUNT(DISTINCT student) >= 5;

📊 性能分析

时间复杂度： $O(n)$ （全表扫描 + 哈希分组；class 上有索引可加速分组）。
空间复杂度： $O(c)$ ， $c$ 为课程数。

思考

WHERE vs HAVING —— 本题最核心的考点：
- WHERE 作用于原始行，在 GROUP BY 之前执行，用不了聚合函数；
- HAVING 作用于分组后的结果，在 GROUP BY 之后执行，专门用来筛选聚合值。
- 口诀：「行级条件走 WHERE，组级条件走 HAVING」。
别把 student_count 当别名用在 HAVING 里：SELECT class, COUNT(*) AS cnt ... HAVING cnt >= 5 在 MySQL 里会报 Error 1054: Unknown column 'cnt' in 'having clause'（HAVING 的求值早于 SELECT 别名解析）→ 必须重写 COUNT(*)。
COUNT(*) 还是 COUNT(DISTINCT student)：依赖联合主键去重时二者等价；若表可能存在重复插入了同一 (student, class)，只有 DISTINCT 版才正确。工程里宁可多写 DISTINCT。

🔗 相关链接

所属 MOC：学习-数据结构与算法MOC
题集索引：LeetCode题集索引
关联概念：SQL原理_02（分组过滤 / WHERE 与 HAVING）
同类题目：订单最多的用户（HAVING 计数）· 查询近30天活跃用户数（COUNT(DISTINCT ...)）

📝 总结

「分组后按计数过滤」模板：

GROUP BY 分组列 HAVING COUNT(...) >= N，一句话即得。
三个关键点：① 组级条件用 HAVING，别用 WHERE；② HAVING 里不能引别名，写全 COUNT(*)；③ 人数类统计优先 COUNT(DISTINCT 学生) 防重复数据。

🔗 题集索引：LeetCode题集索引 · 算法地图：学习-数据结构与算法MOC
📎 同类题：订单最多的用户 · 查询近30天活跃用户数｜概念：SQL原理_02

586. 订单最多的用户

2026-10-11T16:00:00.000Z

586. 订单最多的用户

难度：简单 | 题号：586 | 链接：586. 订单最多的客户 - 力扣（LeetCode） | 数据结构：SQL
关联：从不订购的用户（同用 Orders 表，一文求"从未下单"，一文求"下单最多"）· 分数排名（同为「分组计数 + 排名」题）· 可对照 SQL原理_03（CTE 写法）与 SQL原理_02（窗口函数）。

🎯 问题描述

描述：查找订单数量最多的客户的 customer_number。测试用例保证订单最多的客户只有一个。

表：Orders

+-----------------+----------+
| Column Name     | Type     |
+-----------------+----------+
| order_number    | int      |
| customer_number | int      |
+-----------------+----------+
order_number 是该表的主键（具有唯一值的列）。
该表包含订单 ID 与下单客户 ID 的对应关系。

示例 1：

输入：
Orders 表：
+--------------+-----------------+
| order_number | customer_number |
+--------------+-----------------+
| 1            | 1               |
| 2            | 2               |
| 3            | 3               |
| 4            | 3               |
+--------------+-----------------+
输出：
+-----------------+
| customer_number |
+-----------------+
| 3               |
+-----------------+
解释：
customer_number = 3 的客户共有 2 个订单，多于只有 1 个订单的客户 1 和客户 2。

提示：

先「按客户分组计数」，再「取计数最大的那一组」——本质是分组 Top-1。
题目只保证「唯一」，但追问要求能处理并列第一的情况（见思路 2）。
返回结果只有一列 customer_number。

💻 解题思路

思路1：GROUP BY + ORDER BY … LIMIT 1（用户解法）

核心逻辑

第一步按 customer_number 分组，COUNT(*) 数出每人订单数；第二步按订单数降序排，LIMIT 1 取第一名。用 CTE（WITH）把这两步拆开，可读性更好。

代码实现

# Write your MySQL query statement below
WITH t1 AS (
    SELECT customer_number, COUNT(*) AS n
    FROM Orders
    GROUP BY customer_number
)
SELECT customer_number
FROM t1
ORDER BY n DESC
LIMIT 1;

也可以省掉 CTE 一步写完：SELECT customer_number FROM Orders GROUP BY customer_number ORDER BY COUNT(*) DESC LIMIT 1;

📊 性能分析

时间复杂度： $O(n \log n)$ （GROUP BY 聚合后对结果排序，排序是主导项；走主键索引可直接扫描计数）。
空间复杂度： $O(n)$ （分组结果的哈希/临时表）。

思考

LIMIT 1 的并列陷阱：如果多个客户并列最多，LIMIT 1 只返回其中一个，且返回哪一个不确定（取决于排序稳定性）。本题靠「唯一」保证兜底才安全。
评论区常见报错：聚合函数不能嵌套，MAX(COUNT(*)) 是非法的 → 要么先聚合再排序取首，要么把计数做成子查询再取 MAX。

思路2：窗口函数 DENSE_RANK（应对并列 · Follow-up）

核心逻辑

对每个客户的订单数排名，取 ranking = 1 的全部客户。并列第一时这里会全部保留，正好回答题目的追问「如果订单最多的客户有多个怎么办」。

代码实现

SELECT customer_number
FROM (
    SELECT
        customer_number,
        DENSE_RANK() OVER (ORDER BY COUNT(*) DESC) AS ranking
    FROM Orders
    GROUP BY customer_number
) AS t
WHERE ranking = 1;

📊 性能分析

时间复杂度： $O(n \log n)$ （分组 + 窗口排序）。
空间复杂度： $O(n)$ 。
与思路 1 同阶，但语义更强（天然处理并列），代价是写法更重。

思考

RANK() / DENSE_RANK() 在并列时都会给出 1；差别在后续名次（RANK 跳号、DENSE_RANK 不跳）。本题只取第一名，二者等价；若像分数排名那样需要完整名次，就必须想清楚要哪一种。
另一类等价写法用 HAVING COUNT(*) = (SELECT MAX(cnt) FROM …)，靠子查询取最大计数——可读但重复聚合一次，不如窗口函数干净。

📝 总结

「每组计数的 Top-1」模板：

只需第一名 → GROUP BY 分组列 + ORDER BY COUNT(*) DESC + LIMIT 1（可包一层 CTE 提升可读性）；
需处理并列 / 完整名次 → 子查询里 DENSE_RANK() OVER (ORDER BY COUNT(*) DESC)，外层筛 ranking = 1。

核心坑点：① 聚合函数不能嵌套（MAX(COUNT(*)) 非法）；② LIMIT 1 在并列时结果不确定，仅适合作题目的「唯一」保证。

🔗 题集索引：LeetCode题集索引 · 算法地图：学习-数据结构与算法MOC
📎 同类题：从不订购的用户 · 分数排名 · 部门工资最高的员工｜概念：SQL原理_02 · SQL原理_03

漏斗题

2026-10-02T16:00:00.000Z

漏斗题

类型：自编场景题（漏斗转化）| 题号：— | 链接：—
关联：SQL原理_04（漏斗章节）· SQL分析场景模板 · 好友申请 II ：谁有最多的好友（同为列转行+聚合）

🎯 问题描述

表结构

1	event_log(user_id, event_name, event_time)

事件名：view、cart、order、pay。

需求

统计从"浏览 → 加购 → 下单 → 支付"的漏斗人数。

要求每一步必须发生在第一步之后，即按时间顺序：

1	view_time < cart_time < order_time < pay_time

输出：view_users、cart_users、order_users、pay_users。

说明：每个用户可能多次触发同一事件，需按最早时间归并成一行再比较顺序。

💻 解题思路

思路1：MIN(CASE WHEN) 归并 + 时间递增计数（用户解法）

核心逻辑

① 子查询 person_log：按 user_id 分组，用 MIN(CASE WHEN event_name = 'xx' THEN event_time END) 把每个事件的最早时间抽成一列（列转行 → 转回列）；
② 外层按时间顺序逐级比较：走到下一步的前提是上一步时间更早，用 COUNT(CASE WHEN 条件 THEN 1 END) 数各步人数；
③ 缺 ELSE 时 CASE 返回 NULL，COUNT 只数非空，因此只统计"真的依次走到该步"的用户。

代码实现

WITH person_log AS (
    SELECT
        user_id,
        MIN(CASE WHEN event_name = 'view'  THEN event_time END) AS u_view,
        MIN(CASE WHEN event_name = 'cart'  THEN event_time END) AS u_cart,
        MIN(CASE WHEN event_name = 'order' THEN event_time END) AS u_order,
        MIN(CASE WHEN event_name = 'pay'   THEN event_time END) AS u_pay
    FROM event_log
    GROUP BY user_id
)
SELECT
    COUNT(CASE WHEN u_view IS NOT NULL THEN 1 END) AS view_users,
    COUNT(CASE WHEN u_view < u_cart THEN 1 END) AS cart_users,
    COUNT(CASE WHEN u_view < u_cart AND u_cart < u_order THEN 1 END) AS order_users,
    COUNT(CASE WHEN u_view < u_cart AND u_cart < u_order AND u_order < u_pay THEN 1 END) AS pay_users
FROM person_log;

🔧 修正说明：
原文 u_cartTHEN 缺空格，已改为 u_cart THEN。
原文第一步写 COUNT(CASE WHEN u_view THEN 1 END) —— 直接拿时间做布尔判断，遇到 '0000-00-00' 这类假值会误判；应显式写 u_view IS NOT NULL 才准确。
时间比较也可以用 DATEDIFF(u_cart, u_view) > 0，语义等价。

📊 性能分析

时间复杂度： $O(n)$ （一次分组聚合即可，无 JOIN）。
空间复杂度： $O(1)$ （相对输入）。

思考

这是严格有序漏斗：view < cart < order < pay 全部成立才算走完。若业务允许"乱序转化"（比如直接下单没加购），条件要相应放宽。
若要算转化率，再除以 view_users 即可：cart_users / view_users 等。
若同一用户同事件多天发生、且要求"同一会话内"，需要额外按会话/时间窗切分。

📝 总结

漏斗模板：MIN(CASE WHEN 事件 THEN 时间 END) 把各步压成一行 → 按时间先后逐级比较 → COUNT(CASE WHEN ... THEN 1 END) 数各步人数（无 ELSE 即天然只数"真走到"的）。与 SQL原理_04 漏斗一节完全同源。

🔗 题集索引：LeetCode题集索引 · 算法地图：学习-数据结构与算法MOC

删除有序数组中的重复项 -LeetCode

2026-07-09T16:00:00.000Z

26. 删除有序数组中的重复项

🎯 问题描述（来源于LeetCode）

描述：
给你一个 非严格递增排列 的数组 nums，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。
元素的相对顺序应该保持一致。
不要使用额外的数组空间，你必须在原地修改输入数组，并在使用 O(1) 额外空间的条件下完成。

说明：

数组已排序。
返回新长度 slow 后，不需要考虑数组中超出新长度后面的元素。

示例：

示例 1：

1
2
3

输入: nums = [1,1,2]
输出: 2, nums = [1,2,_]
解释: 函数应返回新长度 2，并且原数组的前两个元素被修改为 1, 2。

示例 2：

1 2	输入: nums = [0,0,1,1,1,2,2,3,3,4] 输出: 5, nums = [0,1,2,3,4,_,_,_,_,_]

💻 解题思路

思路：快慢指针（覆盖法）

算法步骤

如果数组长度为 0，直接返回 0。但代码中未处理空数组，不过题目保证 nums 长度至少为 1。
初始化慢指针 slow = 1，指向下一个不重复元素应该放置的位置。
遍历数组，快指针 fast 从 1 开始（0 位置默认保留）：
- 如果 nums[fast] != nums[slow-1]（即当前元素与前一个不重复元素不同），则将 nums[fast] 移到 slow 位置，然后 slow += 1。
- 否则，fast 继续前进。
返回 slow，即不重复元素的个数。

代码实现（您的代码）

from typing import List

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        slow = 1
        for fast, num in enumerate(nums):
            if fast == 0:
                continue
            if num != nums[slow - 1]:
                nums[slow], nums[fast] = nums[fast], nums[slow]
                slow += 1
        return slow

📊 性能分析

时间复杂度： $O(n)$ ，一次遍历。
空间复杂度： $O(1)$ ，原地修改。

思考

您的代码使用交换（nums[slow], nums[fast] = nums[fast], nums[slow]）来将不重复元素挪到前面，但更常见的是直接覆盖（nums[slow] = nums[fast]），因为 slow 位置的值不再需要。交换也能工作，但略显冗余。
关键点：slow 始终指向下一个要写入的位置，而 slow-1 是最后一个已确认的不重复元素。当遇到新元素时，将其放入 slow 并递增 slow。最终返回 slow 即为长度。
此解法是去重问题的标准双指针实现，简洁高效。

找出数组中的所有 K 近邻下标 -LeetCode

2026-07-09T16:00:00.000Z

2200. 找出数组中的所有 K 近邻下标

🎯 问题描述（来源于LeetCode）

描述：
给你一个下标从 0 开始的整数数组 nums 和两个整数 key 和 k。
K 近邻下标 定义为 nums 中某个下标 i，满足至少存在一个下标 j 使得 |i - j| <= k 且 nums[j] == key。
以列表形式返回所有 K 近邻下标，按 递增顺序 排序。

说明：

一个下标可能对应多个 key 位置，但只计入一次。

示例：

示例 1：

1
2
3

输入: nums = [3,4,9,1,3,3], key = 3, k = 2
输出: [0,1,2,3,4,5]
解释: key 出现在下标 0、4、5，扩展区间 [0,2]、[2,6]、[3,7]，覆盖 [0,5]。

示例 2：

1
2
3

输入: nums = [1,2,3,4,5], key = 2, k = 1
输出: [0,1,2]
解释: key 在索引 1，区间 [0,2]，因此 0、1、2 都是近邻。

💻 解题思路

思路：快慢指针扫描（一次遍历，线性时间）

快指针 fast：遍历数组，寻找值为 key 的位置。
慢指针 slow：始终指向下一个尚未被检查的下标，初始为 0。
当 fast 指向 key 时，从 slow 和 fast - k 的较大值开始，依次检查所有满足 |slow - fast| <= k 的下标，并将它们加入结果列表，同时 slow 递增。
由于 slow 永不回退，且只向前移动，每个下标最多被访问一次，保证了线性时间复杂度。

算法步骤

初始化 slow = 0，结果列表 ans = []，数组长度 l。
遍历 fast 从 0 到 l-1：
- 若 nums[fast] == key：
  - 将 slow 更新为 max(slow, fast - k)，确保不会遗漏之前未扫描的下标。
  - 当 slow <= fast + k 且 slow < l 时：
    - 由于已经保证 slow >= fast - k，此时一定有 abs(slow - fast) <= k，直接将 slow 加入 ans。
    - slow += 1。
- 继续下一个 fast。
返回 ans（已自动升序且无重复）。

代码实现（您的优化代码）

from typing import List

class Solution:
    def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
        slow = 0
        ans = []
        l = len(nums)
        for fast, num in enumerate(nums):
            slow = max(slow, fast - k)
            while num == key and slow <= fast + k and slow < l:
                ans.append(slow)
                slow += 1
        return ans

📊 性能分析

时间复杂度： $O(n)$ ，每个下标最多被 slow 访问一次，外层循环 $O(n)$ 。
空间复杂度： $O(n)$ ，用于存储结果列表。

思考

相比最初的版本，你通过维护 slow 指针不重置，并利用 max(slow, fast - k) 跳过已经处理过的下标，将算法从可能的 $O(n^2)$ 优化为严格的 $O(n)$ 。同时，由于 slow 递增，结果自动保持升序，无需额外排序或去重。这是本题非常优雅的线性解法。

关键点：

只有当 nums[fast] == key 时才触发添加，但 slow 的推进不受 key 位置影响，确保覆盖所有可能的下标。
由于 slow 始终指向下一个可能合法的下标，每个下标只被考虑一次，不会重复。

有效三角形的个数-LeetCode

2026-07-09T16:00:00.000Z

611. 有效三角形的个数

🎯 问题描述（来源于LeetCode）

描述：
给定一个包含非负整数的数组 nums，返回其中可以组成三角形三条边的三元组个数。
三角形的条件是：任意两边之和大于第三边，等价于较短两边之和大于最长边。

说明：

三元组 (i, j, k) 满足 i < j < k，且 nums[i] + nums[j] > nums[k]。
数组长度 1 <= n <= 1000。

示例：

示例 1：

1
2
3

输入: nums = [2,2,3,4]
输出: 3
解释: 有效组合: (2,2,3), (2,3,4), (2,3,4) 共 3 个。

示例 2：

1 2	输入: nums = [4,2,3,4] 输出: 4

💻 解题思路

思路：排序 + 双指针（固定最短边，滑动中边）

算法步骤

将数组 nums 升序排序。
外层循环 slow 从 0 到 n-3，固定最短边 num = nums[slow]。
如果 num == 0，由于三角形边长必须为正数，直接跳过。
初始化 mid = slow + 1，指向可能的次短边（中边）的起始位置。
内层循环 fast 从 slow+2 到 n-1，枚举最长边 c = nums[fast]：
- 当 nums[fast] - nums[mid] >= num 时，说明 num + nums[mid] <= nums[fast]，不满足三角形条件（两边之和不大于第三边）。此时将 mid 右移，直到满足 num + nums[mid] > nums[fast]。
- 此时，所有下标从 mid 到 fast-1 的元素都可以作为中边 b，与当前的 num 和 nums[fast] 组成三角形。
  可行数量为 fast - mid，累加到答案 ans。
返回 ans。

代码实现（您的代码）

from typing import List

class Solution:
    def triangleNumber(self, nums: List[int]) -> int:
        nums.sort()
        n = len(nums)
        ans = 0
        for slow in range(n - 2):
            num = nums[slow]
            if num == 0:  
                continue
            mid = slow + 1
            for fast in range(slow + 2, n):
                while nums[fast] - nums[mid] >= num:
                    mid += 1
                ans += fast - mid
        return ans

📊 性能分析

时间复杂度： $O(n^2)$ 。外层循环 $O(n)$ ，内层循环中 fast 和 mid 均单调递增，每个指针最多移动 $O(n)$ 次，总体 $O(n^2)$ 。
空间复杂度： $O(1)$ （忽略排序占用的栈空间）。

思考

您的命名 slow, mid, fast 非常形象：

slow 是最短边，固定不变；
fast 是最长边，不断右移；
mid 是中边，随着 fast 增大和 num 固定，为了满足 num + nums[mid] > nums[fast]，mid 只能向右移动，绝不回头。

利用排序后的单调性，mid 的单向移动保证了内层循环的摊还复杂度为 $O(n)$ ，整体达到 $O(n^2)$ ，这是本题的标准最优解法。跳过 0 的处理也避免了对无效边长进行多余计算，代码逻辑清晰且高效。

删除字符串两端相同字符后的最短长度-LeetCode

2026-07-08T16:00:00.000Z

1750. 删除字符串两端相同字符后的最短长度

🎯 问题描述（来源于LeetCode）

描述：
给你一个只包含字符 'a'、'b' 和 'c' 的字符串 s，你可以执行以下操作任意次：

选择字符串的一个非空前缀和一个非空后缀，要求前缀和后缀的所有字符都相同，且前缀和后缀的字符相同（即 s[0] == s[-1]）。然后删除前缀和后缀，剩余部分拼接成新字符串。
求在执行任意次操作后，字符串可能的最短长度。

说明：

每次操作必须同时删除前缀和后缀，且前缀和后缀的字符必须相同。
如果两端字符不同，则无法继续操作，返回当前长度。

示例：

示例 1：

1
2
3

输入: s = "ca"
输出: 2
解释: 两端字符 'c' 和 'a' 不同，无法删除，长度为 2。

示例 2：

输入: s = "cabaabac"
输出: 0
解释: 
  初始: "cabaabac" 两端都为 'c'，删除所有 'c' 得到 "abaaba"。
  现在两端为 'a' 和 'a'，删除所有 'a' 得到 "b"。
  但注意：删除前缀和后缀时要求它们连续相同，实际上 "abaaba" 两端为 'a'，删除所有连续 'a' 后，中间 "b" 长度为1，但最后两端 'b' 不同，结果应为1？实际上标准答案是0？需要核对。根据LeetCode示例，输入 "cabaabac" 输出 0，因为删除两端相同字符块后最终为空。

示例 3：

1 2	输入: s = "aabccabba" 输出: 3

💻 解题思路

思路：双指针删除相同字符块

算法步骤

初始化左指针 left = 0，右指针 right = len(s) - 1。
当 left < right 且 s[left] == s[right] 时：
- 记录当前字符 ch = s[left]。
- 从左边删除所有与 ch 相同的连续字符：while left <= right and s[left] == ch: left += 1。
- 从右边删除所有与 ch 相同的连续字符：while left <= right and s[right] == ch: right -= 1。
循环结束后，若 left > right，说明全部删除，返回 0；否则返回 right - left + 1。

代码实现（您的代码）

class Solution:
    def minimumLength(self, s: str) -> int:
        left, right = 0, len(s) - 1
        while left < right and s[left] == s[right]:
            ch = s[left]
            while left <= right and s[left] == ch:
                left += 1
            while left <= right and s[right] == ch:
                right -= 1
        return right - left + 1 if left <= right else 0

📊 性能分析

时间复杂度： $O(n)$ ，每个字符最多被访问一次。
空间复杂度： $O(1)$ ，仅使用常数个变量。

思考

您的代码正确实现了题意：每次从两端删除所有与当前相同字符的连续块，并继续检查新的两端。注意内层两个 while 循环分别删除左右两侧的相同字符块，确保删除的是前缀和后缀中所有连续的该字符。最终若指针交错则返回 0，否则返回剩余长度。该解法是本题的标准双指针解法，高效且简洁。

反转一个字符串里的字母后反转特殊字符-LeetCode

2026-07-08T16:00:00.000Z

3823. 反转一个字符串里的字母后反转特殊字符

🎯 问题描述（来源于LeetCode）

描述：
给定一个字符串 s，该字符串只包含小写字母和特殊字符 "!@#$%^&*()"。
请先反转字符串中所有字母的顺序（但保持字母在原字母位置），再反转所有特殊字符的顺序（保持特殊字符在原来特殊字符位置），然后返回结果字符串。

说明：

字母和特殊字符互不干扰，各自反转。
反转是指将同类字符的顺序倒置。

示例：

示例 1：

输入: s = ")ebc#da@f("
输出: "(fad@cb#e)"
解释: 
  1. 提取字母 "ebc daf"？实际上字母按顺序为 e,b,c,d,a,f → 反转后 f,a,d,c,b,e。
  2. 特殊字符顺序为 ),#,@,( → 反转后 (, @, #, )。
  3. 填充后得到 "(fad@cb#e)"。

示例 2：

1 2	输入: s = "z" 输出: "z"

示例 3：

1 2	输入: s = "!@#$%^&()" 输出: ")(&^%$#@!"

💻 解题思路

思路：双指针分两轮反转（通用方法）

算法步骤

将字符串转为列表 t，便于原地修改。
定义通用函数 reverse(t, f)，其中 f 是一个判断函数，用于保护某些字符不参与交换：
- 设置左右指针 i=0，j=len(t)-1。
- 当 i < j 时：
  - 左指针跳过满足 f 的字符（即保护该类字符）。
  - 右指针跳过满足 f 的字符。
  - 交换左右指针所指的字符（这两个字符都不满足 f，即属于另一类）。
  - 移动指针。
- 该函数的效果是：将所有不满足 f 的字符进行反转，而满足 f 的字符保持位置不变。
第一轮：调用 reverse(t, str.islower)，保护小写字母，反转特殊字符。
第二轮：调用 reverse(t, lambda ch: not ch.islower())，保护特殊字符，反转小写字母。
返回列表转字符串。

代码实现（您的代码）

from typing import List, Callable

class Solution:
    def reverse(self, t: List[str], f: Callable[[str], bool]) -> None:
        i, j = 0, len(t) - 1
        while i < j:
            while i < j and f(t[i]):
                i += 1
            while i < j and f(t[j]):
                j -= 1
            t[i], t[j] = t[j], t[i]
            i += 1
            j -= 1

    def reverseByType(self, s: str) -> str:
        t = list(s)
        self.reverse(t, str.islower)          # 反转非小写（即特殊字符）
        self.reverse(t, lambda ch: not ch.islower())  # 反转小写字母
        return ''.join(t)

📊 性能分析

时间复杂度： $O(n)$ ，两次遍历，每次 $O(n)$ 。
空间复杂度： $O(n)$ ，列表存储字符串。

思考

您的解法通过两轮反转，巧妙地实现了分别反转两类字符的需求。在第一轮中，保护小写字母（str.islower 返回 True），于是所有非小写字符（特殊字符）被反转；第二轮保护非小写字符（not ch.islower() 返回 True），于是小写字母被反转。这种“保护-反转”模式通用且高效，避免了显式提取和填充。虽然相较于提取反转再填回的方法，它的理解成本稍高，但代码简洁，且原地操作节省了额外列表。对于本题，两种方法均可，您的实现展现了双指针的灵活运用。

字典序最小回文串-LeetCode

2026-07-08T16:00:00.000Z

2697. 字典序最小回文串

🎯 问题描述（来源于LeetCode）

描述：
给定一个由小写英文字母组成的字符串 s，你每次操作可以将任意一个字符修改为任意一个小写字母。
请你返回将 s 变成回文串所需的最少操作次数？不，本题要求构造一个字典序最小的回文串，即通过修改某些字符（不限制操作次数），使得最终字符串是回文串，且字典序最小。

说明：

字典序比较：按从左到右的顺序比较字符。
回文串：正读反读相同。
可以修改任意位置的字符为任意小写字母。

示例：

示例 1：

1
2
3

输入: s = "egcfe"
输出: "efcfe"
解释: 将 'g' 改为 'f'，得到 "efcfe" 是回文串，且字典序最小。

示例 2：

1
2
3

输入: s = "abcd"
输出: "abba"
解释: 将 'c' 改为 'b'，'d' 改为 'a'，得到 "abba" 是回文串，且字典序最小。

💻 解题思路

思路：双指针 + 贪心修改

算法步骤

将字符串转为列表 st，便于原地修改。
设置左指针 left = 0，右指针 right = len(s) - 1。
当 left < right 时：
- 如果 st[left] != st[right]，则取两者中较小的字符 ch = min(st[left], st[right])，将两端都改为 ch（因为字典序要最小，应尽可能让左边的字符小）。
- 移动指针：left += 1，right -= 1。
返回列表转字符串。

代码实现（您的代码）

class Solution:
    def makeSmallestPalindrome(self, s: str) -> str:
        left, right = 0, len(s) - 1
        st = list(s)
        while left < right:
            while st[left] != st[right]:
                ch = min(st[left], st[right])
                st[left] = ch
                st[right] = ch
            left += 1
            right -= 1
        return "".join(st)

📊 性能分析

时间复杂度： $O(n)$ ，每个字符访问一次。
空间复杂度： $O(n)$ ，列表存储字符串（可原地修改）。

思考

您的代码使用内层 while 循环来确保两端字符相等，实际上由于每次只会修改一次，内层循环最多执行一次，可以简化为 if 判断。但当前写法逻辑正确且能通过。
关键点：将两端都改为较小的字符，使得字典序最小。例如 'e' 和 'g' 改为 'e'，因为左边字符越小字典序越小。
该解法是本题的标准贪心策略，简洁高效。

给植物浇水 II-LeetCode

2026-07-08T16:00:00.000Z

2105. 给植物浇水 II

🎯 问题描述（来源于LeetCode）

描述：
Alice 和 Bob 计划给一排植物浇水。植物排成一行，从左到右编号为 0 到 n-1。
Alice 从最左边（植物 0）开始，Bob 从最右边（植物 n-1）开始，他们同时向中间移动。

Alice 的水壶容量为 capacityA，Bob 的水壶容量为 capacityB。
当他们到达一株植物时，如果水壶中的水不足以浇灌该植物，他们必须重新装满自己的水壶（在当前位置），然后才能浇水。
他们各自独立行动，但每次只能浇一株植物。
如果两人同时到达同一株植物（即中间只剩一株植物），则水壶中剩余水量较多的人去浇灌（如果两人水量相同，Alice 去浇）。

求他们总共需要重新装满水壶的次数。

说明：

初始水壶是满的（容量分别为 capacityA 和 capacityB）。
植物需要的水量由 plants[i] 给出。

示例：

示例 1：

输入: plants = [2,2,3,3], capacityA = 5, capacityB = 5
输出: 1
解释:
  Alice 浇 0 号 (2)，剩 3；Bob 浇 3 号 (3)，剩 2。
  Alice 浇 1 号 (2)，剩 1；Bob 浇 2 号 (3)，水量不够，Bob 重新装满（+1），然后浇 2 号。
  总共 1 次。

示例 2：

输入: plants = [2,2,3,3], capacityA = 3, capacityB = 4
输出: 2
解释:
  Alice 浇 0 号 (2)，剩 1；Bob 浇 3 号 (3)，剩 1。
  Alice 浇 1 号 (2)，水不够，重新装满（+1），剩 3？实际需先装满再浇，所以重新装满后浇 1 号，剩 1。
  Bob 浇 2 号 (3)，水不够，重新装满（+1），然后浇 2 号。
  总共 2 次。

💻 解题思路

思路：双指针模拟

算法步骤

初始化左右指针 left = 0，right = len(plants) - 1，Alice 当前水量 a = capacityA，Bob 当前水量 b = capacityB，答案 ans = 0。
当 left < right 时：
- Alice 浇水：
  - 如果 a < plants[left]，则需要重新装满（a = capacityA，ans += 1）。
  - 浇水：a -= plants[left]，left += 1。
- Bob 浇水：
  - 如果 b < plants[right]，则需要重新装满（b = capacityB，ans += 1）。
  - 浇水：b -= plants[right]，right -= 1。
如果 left == right（中间只剩一株植物），则由水量较多的人浇灌：
- 如果 max(a, b) < plants[left]，则其中一人需要重新装满（ans += 1）。
- 不需要实际修改水量，因为已经完成所有浇水。
返回 ans。

代码实现（您的代码）

from typing import List

class Solution:
    def minimumRefill(self, plants: List[int], capacityA: int, capacityB: int) -> int:
        left, right = 0, len(plants) - 1
        a, b = capacityA, capacityB
        ans = 0
        while left < right:
            if a < plants[left]:
                a = capacityA
                ans += 1
            a -= plants[left]
            left += 1
            
            if b < plants[right]:
                b = capacityB
                ans += 1
            b -= plants[right]
            right -= 1
        
        if left == right:
            if max(a, b) < plants[left]:
                ans += 1
        return ans

📊 性能分析

时间复杂度： $O(n)$ ，每个植物访问一次。
空间复杂度： $O(1)$ ，仅使用常数个变量。

思考

您的代码正确模拟了两人同时从两端浇水的过程。关键点：

每次浇水前检查当前水量是否足够，若不足则重新装满并计数。
对于最后一株植物，由水量较多者负责，只需判断较大水量是否足够，若不够则只需加一次（因为只需一个人去浇）。
该解法是本题的标准双指针模拟，逻辑清晰，运行高效。

反转单词前缀-LeetCode

2026-07-06T16:00:00.000Z

2000. 反转单词前缀

🎯 问题描述（来源于LeetCode）

描述：
给定一个字符串 word 和一个字符 ch，找出 ch 在 word 中第一次出现的位置（下标从 0 开始）。反转从位置 0 到该位置（含）的所有字符，并返回反转后的字符串。如果 ch 不存在于 word 中，则返回原字符串。

说明：

只需要反转前缀，不修改后缀。

示例：

示例 1：

1
2
3

输入: word = "abcdefd", ch = "d"
输出: "dcbaefd"
解释: "d" 第一次出现在下标 3，反转前 4 个字符 "abcd" → "dcba"。

示例 2：

1
2
3

输入: word = "xyxzxe", ch = "z"
输出: "zxyxxe"
解释: "z" 第一次出现在下标 2，反转前 3 个字符 "xyz" → "zyx"。

💻 解题思路

思路：双指针原地反转

算法步骤

使用 while 循环查找字符 ch 第一次出现的下标 i。若未找到（i == len(word)），直接返回原字符串。
将字符串转为列表 ans，便于原地修改。
设置左指针 left = 0，右指针 right = i。
交换 ans[left] 和 ans[right]，然后 left++，right--，直到 left >= right。
将列表转换回字符串并返回。

代码实现（您的代码）

class Solution:
    def reversePrefix(self, word: str, ch: str) -> str:
        i = 0
        l = len(word)
        while i < l:
            if word[i] == ch:
                break
            i += 1
        if i == l:
            return word
        left = 0
        right = i
        ans = list(word)
        while left < right:
            ans[left], ans[right] = ans[right], ans[left]
            left += 1
            right -= 1
        return "".join(ans)

📊 性能分析

时间复杂度： $O(n)$ ，其中 $n$ 是字符串长度，查找和反转各需线性时间。
空间复杂度： $O(n)$ ，列表占用 $n$ 字符空间（但原地交换，比切片节省临时字符串）。

思考

您的代码使用双指针进行原地反转，避免了切片产生的额外字符串副本（虽然列表也有开销，但通常更高效）。查找过程手动实现，逻辑清晰。如果使用 Python 内置方法 find 和切片可进一步简化，但您的实现更具通用性，且易于理解。边界情况（未找到字符）处理正确，直接返回原字符串。

反转字符串前缀 -LeetCode

2026-07-06T16:00:00.000Z

3794. 反转字符串前缀 - Reverse String Prefix

🎯 问题描述（来源于LeetCode）

描述：
给定一个字符串 s 和一个整数 k，将字符串的前 k 个字符进行反转。其余字符保持原来的顺序。返回反转后的字符串。

说明：

1 <= s.length <= 100
0 <= k <= s.length（根据常见实现推断，可自行验证）

示例：

示例 1：

1
2
3

输入: s = "abcd", k = 2
输出: "bacd"
解释: 前 2 个字符 "ab" 反转为 "ba"，得到 "bacd"。

示例 2：

1
2
3

输入: s = "xyz", k = 3
输出: "zyx"
解释: 前 3 个字符即整个字符串反转。

💻 解题思路

思路：字符串切片拼接

算法步骤

将字符串 s 分成两部分：前缀 pre = s[:k]（前 k 个字符）和后缀 suf = s[k:]（剩余字符）。
反转前缀：pre[::-1]。
将反转后的前缀与后缀拼接并返回。

代码实现

class Solution:
    def reversePrefix(self, s: str, k: int) -> str:
        pre = s[:k]
        suf = s[k:]
        return pre[::-1] + suf

📊 性能分析

时间复杂度： $O(n)$ ，其中 $n$ 是字符串长度。
空间复杂度： $O(n)$ ，切片创建新字符串。

思考

你的代码简洁高效，但如果能注意变量命名的可读性（如将 od 改为 suf 表示后缀），代码会更清晰。
边界情况：由于 Python 切片特性，当 k = 0 时，s[:0] 为空字符串，s[0:] 为原字符串，结果正确；当 k >= len(s) 时，s[:k] 返回整个字符串，s[k:] 为空，结果也正确。无需额外判断。

垂直翻转子矩阵-LeetCode

2026-07-06T16:00:00.000Z

3643. 垂直翻转子矩阵

🎯 问题描述（来源于LeetCode）

描述：
给你一个 m x n 的整数矩阵 grid，以及三个整数 x、y 和 k。
x 和 y 表示一个 正方形子矩阵 的左上角下标，k 表示该正方形子矩阵的边长。
你的任务是垂直翻转该子矩阵的行顺序（即上下翻转），并返回更新后的矩阵。

说明：

垂直翻转：子矩阵的第一行与最后一行交换，第二行与倒数第二行交换，以此类推。
子矩阵外的元素保持不变。
你可以直接在原矩阵上修改，也可以使用额外空间。

示例：

示例 1：

1
2
3

输入: grid = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]], x = 1, y = 0, k = 3
输出: [[1,2,3,4],[13,14,15,8],[9,10,11,12],[5,6,7,16]]
解释: 目标子矩阵为行 1-3、列 0-2。翻转前行顺序为：[5,6,7]、[9,10,11]、[13,14,15]；翻转后行顺序变为：[13,14,15]、[9,10,11]、[5,6,7]，列3保持不变。

示例 2：

1
2
3

输入: grid = [[3,4,2,3],[2,3,4,2]], x = 0, y = 2, k = 2
输出: [[3,4,4,2],[2,3,2,3]]
解释: 目标子矩阵为行 0-1、列 2-3。翻转前为 [[2,3],[4,2]]，翻转后变为 [[4,2],[2,3]]。

💻 解题思路

思路：双指针逐行交换（原地修改）

算法步骤

确定子矩阵边界：
- 顶部行：top = x
- 底部行：bottom = x + k - 1
双指针交换行：
- 当 top < bottom 时，进行循环：
  - 遍历子矩阵的每一列 j，范围从 y 到 y + k - 1。
  - 交换 grid[top][j] 和 grid[bottom][j] 的值。
  - 交换完成后，top 向下移动一行（top++），bottom 向上移动一行（bottom--）。
返回结果：原地修改矩阵后，直接返回 grid。

代码实现（你的代码）

from typing import List

class Solution:
    def reverseSubmatrix(self, grid: List[List[int]], x: int, y: int, k: int) -> List[List[int]]:
        # 初始化上下两个行指针
        l, r = x, x + k - 1
        while l < r:
            # 交换当前两行在子矩阵范围内的所有元素
            for j in range(y, y + k):
                grid[l][j], grid[r][j] = grid[r][j], grid[l][j]
            # 指针向中间移动
            l += 1
            r -= 1
        return grid

📊 性能分析

时间复杂度： $O(k^2)$ ，因为需要遍历子矩阵中一半的行（ $k/2$ 行），每行有 $k$ 个元素需要交换。
空间复杂度： $O(1)$ ，仅使用了有限的几个指针变量，在原矩阵上直接进行修改。

思考

你的解法非常经典，直接利用了双指针（或称为对撞指针）的思想。它通过同时从子矩阵的顶部和底部向中间遍历，并交换对应行的所有元素，高效地完成了垂直翻转。

优点：

原地修改：没有使用额外的矩阵空间，内存效率高。
逻辑清晰：代码直观地反映了“上下交换行”这一操作本质。

翻转图像-LeetCode

2026-07-06T16:00:00.000Z

832. 翻转图像

🎯 问题描述（来源于LeetCode）

描述：
给定一个二进制矩阵 image，先水平翻转每一行（即反转每一行的顺序），然后反转每个像素（0 变为 1，1 变为 0）。返回结果图像。

说明：

水平翻转：例如 [1,1,0] 变为 [0,1,1]。
反转像素：0 → 1，1 → 0。

示例：

示例 1：

1
2
3

输入: image = [[1,1,0],[1,0,1],[0,0,0]]
输出: [[1,0,0],[0,1,0],[1,1,1]]
解释: 先水平翻转每行得到 [[0,1,1],[1,0,1],[0,0,0]]，再反转像素得到结果。

示例 2：

1 2	输入: image = [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]] 输出: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]

💻 解题思路

思路一：分两步（水平翻转 + 反转像素）

算法步骤

遍历每一行 i，将该行水平翻转：image[i] = image[i][::-1]。
再次遍历每一行和每个元素，将 0 变为 1，1 变为 0（或使用 1 - x）。
返回修改后的 image。

思路一：代码实现

from typing import List

class Solution:
    def flipAndInvertImage(self, image: List[List[int]]) -> List[List[int]]:
        m, n = len(image), len(image[0])
        for i in range(m):
            image[i] = image[i][::-1]
        for i, row in enumerate(image):
            for j, x in enumerate(row):
                image[i][j] = 1 if x == 0 else 0
        return image

思路二：合并一步（双指针同时交换并反转）

算法步骤

遍历每一行，使用双指针 l（左）和 r（右）指向行首和行尾。
循环条件 l <= r（当 l == r 时，只需处理中间元素的反转）：
- 交换并反转：row[l], row[r] = 1 - row[r], 1 - row[l]。
  这一步同时完成了水平翻转（交换左右元素）和像素反转（1 - x）。
- 然后 l += 1，r -= 1。
处理完所有行后返回 image。

思路二：代码实现（用户提供）

class Solution:
    def flipAndInvertImage(self, image: List[List[int]]) -> List[List[int]]:
        for row in image:
            l, r = 0, len(row) - 1
            while l <= r:
                row[l], row[r] = 1 - row[r], 1 - row[l]
                l += 1
                r -= 1
        return image

📊 性能分析

时间复杂度：两种思路均为 $O(m \times n)$ ，每个元素访问常数次。
空间复杂度：
- 思路一：每行切片产生新列表，额外 $O(n)$ 空间（但只在单行内，整体为 $O(m \times n)$ 的临时空间）。
- 思路二：原地双指针交换，额外空间 $O(1)$ ，更优。

思考

思路一代码直观，易于理解，但使用了切片创建了新行，空间稍大。思路二将水平翻转和像素反转合并到一次遍历中，使用双指针同时完成交换和取反，不仅减少了遍历次数，还节省了空间，是本题的最优解。两种方法均可通过，推荐在实际编码中使用思路二，因为它更高效。

包含所有三种字符的子字符串数目-LeetCode

2026-07-05T16:00:00.000Z

1358. 包含所有三种字符的子字符串数目

🎯 问题描述（来源于LeetCode）

描述：
给定一个由字符 'a'、'b'、'c' 组成的字符串 s。请返回包含至少一个 'a'、一个 'b' 和一个 'c' 的子字符串数量。

说明：

子字符串是连续的。
s 的长度在 [3, 5×10^4] 之间。

示例：

示例 1：

1
2
3

输入: s = "abcabc"
输出: 10
解释: 包含 a,b,c 的子串共有 10 个。

示例 2：

1 2	输入: s = "aaacb" 输出: 3

💻 解题思路

思路：滑动窗口（双指针）

算法步骤

将字符串转为字符列表（或直接迭代字符串）。
初始化左指针 left = 0，计数器 count = {'a':0, 'b':0, 'c':0}，答案 ans = 0。
遍历右指针 right，将当前字符 s[right] 加入计数。
当窗口中同时包含至少一个 'a'、'b'、'c' 时，说明以当前左指针为起点、右指针为终点以及更右的终点，所有子串都满足条件。此时，left 表示最小的合法左端点，因此以 left 及更小的左端点（即 0 到 left-1）作为起点的子串也都满足条件，数量为 left + 1（即 left 本身？代码中 ans += left 实际上累加了 left 的值，但通常应为 left + 1。需要确认代码正确性：标准做法是 ans += left + 1。但用户代码写的是 ans += left。我们需在思考中解释。）
然后移动左指针，尝试收缩窗口，并更新计数，直到窗口不再满足条件。
返回 ans。

代码实现（您的代码）

class Solution:
    def numberOfSubstrings(self, s: str) -> int:
        st = [c for c in s]
        left = 0
        ans = 0
        count = {"a": 0, "b": 0, "c": 0}
        for right, ch in enumerate(st):
            count[ch] += 1
            while count["a"] * count["b"] * count["c"] != 0:
                ch = st[left]
                count[ch] -= 1
                left += 1
            ans += left
        return ans

📊 性能分析

时间复杂度： $O(n)$ ，每个元素最多被左右指针各访问一次。
空间复杂度： $O(1)$ ，使用固定大小的字典。

思考

该解法利用滑动窗口统计所有满足条件的子串。当窗口内包含 a、b、c 至少各一个时，若左指针为 left，则以当前右端点 right 为结尾的子串中，左端点可以是 0 到 left-1 中的任意一个（因为这些子串也必然包含全部三种字符，因为它们包含当前窗口的左半部分），共 left 个。因此将 left 累加到答案中，而不是 left+1，是因为左端点取 0 到 left-1 共 left 种。这正是代码 ans += left 的原因。在每次满足条件并收缩后，left 已经是第一个使得窗口不满足条件的左端点，所以以 right 为结尾的合法子串数为 left。
注意：若左指针从 0 开始，当第一次满足条件时，left 可能为 1（因为收缩一次），此时 ans += 1，代表以 right 为结尾且左端点为 0 的子串合法，数量为 1，正确。该算法是此题的高效解法，代码简洁，但在理解上需要留意累加逻辑。

和相同的二元子数组-LeetCode

2026-07-05T16:00:00.000Z

930. 和相同的二元子数组

🎯 问题描述（来源于LeetCode）

描述：
给定一个二元数组 nums（只包含 0 和 1）和一个整数 goal，统计并返回具有和 goal 的非空连续子数组的个数。

说明：

子数组是连续的。
1 <= nums.length <= 3 * 10^4。

示例：

示例 1：

1
2
3

输入: nums = [1,0,1,0,1], goal = 2
输出: 4
解释: 有 4 个子数组满足和等于 2。

示例 2：

1 2	输入: nums = [0,0,0,0,0], goal = 0 输出: 15

💻 解题思路

思路：滑动窗口 + 容斥原理（基于您的代码）

算法步骤

定义辅助函数 getNums(k)，该函数返回数组中和大于等于 k 的连续子数组个数。
在 getNums(k) 中：
- 初始化左指针 left = 0，当前窗口和 pre = 0，答案 ans = 0。
- 遍历右指针 right，将 nums[right] 加入 pre。
- 当 pre >= k 时，不断移动左指针（并将移出的元素从 pre 中减去），直到 pre < k。
- 此时，对于当前右端点 right，所有左端点小于 left 的子数组（即从 0 到 left-1 开始的子数组）的和都满足 >= k。因此，共有 left 个以当前 right 为结尾的合法子数组，将 left 累加到 ans。
利用容斥原理：sum == goal 的数量 = sum >= goal 的数量 - sum >= goal+1 的数量。因此返回 getNums(goal) - getNums(goal+1)。

代码实现（您的代码）

from typing import List

class Solution:
    def numSubarraysWithSum(self, nums: List[int], goal: int) -> int:
        def getNums(k: int) -> int:
            ans = 0
            left = 0
            pre = 0
            for right, num in enumerate(nums):
                pre += num
                while left <= right and pre >= k:
                    pre -= nums[left]
                    left += 1
                ans += left 
            return ans
        
        return getNums(goal) - getNums(goal + 1)

📊 性能分析

时间复杂度： $O(n)$ ，每个元素最多被左右指针各访问一次（两次遍历，常数倍）。
空间复杂度： $O(1)$ ，仅使用常数个变量。

思考

解法非常精妙！

传统的滑动窗口通常直接统计“和小于 k”或“和不超过 k”的子数组个数。而您的 getNums 反其道而行之，通过 while pre >= k 收缩窗口，巧妙地统计了“和大于等于 k”的子数组个数。
关键在于 ans += left：当窗口和小于 k 时，left 之前的每一个位置作为起点，与当前 right 组成的子数组，其和都必然大于等于 k。这正是因为包含这些起点会使得窗口扩大，从而恢复 >= k 的状态。
这种写法避开了处理 0 元素带来的复杂边界条件，是本题的一种优雅且高效的解法。

统计「优美子数组」-LeetCode

2026-07-05T16:00:00.000Z

1248. 统计「优美子数组」

🎯 问题描述（来源于LeetCode）

描述：
给定一个整数数组 nums 和一个整数 k。如果一个连续子数组中恰好有 k 个奇数数字，我们就称这个子数组为「优美子数组」。
请返回这个数组中「优美子数组」的数目。

说明：

子数组是连续的。
1 <= nums.length <= 5 * 10^4。

示例：

示例 1：

1
2
3

输入: nums = [1,1,2,1,1], k = 3
输出: 2
解释: 包含 3 个奇数的子数组有 [1,1,2,1] 和 [1,2,1,1]。

示例 2：

1 2	输入: nums = [2,4,6], k = 1 输出: 0

💻 解题思路

思路：滑动窗口 + 容斥原理（基于您的代码）

算法步骤

将原数组 nums 转换为 0/1 数组：偶数 → 0，奇数 → 1。
定义辅助函数 atLeast(x)，返回原数组中奇数个数至少为 x 的连续子数组的个数。
- 在 atLeast(x) 中：
  - 使用滑动窗口维护当前窗口内奇数的个数（即 pre）。
  - 遍历右端点 right，将 nums[right] 加入 pre。
  - 当 pre >= x 时，不断移动左指针 left（并减去移出的元素），直到 pre < x。
  - 此时，对于当前右端点，所有左端点小于 left 的子数组（即起点 0 到 left-1）都满足奇数个数至少为 x，共有 left 个，累加到答案 ans。
利用容斥：恰好为 k 个奇数的子数组数 = atLeast(k) - atLeast(k+1)。
返回结果。

代码实现（您的代码）

from typing import List

class Solution:
    def numberOfSubarrays(self, nums: List[int], k: int) -> int:
        # 将原数组转为 0/1：奇数=1，偶数=0
        def isNum(num):
            return 1 if num % 2 == 1 else 0
        for i, num in enumerate(nums):
            nums[i] = isNum(num)
        
        # 统计奇数个数 >= x 的子数组个数
        def atLeast(x: int) -> int:
            ans = 0
            left = 0
            pre = 0
            for right, num in enumerate(nums):
                pre += num
                while left <= right and pre >= x:
                    pre -= nums[left]
                    left += 1
                ans += left
            return ans
        
        return atLeast(k) - atLeast(k + 1)

📊 性能分析

时间复杂度： $O(n)$ ，三次遍历（一次转换 + 两次 atLeast），但每次遍历都是线性的，总体仍为 O(n)。
空间复杂度： $O(1)$ ，仅使用常数个变量（原地修改数组，不算额外空间）。

思考

您的解法非常巧妙，将「恰好 k 个奇数」转化为「至少 k 个」与「至少 k+1 个」的差，完美复用了 LeetCode 930 题的滑动窗口模板。
关键点在于 ans += left：当窗口内奇数个数下降到小于 x 时，left 是第一个使得窗口不满足条件的左边界，因此所有比 left 小的左端点（即 0 到 left-1）与当前右端点构成的子数组都至少包含 x 个奇数。
这种写法简洁高效，无需处理双指针的复杂边界，是本题的经典解法之一。