在ChatModel实现类里打断点调试Spring AI的工具调用，你会碰到一件怪事：日志里明明看到模型被连续吐了好几次tool_call，可断点只跳进来一次。是断点打错了地方吗？不是。循环压根不在ChatModel里，这是Spring AI 2.0相对1.x最容易让老用户懵的一处架构变化。
这篇文章想说清楚三件事：Spring AI的调用链到底长什么样；工具调用的循环具体藏在哪一层、怎么实现的；这套机制是不是标准的ReAct，Reason、Act、Observation三段一样不少，而不只是长得像。全文过了一遍Spring AI 2.0.0的源码，结论都能对着代码验证，但正文只提类名，不贴文件路径和行号，方便阅读。
一张图看全貌
Spring AI的调用链看着乱，是因为它把三件事叠在了一起：责任链（Advisor Chain）、四层嵌套的可观测性埋点、藏在其中一个Advisor里的ReAct循环。三件事拆开看，每一件都不复杂。
Spring AI没有把ReAct包装成一个显眼的Agent概念让你去学，它把循环压缩进了一个Advisor，默认情况下你甚至感觉不到自己在用Agent框架，只是在调一个会自动执行工具的聊天客户端。这种「藏起来」的设计对写业务代码的人友好，代价是调试的时候容易懵：断点打错层、以为循环丢了、不知道该去哪改最大轮数，都是这套设计换来的认知成本。搞清楚循环在哪、由谁驱动、什么时候停，这几个问题想明白了，Spring AI的工具调用机制就不再是一个黑盒。
]]>
<![CDATA[十二、Skywalking存储查询 DAO 实现]]>tag:https://lymboy.com,2026-03-10:shi-er-skywalking-cun-chu-cha-xun-dao-shi-xian2026-03-10T22:11:35+08:002026-03-10T22:11:35+08:00sairohttps://lymboy.com
存储查询 DAO 实现
这一篇解决什么 05-存储层 讲写入侧。这一篇讲查询侧：同一个"读指标"接口，BanyanDB / ES / JDBC 三个后端各用什么机制实现？BanyanDB 用 measure 倒排 + TopN 预聚合 + 原生 trace span 树；ES 用 multi-get 点查 + terms/avg 查询期聚合 + routing；JDBC 用主键 IN + SQL GROUP BY + tag 表 join。读完应该能回答：为什么 BanyanDB 查询最快、ES 次之、JDBC 最慢——以及这三套差别背后各自在押注什么。
为什么三种存储的查询实现差别这么大
先把结论摆出来，再逐个看实现。
三个后端不是"同一种查询的三种写法"，而是三种存储哲学在三套查询语义上的投影。差别根源有三层：
数据是否原生支持时序预聚合。指标的本质是"每个时间桶、每个实体一个值"。BanyanDB 把这做成了一等公民（measure 模型，写入即按 (time_bucket, entity_id) 聚合），查询只是按 entity_id 倒排查一段时间的点。ES 和 JDBC 没有时序原生模型，靠把 (time_bucket, entity_id) 当作文档 ID / 主键来"伪装"成点查——查询时算出期望的几个桶 ID，直接按 ID 取回，不走聚合。这是三者指标查询性能接近、且都不在查询期聚合的原因。
实例关系（buildInstanceRelationsQuery:155）：用 and/or 组合双向条件（source=client AND dest=server）OR（dest=client AND source=server），query.criteria(or(...))（:175）。
endpoint/进程关系类似，都靠 groupBy tag 去重。
group by tag 去重 BanyanDB 的 groupBy(tag set) 是原生 measure 操作，按 tag 维度折叠数据点。拓扑查询本质就是"在这段时间内出现过哪些关系实体"，group by entity_id 天然去重——同一关系实体出现多少次都被折成一行。这比 ES 的 terms 聚合去重更直接，因为 group by 是 measure 的原生命令。
查询 DAO 集中在 oap-server/server-storage-plugin/storage-elasticsearch-plugin/.../query/，都继承 EsDAO。
MetricsQueryEsDAO（按文档 ID 多点查——不做聚合）
oap-server/server-storage-plugin/storage-elasticsearch-plugin/.../query/MetricsQueryEsDAO.java:59。实现 IMetricsQueryDAO。理解 ES 指标查询的关键：ES 指标查询不用 ES 聚合，而是按文档 ID 多点查（multi-get）。
查询 DAO 在 oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/.../common/dao/（通用，H2/MySQL/PG 共用），PostgreSQL 特化在 postgresql/dao/。
JDBCMetricsQueryDAO（按主键 IN 查——不做聚合）
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/.../common/dao/JDBCMetricsQueryDAO.java:45。实现 IMetricsQueryDAO。和 ES 思路一样——指标按主键 ID 点查，不聚合。
对每个表发 SQL：select id, valueColumnName from table where id in (?, ?, ...)（:76-82）——主键 IN 查询，等价于 ES 的 multi-get，走主键 B-tree 索引。
结果按 Util.sortValues 排序补默认值。
foreign 指标：try-catch 跳过不含该 value 列的表（:97-103）。
listEntityIdsInRange（:217）：这里用 SQL 聚合：select entity_id, max(time_bucket) as latest_time_bucket ... where table_name=? and time_bucket>=? and time_bucket<=? group by entity_id order by latest_time_bucket desc limit ?（:250-259）。注释（:241-247）解释为什么用 GROUP BY+MAX 而非 SELECT DISTINCT：PostgreSQL 拒绝 ORDER BY 一个不在 DISTINCT 列表里的列，所以用 GROUP BY 形式可移植。跨表结果在 Java 端按 latest 合并（:270）再全局排序取 limit。
拼 SQL：where table_name=? and time_bucket>=? and time_bucket<=? and latency>=? and latency<=? and service_id=? and ... and is_error=1（:138-185），order by start_time desc / order by latency desc（:188/:191），LIMIT ? OFFSET ?（:195，buildLimit:229）。
tag 查询靠 inner join 单独的 tag 表（:132、:171-177）：inner join segment_tag t0 on main.id=t0.id and t0.tags=?。每个 tag 一次 join。
JDBC 的 tag 存储模型 SegmentRecord 用 @SQLDatabase.AdditionalEntity(additionalTables = {ADDITIONAL_TAG_TABLE})（SegmentRecord.java:88，ADDITIONAL_TAG_TABLE = "segment_tag":64）把 tags 拆到独立表 segment_tag(id, tags)。主表不存 tags，查 tag 必须 join tag 表。这和 ES（tags 字段建倒排）、BanyanDB（tags 数组 + having）完全不同——JDBC 没有倒排索引，靠额外表 + B-tree 索引 + join 实现 tag 过滤。代价是每个 tag 一次 join，tag 多了 join 数线性增长。
queryByTraceId（:236）：遍历 getTablesWithinTTL 所有 TTL 内的表（:237），每表发 where table_name=? and trace_id=?。注释里 queryBasicTraces 的 TODO: sort（:226）说明跨表结果排序未在 SQL 层做。没有 ES 那样的 routing——JDBC 无法按 traceId 路由到单表，只能全 TTL 表扫，这是 JDBC trace 查询最慢的根源。
queryBySegmentIdList（:257）：segment_id in (...)。
queryByTraceIdWithInstanceId（:282）：trace_id in (...) and service_instance_id in (...)。
doFlexibleTraceQuery（:309）返回空。
JDBCAggregationQueryDAO（SQL 子查询 GROUP BY + Java 端合并）
select result, entity_id from ( select avg(valueColumnName) as result, entity_id from table where table_name=? and time_bucket>=? and time_bucket<=? [and attr=?]... group by entity_id) as T order by result desc limit topN
即 avg + GROUP BY entity_id + ORDER BY + LIMIT——SQL 查询期聚合，单表内取 TopN。
select entity_id, component_ids from tablewhere table_name=? and time_bucket>=? and time_bucket<=? [and (source=? or dest=?)]group by entity_id, component_ids
（:172-176）——GROUP BY 去重拿到这段时间出现过的关系实体。实例/端点/进程关系同理（:223-227、:258-263、:295-301），条件用 source=? and dest=? 双向 OR。
PostgreSQLMetricsQueryDAO（:26）继承 JDBCMetricsQueryDAO，只重写 buildMetricsValueSql（:33）：给聚合列加 as result 别名（PG 对 ORDER BY 别名要求���格）。
PostgreSQLAggregationQueryDAO（:26）继承 JDBCAggregationQueryDAO，重写 buildMetricsValueSql（:32）：用 select * from (select avg(...) as result, entity_id from ...) 子查询包装。
到这里，SkyWalking OAP 的核心子系统、数据模型、协议层、Profiling、查询 DAO 都拆解完了。回到 README 看整体地图，或回看任意一篇：
00-整体架构与端到端数据流 / 01-模块系统与启动流程 / 02-数据采集层-Receiver
03-分析引擎与四大DSL / 04-流处理引擎-Worker链 / 05-存储层
06-查询层与告警 / 07-集群协调与动态配置
08-数据模型与Scope体系 / 09-协议层与Agent采集
10-Profiling体系
心智模型 把查询 DAO 想成"展厅的三种导览系统"：BanyanDB 是为 SkyWalking 量身定制的智能导览——measure 货架按 ID 直取、TopN 区有预分拣榜单、trace 区有原生族谱树、标签有数组倒排；ES 是租来的通用搜索引擎——指标靠 ID 点查、TopN 靠现场聚合、trace 靠倒排+routing、还能全文搜日志；JDBC 是拿关系库当仓库——指标靠主键 IN、TopN 靠 GROUP BY+跨表合并、trace 靠全表扫+join tag 表。同一份"查询菜单"（接口），三种仓库各有各的取法，性能差距源自谁更贴近时序+链路的原生语义。
ClassPath.from(classLoader).getTopLevelClassesRecursive("org.apache.skywalking")——递归扫描 org.apache.skywalking 包下所有顶层类(:55)。用 ClassPath API 而不是自写文件遍历,是因为 SkyWalking 可能打成 fat jar 或被 OSGi 容器加载,ClassPath API 能正确处理这些部署形态。
插件化的关键设计点 Model 后端中立，但通过三个 *ModelExtension 给每个后端留专属配置挂载位。BanyanDBModelExtension（storage/model/BanyanDBModelExtension.java:33）挂 timestampColumn（:42）、traceIdColumn（:51）、indexMode（:80）、streamGroup（:84）、traceGroup（:88）；ElasticSearchModelExtension 挂 ES 专属；SQLDatabaseModelExtension 挂附加表、复合索引。
stream 对应 Record 子类。每个事件一条记录，只追加不更新。查询靠倒排 IndexRule + 时间范围扫描。不支持服务端 TopN 预聚合——BanyanDBIndexInstaller.java:232 注释写得很直白：“Stream not support server side TopN pre-aggregation”。
倒排索引通俗解释 正排是"给我 ID 为 X 的记录"（按主键找内容）；倒排是"给我所有 service=order-service 的 trace"——先在"service → ID 列表"的索引里查到候选 ID，再回表取内容。BanyanDB 的 IndexRule 就是显式声明"我要在哪个 tag 上建倒排"，没声明则该 tag 只能顺序扫描，查询慢。
createOrUpdateTableIndexes（:138）：对非 storageOnly 列建 CREATE INDEX idx_<hash>（:145,159,182），支持复合索引（:201-212）。
SQL 生成与批量插入
JDBCMetricsDAO（common/dao/JDBCMetricsDAO.java:40）：multiGet（:45）按 ID 批查；prepareBatchInsert（:56）→ getInsertExecutor；prepareBatchUpdate（:61）→ getUpdateExecutor。
Metric：OpenTelemetryMetricHandler（.../otel/otlp/OpenTelemetryMetricHandler.java:38）调 OpenTelemetryMetricRequestProcessor.processMetricsRequest()，用 MAL 规则把 OTLP metrics 转成 SkyWalking Meter 体系。
仅 proto 定义模块（observer.proto 等），编译出 Cilium Hubble 的 Java stub，无运行时逻辑。
F 组：私有 HTTP 协议接收器
F1. telegraf-receiver · InfluxDB line protocol
TelegrafReceiverProvider（.../telegraf/provider/TelegrafReceiverProvider.java:43）复用 sharing server 的 HTTPHandlerRegister。Telegraf 用 InfluxDB line protocol 格式上报指标，Provider start() 加载 MAL 规则（Rules.loadRules，:83），取 MeterSystem（:92）注入 handler。本质是"telegraf 格式 → MAL 体系"。
registerServiceImplementation(...)（:105）是 final 方法，把 Service 实现塞进内部 services Map。requiredCheck(...)（:120）在 start 阶段校验：注册的 Service 数量必须和 ModuleDefine.services() 声明的完全一致，多了少了都报错。
class Solution { public void merge(int[] nums1, int m, int[] nums2, int n) { int i = m - 1, j = n - 1, k = m + n - 1; while (i >= 0 && j >= 0) { nums1[k--] = nums1[i] > nums2[j] ? nums1[i--] : nums2[j--]; } while (j >= 0) nums1[k--] = nums2[j--]; // nums1 剩余的不用动(已在位) }}
思路脉络：快慢指针。slow 指向下一个保留元素该放的位置，fast 扫描全数组。遇 nums[fast] != val 就赋值给 nums[slow] 并 slow++，等于 val 就跳过。和热题 100 的移动零完全同构。
class Solution { public int removeElement(int[] nums, int val) { int slow = 0; for (int fast = 0; fast < nums.length; fast++) { if (nums[fast] != val) nums[slow++] = nums[fast]; } return slow; }}
class Solution { public int removeDuplicates(int[] nums) { if (nums.length == 0) return 0; int slow = 0; for (int fast = 1; fast < nums.length; fast++) { if (nums[fast] != nums[slow]) nums[++slow] = nums[fast]; } return slow + 1; }}
class Solution { public int removeDuplicates(int[] nums) { int slow = 0; for (int fast = 0; fast < nums.length; fast++) { if (slow < 2 || nums[fast] != nums[slow - 2]) nums[slow++] = nums[fast]; } return slow; }}
思路脉络：三次反转。整体反转 → 反转前 k 个 → 反转后 n-k 个，等价于右轮转 k。先 k %= n。和热题 100 相同。
class Solution { public void rotate(int[] nums, int k) { int n = nums.length; k %= n; reverse(nums, 0, n - 1); reverse(nums, 0, k - 1); reverse(nums, k, n - 1); } void reverse(int[] a, int l, int r) { while (l < r) { int t = a[l]; a[l] = a[r]; a[r] = t; l++; r--; } }}
class Solution { public int maxProfit(int[] prices) { int minPrice = Integer.MAX_VALUE, ans = 0; for (int p : prices) { minPrice = Math.min(minPrice, p); ans = Math.max(ans, p - minPrice); } return ans; }}
class Solution { public int maxProfit(int[] prices) { int ans = 0; for (int i = 1; i < prices.length; i++) { if (prices[i] > prices[i - 1]) ans += prices[i] - prices[i - 1]; } return ans; }}
[!info] 复杂度 时间 O(n)，空间 O(1)。
[!tip] 辨析 一次买卖(121)用"维护最小值"；无限次买卖(本题)用"累加所有上升段"；最多 k 次(188)才需 DP。难度递增。
class Solution { public boolean canJump(int[] nums) { int maxReach = 0; for (int i = 0; i < nums.length; i++) { if (i > maxReach) return false; maxReach = Math.max(maxReach, i + nums[i]); } return true; }}
class Solution { public int jump(int[] nums) { int steps = 0, l = 0, r = 0; while (r < nums.length - 1) { int nextMax = 0; for (int i = l; i <= r; i++) nextMax = Math.max(nextMax, i + nums[i]); l = r + 1; r = nextMax; steps++; } return steps; }}
思路脉络：排序后从高引到低引遍历，h 是"至少有 h 篇被引 ≥ h 次"。排序后第 i 篇（从0起）引文 citations[i]，若 citations[i] >= n-i 则至少有 n-i 篇 ≥ 它，h 候选是 n-i。从后往前找第一个满足的，或正向遍历取 min(citations[i], n-i) 的最大值。
class Solution { public int hIndex(int[] citations) { Arrays.sort(citations); int h = 0, n = citations.length; for (int i = 0; i < n; i++) { h = Math.max(h, Math.min(citations[i], n - i)); } return h; }}
[!info] 复杂度 时间 O(n log n)，空间 O(1)。
[!tip] 进阶 计数排序可 O(n)：用 cnt[i] 记引文恰好 i 的篇数，超过 n 的计入 cnt[n]，从后往前累加。
class Solution { public int[] productExceptSelf(int[] nums) { int n = nums.length, res[] = new int[n]; res[0] = 1; for (int i = 1; i < n; i++) res[i] = res[i - 1] * nums[i - 1]; int right = 1; for (int i = n - 1; i >= 0; i--) { res[i] *= right; right *= nums[i]; } return res; }}
class Solution { public int canCompleteCircuit(int[] gas, int[] cost) { int total = 0, tank = 0, start = 0; for (int i = 0; i < gas.length; i++) { int diff = gas[i] - cost[i]; total += diff; tank += diff; if (tank < 0) { start = i + 1; tank = 0; } // 当前段作起点不行，重置 } return total >= 0 ? start : -1; }}
思路脉络：每人至少 1 颗。两次遍历：从左扫保证比左邻 rating 高的多一颗；从右扫保证比右邻高的多一颗，取两次的 max。两次取 max 同时满足左右约束。
class Solution { public int candy(int[] ratings) { int n = ratings.length; int[] candies = new int[n]; Arrays.fill(candies, 1); for (int i = 1; i < n; i++) // 比左邻高则 +1 if (ratings[i] > ratings[i - 1]) candies[i] = candies[i - 1] + 1; for (int i = n - 2; i >= 0; i--) // 比右邻高则 max(+1) if (ratings[i] > ratings[i + 1]) candies[i] = Math.max(candies[i], candies[i + 1] + 1); int sum = 0; for (int c : candies) sum += c; return sum; }}
class Solution { public int romanToInt(String s) { int[] v = new int[s.length()]; for (int i = 0; i < s.length(); i++) v[i] = val(s.charAt(i)); int ans = 0; for (int i = 0; i < v.length; i++) { if (i + 1 < v.length && v[i] < v[i + 1]) ans -= v[i]; else ans += v[i]; } return ans; } int val(char c) { return switch (c) { case 'I' -> 1; case 'V' -> 5; case 'X' -> 10; case 'L' -> 50; case 'C' -> 100; case 'D' -> 500; case 'M' -> 1000; default -> 0; }; }}
class Solution { public int lengthOfLastWord(String s) { int i = s.length() - 1, len = 0; while (i >= 0 && s.charAt(i) == ' ') i--; // 跳尾部空格 while (i >= 0 && s.charAt(i) != ' ') { len++; i--; } return len; }}
class Solution { public String longestCommonPrefix(String[] strs) { if (strs.length == 0) return ""; String pre = strs[0]; for (int i = 1; i < strs.length; i++) { while (!strs[i].startsWith(pre)) pre = pre.substring(0, pre.length() - 1); } return pre; }}
思路脉络：Java 直接 split("\\s+") 拆词，逆序拼。或原地双端：整体反转 → 每词反转 → 去多余空格。这里用 API 法最简洁。
class Solution { public String reverseWords(String s) { String[] words = s.trim().split("\\s+"); StringBuilder sb = new StringBuilder(); for (int i = words.length - 1; i >= 0; i--) { sb.append(words[i]); if (i > 0) sb.append(" "); } return sb.toString(); }}
class Solution { public String convert(String s, int numRows) { if (numRows == 1) return s; StringBuilder[] rows = new StringBuilder[numRows]; for (int i = 0; i < numRows; i++) rows[i] = new StringBuilder(); int cur = 0, dir = 1; for (char c : s.toCharArray()) { rows[cur].append(c); if (cur == 0) dir = 1; else if (cur == numRows - 1) dir = -1; cur += dir; } StringBuilder ans = new StringBuilder(); for (StringBuilder r : rows) ans.append(r); return ans.toString(); }}
[!info] 复杂度 时间 O(n)，空间 O(n)。
[!warning] 易错点 numRows == 1 时直接返回原串，否则 cur += dir 会越界（numRows-1 = 0，dir 一直在 1/-1 间跳但 cur 不动，但循环里 cur == 0 和 cur == numRows-1 同时成立会反复改 dir，实际 cur 始终 0，能跑但浪费。显式 return 更稳）。
class Solution { public int strStr(String haystack, String needle) { int n = haystack.length(), m = needle.length(); for (int i = 0; i <= n - m; i++) { int j = 0; for (; j < m && haystack.charAt(i + j) == needle.charAt(j); j++); if (j == m) return i; } return -1; }}
[!info] 复杂度 时间 O(nm)（朴素），空间 O(1)。
[!tip] 进阶 KMP 用 next 数组预处理 needle 的"最长相同前后缀"，失配时跳过已匹配部分，O(n+m)。适合大文本匹配，面试会追。
class Solution { public List<String> fullJustify(String[] words, int maxWidth) { List<String> res = new ArrayList<>(); int i = 0, n = words.length; while (i < n) { int lineLen = words[i].length(), j = i + 1; while (j < n && lineLen + 1 + words[j].length() <= maxWidth) { lineLen += 1 + words[j++].length(); // j 是下一行起点 } int gap = j - i - 1; // 本行词间距数 StringBuilder sb = new StringBuilder(words[i]); if (j == n || gap == 0) { // 末行 或 单词一行 for (int k = i + 1; k < j; k++) sb.append(' ').append(words[k]); while (sb.length() < maxWidth) sb.append(' '); } else { int spaces = (maxWidth - lineLen + gap) / (gap); // 每个 gap 的基础空格 int extra = (maxWidth - lineLen + gap) % gap; // 多出的分给左边 for (int k = i + 1; k < j; k++) { int sp = spaces + (k - i <= extra ? 1 : 0); sb.append(" ".repeat(sp)).append(words[k]); } } res.add(sb.toString()); i = j; } return res; }}
class Solution { public boolean isPalindrome(String s) { int l = 0, r = s.length() - 1; while (l < r) { while (l < r && !Character.isLetterOrDigit(s.charAt(l))) l++; while (l < r && !Character.isLetterOrDigit(s.charAt(r))) r--; if (Character.toLowerCase(s.charAt(l++)) != Character.toLowerCase(s.charAt(r--))) return false; } return true; }}
class Solution { public boolean isSubsequence(String s, String t) { int i = 0; for (int j = 0; j < t.length() && i < s.length(); j++) { if (s.charAt(i) == t.charAt(j)) i++; } return i == s.length(); }}
[!info] 复杂度 时间 O(n+m)，空间 O(1)。
[!tip] 进阶
若 t 固定、s 有大量查询，预处理 t 为"每个位置之后各字母最早出现位置"的 next[i][26] 表，每个 s 查询 O(|s|)。
class Solution { public int[] twoSum(int[] numbers, int target) { int l = 0, r = numbers.length - 1; while (l < r) { int sum = numbers[l] + numbers[r]; if (sum == target) return new int[]{l + 1, r + 1}; else if (sum < target) l++; else r--; } return new int[0]; }}
思路脉络：双指针从两端出发。宽 (r-l) 在缩小，面积 = min(h[l],h[r]) × 宽。移动矮边才有可能让 min 变大；移动高边宽更小且 min 不升（被矮边卡住），面积必减。所以哪边矮移哪边。和热题 100 相同。
class Solution { public int maxArea(int[] height) { int l = 0, r = height.length - 1, ans = 0; while (l < r) { ans = Math.max(ans, Math.min(height[l], height[r]) * (r - l)); if (height[l] < height[r]) l++; else r--; } return ans; }}
class Solution { public List<List<Integer>> threeSum(int[] nums) { List<List<Integer>> res = new ArrayList<>(); Arrays.sort(nums); for (int i = 0; i < nums.length - 2; i++) { if (nums[i] > 0) break; if (i > 0 && nums[i] == nums[i - 1]) continue; int l = i + 1, r = nums.length - 1; while (l < r) { int sum = nums[i] + nums[l] + nums[r]; if (sum < 0) l++; else if (sum > 0) r--; else { res.add(Arrays.asList(nums[i], nums[l], nums[r])); while (l < r && nums[l] == nums[l + 1]) l++; while (l < r && nums[r] == nums[r - 1]) r--; l++; r--; } } } return res; }}
思路脉络：正整数 → 窗口和单调。变长窗口：r 扩加入 sum，一旦 sum ≥ target 就缩 l（边缩边更新最短长度、减 sum）。正整数保证缩 l 和一定减，不会错过更优解。
class Solution { public int minSubArrayLen(int target, int[] nums) { int l = 0, sum = 0, ans = Integer.MAX_VALUE; for (int r = 0; r < nums.length; r++) { sum += nums[r]; while (sum >= target) { ans = Math.min(ans, r - l + 1); sum -= nums[l++]; } } return ans == Integer.MAX_VALUE ? 0 : ans; }}
思路脉络：哈希记字符最近下标，r 遇重复时 l 跳到 max(l, map[c]+1)（不能后退）。和热题 100 相同。
class Solution { public int lengthOfLongestSubstring(String s) { Map<Character, Integer> map = new HashMap<>(); int l = 0, ans = 0; for (int r = 0; r < s.length(); r++) { char c = s.charAt(r); if (map.containsKey(c)) l = Math.max(l, map.get(c) + 1); map.put(c, r); ans = Math.max(ans, r - l + 1); } return ans; }}
[!info] 复杂度 时间 O(n)，空间 O(字符集)。
[!warning] 易错点
Math.max 保证 l 只前进。abba 处理第二个 b 时 l 跳到 2，处理第二个 a 时 map.get('a')+1=1 不能让 l 退回。
思路脉络：单词定长 w，把 s 按 w 切成"词序列"。窗口大小固定为 words.length，对每个起始偏移 0..w-1 各做一次定长滑动窗口 + 计数匹配。本质是"定长窗口 + 状态计数"。
class Solution { public List<Integer> findSubstring(String s, String[] words) { List<Integer> res = new ArrayList<>(); int n = s.length(), m = words.length, w = words[0].length(); Map<String, Integer> need = new HashMap<>(); for (String wd : words) need.merge(wd, 1, Integer::sum); for (int off = 0; off < w; off++) { int l = off, count = 0; Map<String, Integer> win = new HashMap<>(); for (int r = off; r + w <= n; r += w) { String word = s.substring(r, r + w); if (!need.containsKey(word)) { win.clear(); count = 0; l = r + w; continue; } win.merge(word, 1, Integer::sum); count++; while (win.get(word) > need.get(word)) { String out = s.substring(l, l + w); win.merge(out, -1, Integer::sum); count--; l += w; } if (count == m) res.add(l); } } return res; }}
class Solution { public boolean isValidSudoku(char[][] board) { boolean[][] row = new boolean[9][9], col = new boolean[9][9], box = new boolean[9][9]; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { char c = board[i][j]; if (c == '.') continue; int d = c - '1', b = (i / 3) * 3 + j / 3; if (row[i][d] || col[j][d] || box[b][d]) return false; row[i][d] = col[j][d] = box[b][d] = true; } } return true; }}
class Solution { public List<Integer> spiralOrder(int[][] matrix) { List<Integer> res = new ArrayList<>(); int top = 0, bottom = matrix.length - 1, left = 0, right = matrix[0].length - 1; while (top <= bottom && left <= right) { for (int j = left; j <= right; j++) res.add(matrix[top][j]); top++; for (int i = top; i <= bottom; i++) res.add(matrix[i][right]); right--; if (top <= bottom) { for (int j = right; j >= left; j--) res.add(matrix[bottom][j]); bottom--; } if (left <= right) { for (int i = bottom; i >= top; i--) res.add(matrix[i][left]); left++; } } return res; }}
class Solution { public void rotate(int[][] matrix) { int n = matrix.length; for (int i = 0; i < n; i++) for (int j = i + 1; j < n; j++) { int t = matrix[i][j]; matrix[i][j] = matrix[j][i]; matrix[j][i] = t; } for (int[] row : matrix) { int l = 0, r = n - 1; while (l < r) { int t = row[l]; row[l] = row[r]; row[r] = t; l++; r--; } } }}
class Solution { public void setZeroes(int[][] matrix) { int m = matrix.length, n = matrix[0].length; boolean firstRow = false, firstCol = false; for (int j = 0; j < n; j++) if (matrix[0][j] == 0) firstRow = true; for (int i = 0; i < m; i++) if (matrix[i][0] == 0) firstCol = true; for (int i = 1; i < m; i++) for (int j = 1; j < n; j++) if (matrix[i][j] == 0) { matrix[i][0] = 0; matrix[0][j] = 0; } for (int i = 1; i < m; i++) for (int j = 1; j < n; j++) if (matrix[i][0] == 0 || matrix[0][j] == 0) matrix[i][j] = 0; if (firstRow) for (int j = 0; j < n; j++) matrix[0][j] = 0; if (firstCol) for (int i = 0; i < m; i++) matrix[i][0] = 0; }}
class Solution { public void gameOfLife(int[][] board) { int m = board.length, n = board[0].length; int[] dx = {-1,-1,-1,0,0,1,1,1}, dy = {-1,0,1,-1,1,-1,0,1}; for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { int live = 0; for (int k = 0; k < 8; k++) { int x = i + dx[k], y = j + dy[k]; if (x >= 0 && x < m && y >= 0 && y < n && Math.abs(board[x][y]) == 1) live++; } if (board[i][j] == 1 && (live < 2 || live > 3)) board[i][j] = -1; else if (board[i][j] == 0 && live == 3) board[i][j] = 2; } } for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) board[i][j] = board[i][j] > 0 ? 1 : 0; }}
class Solution { public boolean isIsomorphic(String s, String t) { Map<Character, Character> s2t = new HashMap<>(), t2s = new HashMap<>(); for (int i = 0; i < s.length(); i++) { char a = s.charAt(i), b = t.charAt(i); if (s2t.containsKey(a) && s2t.get(a) != b) return false; if (t2s.containsKey(b) && t2s.get(b) != a) return false; s2t.put(a, b); t2s.put(b, a); } return true; }}
class Solution { public boolean isAnagram(String s, String t) { if (s.length() != t.length()) return false; int[] cnt = new int[26]; for (char c : s.toCharArray()) cnt[c - 'a']++; for (char c : t.toCharArray()) cnt[c - 'a']--; for (int n : cnt) if (n != 0) return false; return true; }}
class Solution { public List<List<String>> groupAnagrams(String[] strs) { Map<String, List<String>> map = new HashMap<>(); for (String s : strs) { char[] cs = s.toCharArray(); Arrays.sort(cs); map.computeIfAbsent(new String(cs), k -> new ArrayList<>()).add(s); } return new ArrayList<>(map.values()); }}
思路脉络：边查边存。固定 num 要找的是 target-num，哈希 O(1) 查。先查再存避免用到自己。和热题 100 相同。
class Solution { public int[] twoSum(int[] nums, int target) { Map<Integer, Integer> map = new HashMap<>(); for (int i = 0; i < nums.length; i++) { int need = target - nums[i]; if (map.containsKey(need)) return new int[]{map.get(need), i}; map.put(nums[i], i); } return new int[0]; }}
class Solution { public boolean isHappy(int n) { Set<Integer> seen = new HashSet<>(); while (n != 1 && !seen.contains(n)) { seen.add(n); n = next(n); } return n == 1; } int next(int n) { int sum = 0; while (n > 0) { int d = n % 10; sum += d * d; n /= 10; } return sum; }}
class Solution { public int longestConsecutive(int[] nums) { Set<Integer> set = new HashSet<>(); for (int n : nums) set.add(n); int best = 0; for (int x : set) { if (set.contains(x - 1)) continue; int cur = x, len = 1; while (set.contains(cur + 1)) { cur++; len++; } best = Math.max(best, len); } return best; }}
class Solution { public List<String> summaryRanges(int[] nums) { List<String> res = new ArrayList<>(); for (int i = 0; i < nums.length; i++) { int l = i; while (i + 1 < nums.length && nums[i + 1] == nums[i] + 1) i++; if (l == i) res.add(String.valueOf(nums[l])); else res.add(nums[l] + "->" + nums[i]); } return res; }}
[!info] 复杂度 时间 O(n)，空间 O(1)。
[!warning] 易错点
单点（l==i）单独输出数字，连续段输出 a->b。while 推进 i，外层 for 的 i++ 会跳到下一段起点。
class Solution { public int[][] insert(int[][] intervals, int[] newInterval) { List<int[]> res = new ArrayList<>(); int i = 0, n = intervals.length; while (i < n && intervals[i][1] < newInterval[0]) res.add(intervals[i++]); while (i < n && intervals[i][0] <= newInterval[1]) { newInterval[0] = Math.min(newInterval[0], intervals[i][0]); newInterval[1] = Math.max(newInterval[1], intervals[i][1]); i++; } res.add(newInterval); while (i < n) res.add(intervals[i++]); return res.toArray(new int[0][]); }}
class Solution { public int findMinArrowShots(int[][] points) { if (points.length == 0) return 0; Arrays.sort(points, (a, b) -> Integer.compare(a[1], b[1])); int arrows = 1, end = points[0][1]; for (int[] p : points) { if (p[0] > end) { arrows++; end = p[1]; } } return arrows; }}
class Solution { public boolean isValid(String s) { Map<Character, Character> m = Map.of(')', '(', ']', '[', '}', '{'); Deque<Character> st = new ArrayDeque<>(); for (char c : s.toCharArray()) { if (!m.containsKey(c)) st.push(c); else if (st.isEmpty() || st.pop() != m.get(c)) return false; } return st.isEmpty(); }}
思路脉络：辅助栈 minSt 同步压栈，每步记"当前栈内最小值"。pop 同步弹。和热题 100 相同。
class MinStack { Deque<Integer> st = new ArrayDeque<>(), minSt = new ArrayDeque<>(); public MinStack() { minSt.push(Integer.MAX_VALUE); } public void push(int v) { st.push(v); minSt.push(Math.min(minSt.peek(), v)); } public void pop() { st.pop(); minSt.pop(); } public int top() { return st.peek(); } public int getMin() { return minSt.peek(); }}
class Solution { public int evalRPN(String[] tokens) { Deque<Integer> st = new ArrayDeque<>(); for (String t : tokens) { if (t.equals("+") || t.equals("-") || t.equals("*") || t.equals("/")) { int b = st.pop(), a = st.pop(); st.push(t.equals("+") ? a + b : t.equals("-") ? a - b : t.equals("*") ? a * b : a / b); } else st.push(Integer.parseInt(t)); } return st.pop(); }}
class Solution { public int calculate(String s) { Deque<Integer> st = new ArrayDeque<>(); int res = 0, sign = 1, num = 0; for (char c : s.toCharArray()) { if (Character.isDigit(c)) num = num * 10 + (c - '0'); else if (c == '+') { res += sign * num; num = 0; sign = 1; } else if (c == '-') { res += sign * num; num = 0; sign = -1; } else if (c == '(') { st.push(res); st.push(sign); res = 0; sign = 1; } else if (c == ')') { res += sign * num; num = 0; res *= st.pop(); res += st.pop(); } } return res + sign * num; }}
[!info] 复杂度 时间 O(n)，空间 O(n)。
[!warning] 易错点
最后 return res + sign*num 处理末尾未结算的数字。遇 ( 入栈顺序是 res 先、sign 后，遇 ) 弹出是 sign 先（乘）、res 后（加）——LIFO。num 用完后归零。
class Solution { public Node copyRandomList(Node head) { if (head == null) return null; Map<Node, Node> map = new HashMap<>(); for (Node p = head; p != null; p = p.next) map.put(p, new Node(p.val)); for (Node p = head; p != null; p = p.next) { map.get(p).next = map.get(p.next); map.get(p).random = map.get(p.random); } return map.get(head); }}
思路脉络：先定位 pre（left 前驱）。用头插法反转 [left, right]：每次把 cur 插到 pre 后面，tail（原 left）不断被往后推。dummy 处理 left=1。
class Solution { public ListNode reverseBetween(ListNode head, int left, int right) { ListNode dummy = new ListNode(0, head), pre = dummy; for (int i = 1; i < left; i++) pre = pre.next; ListNode tail = pre.next, cur = tail.next; for (int i = left; i < right; i++) { ListNode next = cur.next; cur.next = pre.next; pre.next = cur; tail.next = next; cur = next; } return dummy.next; }}
[!info] 复杂度 时间 O(n)，空间 O(1)。
[!warning] 易错点
头插法：cur 插到 pre 后，tail（原 left）始终是这段的尾，tail.next = next 维持它与右侧连接。
class Solution { public ListNode removeNthFromEnd(ListNode head, int n) { ListNode dummy = new ListNode(0, head), fast = dummy, slow = dummy; for (int i = 0; i < n; i++) fast = fast.next; while (fast.next != null) { fast = fast.next; slow = slow.next; } slow.next = slow.next.next; return dummy.next; }}
class Solution { public ListNode partition(ListNode head, int x) { ListNode small = new ListNode(0), big = new ListNode(0); ListNode s = small, b = big; for (ListNode p = head; p != null; p = p.next) { if (p.val < x) { s.next = p; s = s.next; } else { b.next = p; b = b.next; } } b.next = null; s.next = big.next; return small.next; }}
class Solution { public boolean isSymmetric(TreeNode root) { return check(root.left, root.right); } boolean check(TreeNode a, TreeNode b) { if (a == null && b == null) return true; if (a == null || b == null) return false; return a.val == b.val && check(a.left, b.right) && check(a.right, b.left); }}
思路脉络：DFS 传"当前累计值" cur = cur*10 + node.val。到叶子时把 cur 加进总和。
class Solution { int sum = 0; public int sumNumbers(TreeNode root) { dfs(root, 0); return sum; } void dfs(TreeNode node, int cur) { if (node == null) return; cur = cur * 10 + node.val; if (node.left == null && node.right == null) sum += cur; dfs(node.left, cur); dfs(node.right, cur); }}
class Solution { int ans = Integer.MIN_VALUE; public int maxPathSum(TreeNode root) { gain(root); return ans; } int gain(TreeNode root) { if (root == null) return 0; int l = Math.max(0, gain(root.left)), r = Math.max(0, gain(root.right)); ans = Math.max(ans, l + r + root.val); return Math.max(l, r) + root.val; }}
[!info] 复杂度 时间 O(n)，空间 O(h)。
[!warning] 易错点
ans 用"两边和"（完整路径可分叉在当前），return 用"单边"（向上不能分叉）。负贡献 Math.max(0, ...) 截断。
class BSTIterator { Deque<TreeNode> st = new ArrayDeque<>(); public BSTIterator(TreeNode root) { pushLeft(root); } public int next() { TreeNode n = st.pop(); pushLeft(n.right); return n.val; } public boolean hasNext() { return !st.isEmpty(); } void pushLeft(TreeNode n) { while (n != null) { st.push(n); n = n.left; } }}
思路脉络：层序遍历，每层最后一个节点就是右视图。复用 BFS 模板，记录 i == size-1 的节点。
class Solution { public List<Integer> rightSideView(TreeNode root) { List<Integer> res = new ArrayList<>(); if (root == null) return res; Queue<TreeNode> q = new ArrayDeque<>(); q.offer(root); while (!q.isEmpty()) { int size = q.size(); for (int i = 0; i < size; i++) { TreeNode n = q.poll(); if (i == size - 1) res.add(n.val); if (n.left != null) q.offer(n.left); if (n.right != null) q.offer(n.right); } } return res; }}
class Solution { public List<Double> averageOfLevels(TreeNode root) { List<Double> res = new ArrayList<>(); Queue<TreeNode> q = new ArrayDeque<>(); q.offer(root); while (!q.isEmpty()) { int size = q.size(); double sum = 0; for (int i = 0; i < size; i++) { TreeNode n = q.poll(); sum += n.val; if (n.left != null) q.offer(n.left); if (n.right != null) q.offer(n.right); } res.add(sum / size); } return res; }}
class Solution { public List<List<Integer>> levelOrder(TreeNode root) { List<List<Integer>> res = new ArrayList<>(); if (root == null) return res; Queue<TreeNode> q = new ArrayDeque<>(); q.offer(root); while (!q.isEmpty()) { int size = q.size(); List<Integer> level = new ArrayList<>(); for (int i = 0; i < size; i++) { TreeNode n = q.poll(); level.add(n.val); if (n.left != null) q.offer(n.left); if (n.right != null) q.offer(n.right); } res.add(level); } return res; }}
class Solution { public List<List<Integer>> zigzagLevelOrder(TreeNode root) { List<List<Integer>> res = new ArrayList<>(); if (root == null) return res; Queue<TreeNode> q = new ArrayDeque<>(); q.offer(root); boolean leftToRight = true; while (!q.isEmpty()) { int size = q.size(); LinkedList<Integer> level = new LinkedList<>(); for (int i = 0; i < size; i++) { TreeNode n = q.poll(); if (leftToRight) level.add(n.val); else level.addFirst(n.val); if (n.left != null) q.offer(n.left); if (n.right != null) q.offer(n.right); } res.add(level); leftToRight = !leftToRight; } return res; }}
class Solution { public int numIslands(char[][] grid) { int m = grid.length, n = grid[0].length, ans = 0; for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) if (grid[i][j] == '1') { dfs(grid, i, j); ans++; } return ans; } void dfs(char[][] g, int i, int j) { if (i < 0 || i >= g.length || j < 0 || j >= g[0].length || g[i][j] != '1') return; g[i][j] = '0'; dfs(g, i+1, j); dfs(g, i-1, j); dfs(g, i, j+1); dfs(g, i, j-1); }}
思路脉络：反向思考——从边界所有 O 出发 DFS/BFS 标记"不翻"，剩下的 O 都是被围的，翻成 X。
class Solution { public void solve(char[][] board) { int m = board.length, n = board[0].length; for (int i = 0; i < m; i++) { dfs(board, i, 0); dfs(board, i, n - 1); // 左右边界 } for (int j = 0; j < n; j++) { dfs(board, 0, j); dfs(board, m - 1, j); // 上下边界 } for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) { if (board[i][j] == 'O') board[i][j] = 'X'; // 剩下的 O 是被围的 else if (board[i][j] == 'A') board[i][j] = 'O'; // 标记的还原 } } void dfs(char[][] b, int i, int j) { if (i < 0 || i >= b.length || j < 0 || j >= b[0].length || b[i][j] != 'O') return; b[i][j] = 'A'; dfs(b, i+1, j); dfs(b, i-1, j); dfs(b, i, j+1); dfs(b, i, j-1); }}
class Solution { Map<Node, Node> map = new HashMap<>(); public Node cloneGraph(Node node) { if (node == null) return null; if (map.containsKey(node)) return map.get(node); Node clone = new Node(node.val); map.put(node, clone); for (Node nb : node.neighbors) clone.neighbors.add(cloneGraph(nb)); return clone; }}
思路脉络：把等式建成带权有向图——a→b 权 k、b→a 权 1/k。每次查询从 c 到 d 做 BFS/DFS，路径权乘积即答案；不可达返回 -1。
class Solution { public double[] calcEquation(List<List<String>> eq, double[] val, List<List<String>> q) { Map<String, Map<String, Double>> g = new HashMap<>(); for (int i = 0; i < eq.size(); i++) { String a = eq.get(i).get(0), b = eq.get(i).get(1); g.computeIfAbsent(a, k -> new HashMap<>()).put(b, val[i]); g.computeIfAbsent(b, k -> new HashMap<>()).put(a, 1.0 / val[i]); } double[] res = new double[q.size()]; for (int i = 0; i < q.size(); i++) { res[i] = bfs(g, q.get(i).get(0), q.get(i).get(1), new HashSet<>()); } return res; } double bfs(Map<String, Map<String, Double>> g, String s, String t, Set<String> seen) { if (!g.containsKey(s) || !g.containsKey(t)) return -1.0; if (s.equals(t)) return 1.0; seen.add(s); for (Map.Entry<String, Double> e : g.get(s).entrySet()) { if (!seen.contains(e.getKey())) { double sub = bfs(g, e.getKey(), t, seen); if (sub != -1.0) return e.getValue() * sub; } } return -1.0; }}
class Solution { public boolean canFinish(int n, int[][] pre) { List<List<Integer>> g = new ArrayList<>(); int[] indeg = new int[n]; for (int i = 0; i < n; i++) g.add(new ArrayList<>()); for (int[] p : pre) { g.get(p[1]).add(p[0]); indeg[p[0]]++; } Queue<Integer> q = new ArrayDeque<>(); for (int i = 0; i < n; i++) if (indeg[i] == 0) q.offer(i); int cnt = 0; while (!q.isEmpty()) { int c = q.poll(); cnt++; for (int nx : g.get(c)) if (--indeg[nx] == 0) q.offer(nx); } return cnt == n; }}
class Solution { public int[] findOrder(int n, int[][] pre) { List<List<Integer>> g = new ArrayList<>(); int[] indeg = new int[n]; for (int i = 0; i < n; i++) g.add(new ArrayList<>()); for (int[] p : pre) { g.get(p[1]).add(p[0]); indeg[p[0]]++; } Queue<Integer> q = new ArrayDeque<>(); for (int i = 0; i < n; i++) if (indeg[i] == 0) q.offer(i); int[] res = new int[n]; int idx = 0; while (!q.isEmpty()) { int c = q.poll(); res[idx++] = c; for (int nx : g.get(c)) if (--indeg[nx] == 0) q.offer(nx); } return idx == n ? res : new int[0]; }}
思路脉络：BFS 最短步数。每个位置 i 模拟掷 1-6，遇到蛇梯跳转（注意 Boustrophedon 编号——奇数行从左到右、偶数行从右到左，坐标映射是难点）。
class Solution { public int snakesAndLadders(int[][] board) { int n = board.length, target = n * n; int[] dist = new int[target + 1]; Arrays.fill(dist, -1); dist[1] = 0; Queue<Integer> q = new ArrayDeque<>(); q.offer(1); while (!q.isEmpty()) { int cur = q.poll(); for (int move = 1; move <= 6 && cur + move <= target; move++) { int next = cur + move; int[] rc = pos(next, n); int r = rc[0], c = rc[1]; if (board[r][c] != -1) next = board[r][c]; if (dist[next] == -1) { dist[next] = dist[cur] + 1; q.offer(next); } } } return dist[target]; } int[] pos(int num, int n) { int r = (num - 1) / n, c = (num - 1) % n; // 从底起算的行列 if (r % 2 == 1) c = n - 1 - c; // 偶数行(从底0起)反向 return new int[]{n - 1 - r, c}; // 转成从顶起的行 }}
[!info] 复杂度 时间 O(n²)，空间 O(n²)。
[!warning] 易错点
坐标映射 pos：从底起第 r 行，r 偶数正向、奇数反向；最终行号 = n-1-r。这块最容易写错，建议画图验证。
class Solution { public int minMutation(String start, String end, String[] bank) { Set<String> set = new HashSet<>(Arrays.asList(bank)); if (!set.contains(end)) return -1; char[] genes = {'A','C','G','T'}; Queue<String> q = new ArrayDeque<>(); q.offer(start); Set<String> seen = new HashSet<>(); seen.add(start); int steps = 0; while (!q.isEmpty()) { int size = q.size(); for (int i = 0; i < size; i++) { String cur = q.poll(); if (cur.equals(end)) return steps; char[] cs = cur.toCharArray(); for (int j = 0; j < cs.length; j++) { char old = cs[j]; for (char g : genes) { cs[j] = g; String nb = new String(cs); if (set.contains(nb) && !seen.contains(nb)) { seen.add(nb); q.offer(nb); } } cs[j] = old; } } steps++; } return -1; }}
class Solution { public int ladderLength(String begin, String end, List<String> wordList) { Set<String> dict = new HashSet<>(wordList); if (!dict.contains(end)) return 0; Queue<String> q = new ArrayDeque<>(); q.offer(begin); Set<String> seen = new HashSet<>(); seen.add(begin); int steps = 1; while (!q.isEmpty()) { int size = q.size(); for (int i = 0; i < size; i++) { char[] cs = q.poll().toCharArray(); for (int j = 0; j < cs.length; j++) { char old = cs[j]; for (char c = 'a'; c <= 'z'; c++) { cs[j] = c; String nb = new String(cs); if (nb.equals(end)) return steps + 1; if (dict.contains(nb) && !seen.contains(nb)) { seen.add(nb); q.offer(nb); } } cs[j] = old; } } steps++; } return 0; }}
[!info] 复杂度 时间 O(N × L × 26)，空间 O(N)。
[!tip] 进阶
双向 BFS：从 begin 和 end 各自 BFS，每步扩节点少的一侧，相遇即最短。对大词典快很多，但实现稍复杂。
class Solution { class Trie { Trie[] ch = new Trie[26]; String word; } int[] dx = {-1,1,0,0}, dy = {0,0,-1,1}; public List<String> findWords(char[][] board, String[] words) { Trie root = new Trie(); for (String w : words) { Trie node = root; for (char c : w.toCharArray()) { int i = c - 'a'; if (node.ch[i] == null) node.ch[i] = new Trie(); node = node.ch[i]; } node.word = w; } List<String> res = new ArrayList<>(); for (int i = 0; i < board.length; i++) for (int j = 0; j < board[0].length; j++) dfs(board, i, j, root, res); return res; } void dfs(char[][] b, int i, int j, Trie node, List<String> res) { char c = b[i][j]; if (c == '#' || node.ch[c - 'a'] == null) return; node = node.ch[c - 'a']; if (node.word != null) { res.add(node.word); node.word = null; } // 收集并去重 b[i][j] = '#'; for (int k = 0; k < 4; k++) { int x = i + dx[k], y = j + dy[k]; if (x >= 0 && x < b.length && y >= 0 && y < b[0].length) dfs(b, x, y, node, res); } b[i][j] = c; }}
class Solution { String[] map = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"}; List<String> res = new ArrayList<>(); public List<String> letterCombinations(String digits) { if (digits.isEmpty()) return res; backtrack(digits, 0, new StringBuilder()); return res; } void backtrack(String d, int i, StringBuilder sb) { if (i == d.length()) { res.add(sb.toString()); return; } for (char c : map[d.charAt(i) - '0'].toCharArray()) { sb.append(c); backtrack(d, i + 1, sb); sb.deleteCharAt(sb.length() - 1); } }}
思路脉络：组合用 start 防重复（只往后选）。每层从 start 到 n，选了就递归 i+1，长度到 k 收集。
class Solution { List<List<Integer>> res = new ArrayList<>(); public List<List<Integer>> combine(int n, int k) { backtrack(n, k, 1, new ArrayList<>()); return res; } void backtrack(int n, int k, int start, List<Integer> path) { if (path.size() == k) { res.add(new ArrayList<>(path)); return; } for (int i = start; i <= n; i++) { path.add(i); backtrack(n, k, i + 1, path); path.remove(path.size() - 1); } }}
[!info] 复杂度 时间 O(C(n,k))，空间 O(k)。
[!tip] 剪枝
i <= n - (k - path.size()) + 1：剩余位置不够凑满 k 个时停，省掉无效分支。
class Solution { List<List<Integer>> res = new ArrayList<>(); public List<List<Integer>> combinationSum(int[] c, int target) { Arrays.sort(c); backtrack(c, target, 0, new ArrayList<>()); return res; } void backtrack(int[] c, int remain, int start, List<Integer> path) { if (remain == 0) { res.add(new ArrayList<>(path)); return; } for (int i = start; i < c.length; i++) { if (c[i] > remain) break; path.add(c[i]); backtrack(c, remain - c[i], i, path); path.remove(path.size() - 1); } }}
思路脉络：逐行回溯，每行选一列。冲突检查只看上方（同行只一个、下方没放）：同列、主对角(row-col)、副对角(row+col)。用三个 Set 记已占列/对角，valid 降到 O(1)。
class Solution { int ans = 0; Set<Integer> col = new HashSet<>(), diag1 = new HashSet<>(), diag2 = new HashSet<>(); public int totalNQueens(int n) { backtrack(n, 0); return ans; } void backtrack(int n, int row) { if (row == n) { ans++; return; } for (int c = 0; c < n; c++) { int d1 = row - c, d2 = row + c; if (col.contains(c) || diag1.contains(d1) || diag2.contains(d2)) continue; col.add(c); diag1.add(d1); diag2.add(d2); backtrack(n, row + 1); col.remove(c); diag1.remove(d1); diag2.remove(d2); } }}
[!info] 复杂度 时间 O(n!)，空间 O(n)。
[!tip] 套路
对角线用 row-col、row+col 作 key 是经典。和 N 皇后 I 完全同模板，只是不收集棋盘只计数。
class Solution { public boolean exist(char[][] board, String word) { int m = board.length, n = board[0].length; for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) if (dfs(board, word, i, j, 0)) return true; return false; } boolean dfs(char[][] b, String w, int i, int j, int k) { if (k == w.length()) return true; if (i < 0 || i >= b.length || j < 0 || j >= b[0].length || b[i][j] != w.charAt(k)) return false; char t = b[i][j]; b[i][j] = '#'; boolean f = dfs(b, w, i+1, j, k+1) || dfs(b, w, i-1, j, k+1) || dfs(b, w, i, j+1, k+1) || dfs(b, w, i, j-1, k+1); b[i][j] = t; return f; }}
class Solution { public Node construct(int[][] grid) { return build(grid, 0, 0, grid.length); } Node build(int[][] g, int r, int c, int len) { if (same(g, r, c, len)) return new Node(g[r][c] == 1, true); Node node = new Node(true, false); int half = len / 2; node.topLeft = build(g, r, c, half); node.topRight = build(g, r, c + half, half); node.bottomLeft = build(g, r + half, c, half); node.bottomRight = build(g, r + half, c + half, half); return node; } boolean same(int[][] g, int r, int c, int len) { int v = g[r][c]; for (int i = r; i < r + len; i++) for (int j = c; j < c + len; j++) if (g[i][j] != v) return false; return true; }}
[!info] 复杂度 时间 O(n²)，空间 O(log n)。
[!warning] 易错点
象限顺序：左上、右上、左下、右下，坐标偏移别搞反。叶节点 val = g[r][c]==1、isLeaf=true。
class Solution { public ListNode mergeKLists(ListNode[] lists) { if (lists == null || lists.length == 0) return null; PriorityQueue<ListNode> pq = new PriorityQueue<>((a, b) -> a.val - b.val); for (ListNode h : lists) if (h != null) pq.offer(h); ListNode dummy = new ListNode(0), cur = dummy; while (!pq.isEmpty()) { ListNode n = pq.poll(); cur.next = n; cur = cur.next; if (n.next != null) pq.offer(n.next); } return dummy.next; }}
class Solution { public int maxSubArray(int[] nums) { int pre = 0, ans = Integer.MIN_VALUE; for (int n : nums) { pre = Math.max(n, pre + n); ans = Math.max(ans, pre); } return ans; }}
思路脉络：标准精确二分。找不到时 l 正好停在应插入位置（循环结束 l=r+1，l 指向第一个大于 target 的位置）。
class Solution { public int searchInsert(int[] nums, int target) { int l = 0, r = nums.length - 1; while (l <= r) { int m = (l + r) / 2; if (nums[m] == target) return m; else if (nums[m] < target) l = m + 1; else r = m - 1; } return l; }}
class Solution { public boolean searchMatrix(int[][] matrix, int target) { int m = matrix.length, n = matrix[0].length, l = 0, r = m * n - 1; while (l <= r) { int mid = (l + r) / 2, v = matrix[mid / n][mid % n]; if (v == target) return true; else if (v < target) l = mid + 1; else r = mid - 1; } return false; }}
class Solution { public int findPeakElement(int[] nums) { int l = 0, r = nums.length - 1; while (l < r) { int m = (l + r) / 2; if (nums[m] < nums[m + 1]) l = m + 1; else r = m; } return l; }}
class Solution { public int search(int[] nums, int target) { int l = 0, r = nums.length - 1; while (l <= r) { int m = (l + r) / 2; if (nums[m] == target) return m; if (nums[l] <= nums[m]) { if (nums[l] <= target && target < nums[m]) r = m - 1; else l = m + 1; } else { if (nums[m] < target && target <= nums[r]) l = m + 1; else r = m - 1; } } return -1; }}
class Solution { public int[] searchRange(int[] nums, int target) { return new int[]{findLeft(nums, target), findRight(nums, target)}; } int findLeft(int[] a, int t) { int l = 0, r = a.length - 1, ans = -1; while (l <= r) { int m = (l+r)/2; if (a[m]==t) { ans=m; r=m-1; } else if (a[m]<t) l=m+1; else r=m-1; } return ans; } int findRight(int[] a, int t) { int l = 0, r = a.length - 1, ans = -1; while (l <= r) { int m = (l+r)/2; if (a[m]==t) { ans=m; l=m+1; } else if (a[m]<t) l=m+1; else r=m-1; } return ans; }}
思路脉络：和 right 比。nums[m] > nums[r] 最小在右半；否则最小在 m 或左半。r = m（不减一，m 可能是最小）。
class Solution { public int findMin(int[] nums) { int l = 0, r = nums.length - 1; while (l < r) { int m = (l + r) / 2; if (nums[m] > nums[r]) l = m + 1; else r = m; } return nums[l]; }}
class Solution { public double findMedianSortedArrays(int[] a, int[] b) { if (a.length > b.length) return findMedianSortedArrays(b, a); int m = a.length, n = b.length, half = (m + n + 1) / 2, lo = 0, hi = m; while (lo <= hi) { int i = (lo + hi) / 2, j = half - i; int aL = i == 0 ? Integer.MIN_VALUE : a[i - 1]; int aR = i == m ? Integer.MAX_VALUE : a[i]; int bL = j == 0 ? Integer.MIN_VALUE : b[j - 1]; int bR = j == n ? Integer.MAX_VALUE : b[j]; if (aL <= bR && bL <= aR) { if ((m + n) % 2 == 1) return Math.max(aL, bL); return (Math.max(aL, bL) + Math.min(aR, bR)) / 2.0; } else if (aL > bR) hi = i - 1; else lo = i + 1; } return 0; }}
[!info] 复杂度 时间 O(log(min(m,n)))，空间 O(1)。
[!warning] 易错点
必须在短数组上二分：否则 j = half - i 可能越界。开头 swap 保证 a 短。边界用 ±∞：i==0 时 aL 取 MIN_VALUE。
17. 堆
堆维护"半个有序集"，快速取最大/最小。两类：Top-K（大小 K 的堆，比堆顶差就丢）、动态中位数（大顶堆装小半 + 小顶堆装大半，平衡规模）。
class Solution { public int findKthLargest(int[] nums, int k) { k = nums.length - k; int l = 0, r = nums.length - 1; while (l < r) { int p = partition(nums, l, r); if (p == k) return nums[p]; else if (p < k) l = p + 1; else r = p - 1; } return nums[l]; } int partition(int[] a, int l, int r) { int pivot = a[r], i = l; for (int j = l; j < r; j++) if (a[j] <= pivot) swap(a, i++, j); swap(a, i, r); return i; } void swap(int[] a, int i, int j) { int t = a[i]; a[i] = a[j]; a[j] = t; }}
k 个项目，各有资本 w[i] 和利润 p[i]，从初始资本 W 开始，每次选能做的（w[i] <= W）里利润最大的，求做完 k 个后的总资本。
思路脉络：贪心 + 两个堆。按资本升序排项目，用最大利润堆维护"当前能做的项目"。每次做利润最大的（堆顶），做完资本增加，把新解锁的项目入堆，做 k 次。
class Solution { public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) { int n = profits.length, i = 0; int[][] projects = new int[n][2]; for (int j = 0; j < n; j++) projects[j] = new int[]{capital[j], profits[j]}; Arrays.sort(projects, (a, b) -> a[0] - b[0]); PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder()); for (int cnt = 0; cnt < k; cnt++) { while (i < n && projects[i][0] <= w) maxHeap.offer(projects[i++][1]); if (maxHeap.isEmpty()) break; w += maxHeap.poll(); } return w; }}
[!info] 复杂度 时间 O(n log n + k log n)，空间 O(n)。
[!warning] 易错点
必须按资本升序排，才能用指针 i 一次性把"新解锁"的项目入堆（资本只增不减，入过堆的不用退）。堆里选利润最大——贪心选择。
class Solution { public String addBinary(String a, String b) { StringBuilder sb = new StringBuilder(); int i = a.length() - 1, j = b.length() - 1, carry = 0; while (i >= 0 || j >= 0 || carry != 0) { int sum = carry; if (i >= 0) sum += a.charAt(i--) - '0'; if (j >= 0) sum += b.charAt(j--) - '0'; sb.append(sum % 2); carry = sum / 2; } return sb.reverse().toString(); }}
思路脉络：逐位处理。每次取 n 最低位，左移到结果的高位（res = (res<<1) | (n&1)），n 右移。32 次循环。
public class Solution { public int reverseBits(int n) { int res = 0; for (int i = 0; i < 32; i++) { res = (res << 1) | (n & 1); n >>>= 1; } return res; }}
class Solution { public int singleNumber(int[] nums) { int ans = 0; for (int i = 0; i < 32; i++) { int cnt = 0; for (int n : nums) cnt += (n >> i) & 1; ans |= (cnt % 3) << i; } return ans; }}
思路脉络：二分。mid*mid <= x 则候选并往右，否则往左。用 mid <= x/mid 代替 mid*mid 防溢出。
class Solution { public int mySqrt(int x) { int l = 1, r = x, ans = 0; while (l <= r) { int m = (l + r) / 2; if (m <= x / m) { ans = m; l = m + 1; } else r = m - 1; } return ans; }}
class Solution { public double myPow(double x, int n) { long N = n; if (N < 0) { x = 1 / x; N = -N; } double ans = 1; while (N > 0) { if ((N & 1) == 1) ans *= x; x *= x; N >>= 1; } return ans; }}
[!info] 复杂度 时间 O(log n)，空间 O(1)。
[!warning] 易错点
n 用 long 接收：Integer.MIN_VALUE 取反溢出。N & 1 判奇偶，N >>= 1 折半。
class Solution { public int maxPoints(int[][] points) { int ans = 1, n = points.length; for (int i = 0; i < n; i++) { Map<String, Integer> slopes = new HashMap<>(); int dup = 0, max = 0; for (int j = i + 1; j < n; j++) { int dx = points[j][0] - points[i][0], dy = points[j][1] - points[i][1]; if (dx == 0 && dy == 0) { dup++; continue; } int g = gcd(dx, dy); String slope = (dx / g) + "/" + (dy / g); max = Math.max(max, slopes.merge(slope, 1, Integer::sum)); } ans = Math.max(ans, max + dup + 1); } return ans; } int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }}
class Solution { public int climbStairs(int n) { if (n <= 2) return n; int a = 1, b = 2; for (int i = 3; i <= n; i++) { int c = a + b; a = b; b = c; } return b; }}
思路脉络：dp[i] = 前 i 间最大金额。偷第 i 间则 dp[i-2]+nums[i]，不偷则 dp[i-1]，取大。压缩成 prev2/prev1。
class Solution { public int rob(int[] nums) { int prev2 = 0, prev1 = 0; for (int n : nums) { int cur = Math.max(prev1, prev2 + n); prev2 = prev1; prev1 = cur; } return prev1; }}
class Solution { public int lengthOfLIS(int[] nums) { int[] tails = new int[nums.length], len = 0; for (int num : nums) { int l = 0, r = len; while (l < r) { int m = (l + r) / 2; if (tails[m] < num) l = m + 1; else r = m; } tails[l] = num; if (l == len) len++; } return len; }}
class Solution { public int minPathSum(int[][] grid) { int m = grid.length, n = grid[0].length; for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) { if (i == 0 && j == 0) continue; else if (i == 0) grid[i][j] += grid[i][j - 1]; else if (j == 0) grid[i][j] += grid[i - 1][j]; else grid[i][j] += Math.min(grid[i - 1][j], grid[i][j - 1]); } return grid[m - 1][n - 1]; }}
class Solution { public String longestPalindrome(String s) { int st = 0, max = 1; for (int i = 0; i < s.length(); i++) { int l1 = expand(s, i, i), l2 = expand(s, i, i + 1); int len = Math.max(l1, l2); if (len > max) { max = len; st = i - (len - 1) / 2; } } return s.substring(st, st + max); } int expand(String s, int l, int r) { while (l >= 0 && r < s.length() && s.charAt(l) == s.charAt(r)) { l--; r++; } return r - l - 1; }}
[!info] 复杂度 时间 O(n²)，空间 O(1)。
[!warning] 易错点
expand 返回 r - l - 1：退出时 l/r 已是不匹配位置，真实回文 (l+1, r-1)，长 r-1-(l+1)+1 = r-l-1。起点 i - (len-1)/2 对奇偶都成立。
class Solution { public int[] twoSum(int[] nums, int target) { Map<Integer, Integer> map = new HashMap<>(); // 值 -> 下标 for (int i = 0; i < nums.length; i++) { int need = target - nums[i]; if (map.containsKey(need)) { return new int[]{map.get(need), i}; // 先查再存，避免用到自己 } map.put(nums[i], i); } return new int[0]; // 题目保证有解，走不到 }}
graph LR A["字符串 str"] --> B["规范化为 key"] B --> C{"map 含 key?"} C -- 有 --> D["加入该组列表"] C -- 没有 --> E["新建列表并加入"] D --> F["map.values() 即结果"] E --> F
排序法代码最直观：
class Solution { public List<List<String>> groupAnagrams(String[] strs) { Map<String, List<String>> map = new HashMap<>(); for (String s : strs) { char[] cs = s.toCharArray(); Arrays.sort(cs); // 排序后作为 key String key = new String(cs); map.computeIfAbsent(key, k -> new ArrayList<>()).add(s); } return new ArrayList<>(map.values()); }}
graph LR A["全部数放入 Set"] --> B["遍历每个数 x"] B --> C{"x-1 在 Set 中?"} C -- 是 → 非起点，跳过 --> B C -- 否 → x 是起点 --> D["从 x 向上数 x+1, x+2..."] D --> E["更新最长长度"] E --> B
class Solution { public int longestConsecutive(int[] nums) { Set<Integer> set = new HashSet<>(); for (int n : nums) set.add(n); int best = 0; for (int x : set) { if (set.contains(x - 1)) continue; // 不是起点，跳过 int cur = x, len = 1; while (set.contains(cur + 1)) { cur++; len++; } best = Math.max(best, len); } return best; }}
graph LR A["slow=0 非零落脚点"] --> B["fast 遍历数组"] B --> C{"nums[fast] != 0?"} C -- 是 --> D["交换 slow 与 fast"] D --> E["slow++"] C -- 否 --> F["跳过"] E --> B F --> B
class Solution { public void moveZeroes(int[] nums) { int slow = 0; for (int fast = 0; fast < nums.length; fast++) { if (nums[fast] != 0) { int t = nums[slow]; nums[slow] = nums[fast]; nums[fast] = t; slow++; } } }}
移动高的一边：高被 min 限制，移动后宽更小，且新边若更高也不会提升 min（被原矮边卡住），若更矮则 min 更小——面积必减。 移动矮的一边：矮边是瓶颈，换掉它才有可能让 min 变大。虽然不一定变好，但只有这条路有可能变好。
所以策略：哪边矮移哪边。
graph LR A["l=0, r=n-1"] --> B["算面积 min*宽"] B --> C["更新答案"] C --> D{"h[l] < h[r]?"} D -- 是 --> E["l++ 移矮边"] D -- 否 --> F["r-- 移矮边"] E --> B F --> B
class Solution { public int maxArea(int[] height) { int l = 0, r = height.length - 1, ans = 0; while (l < r) { int area = Math.min(height[l], height[r]) * (r - l); ans = Math.max(ans, area); if (height[l] < height[r]) l++; else r--; } return ans; }}
[!info] 复杂度 时间 O(n)，空间 O(1)。
[!warning] 易错点 别写成"移动高的"。正确性证明要抓住"宽必减、高受 min 限制"两点，移动矮边是唯一可能变好的方向。
graph LR A["排序"] --> B["固定 i"] B --> C["l=i+1, r=n-1"] C --> D["sum = nums[i]+nums[l]+nums[r]"] D --> E{"sum ? 0"} E -- "<0" --> F["l++"] E -- ">0" --> G["r--"] E -- "=0" --> H["记录答案"] H --> I["l,r 各自跳过重复"] I --> J["l++, r--"] F --> D G --> D J --> D
class Solution { public List<List<Integer>> threeSum(int[] nums) { List<List<Integer>> res = new ArrayList<>(); Arrays.sort(nums); for (int i = 0; i < nums.length - 2; i++) { if (nums[i] > 0) break; // 最小值已>0 if (i > 0 && nums[i] == nums[i - 1]) continue; // i 去重 int l = i + 1, r = nums.length - 1; while (l < r) { int sum = nums[i] + nums[l] + nums[r]; if (sum < 0) l++; else if (sum > 0) r--; else { res.add(Arrays.asList(nums[i], nums[l], nums[r])); while (l < r && nums[l] == nums[l + 1]) l++; // l 去重 while (l < r && nums[r] == nums[r - 1]) r--; // r 去重 l++; r--; } } } return res; }}
graph LR A["l=0,r=n-1<br/>leftMax=rightMax=0"] --> B{"h[l] < h[r]?"} B -- 是 --> C{"h[l] >= leftMax?"} C -- 是 --> D["更新 leftMax"] C -- 否 --> E["累加 leftMax-h[l]"] D --> F["l++"] E --> F B -- 否 --> G{"h[r] >= rightMax?"} G -- 是 --> H["更新 rightMax"] G -- 否 --> I["累加 rightMax-h[r]"] H --> J["r--"] I --> J F --> B J --> B
class Solution { public int trap(int[] height) { int l = 0, r = height.length - 1; int leftMax = 0, rightMax = 0, ans = 0; while (l < r) { if (height[l] < height[r]) { // 左边矮，瓶颈在左 if (height[l] >= leftMax) leftMax = height[l]; else ans += leftMax - height[l]; l++; } else { // 右边矮，瓶颈在右 if (height[r] >= rightMax) rightMax = height[r]; else ans += rightMax - height[r]; r--; } } return ans; }}
思路脉络：暴力是枚举所有子串 O(n³) 或固定起点向右延伸 O(n²)。观察：若子串 [l,r] 在 r 处出现重复字符 c，那么任何 l 不动的更长子串都含重复——l 必须跳过 c 上次出现的位置。
所以用哈希记下每个字符最近一次出现的下标，r 遇到重复时，l 直接跳到 map.get(c)+1。注意要用 max(l, ...)：因为重复字符可能已经在 l 左侧（窗口外），不能往回缩。
graph LR A["l=0, r 遍历"] --> B{"c 上次出现在窗口内?"} B -- 是 --> C["l 跳到 上次下标+1"] B -- 否 --> D["窗口合法"] C --> E["更新 c 位置, 更新答案"] D --> E E --> A
class Solution { public int lengthOfLongestSubstring(String s) { Map<Character, Integer> map = new HashMap<>(); // 字符 -> 最近下标 int l = 0, ans = 0; for (int r = 0; r < s.length(); r++) { char c = s.charAt(r); if (map.containsKey(c)) { l = Math.max(l, map.get(c) + 1); // 只能前进，不能后退 } map.put(c, r); ans = Math.max(ans, r - l + 1); } return ans; }}
[!info] 复杂度 时间 O(n)，空间 O(字符集大小)。
[!warning] 易错点 漏掉 Math.max 会导致 l 回退。例如 abba，处理第二个 b 时 l 跳到 2，处理第二个 a 时若直接用 map.get('a')+1 = 1，l 会从 2 退回 1，窗口反而变大且含重复。
438. 找到字符串中所有字母异位词
找 p 的所有异位词在 s 中的起始下标。
思路脉络：异位词 = 长度相同且字母计数相同。固定大小为 m = p.length() 的窗口在 s 上滑动，问哪些位置的窗口计数等于 p 的计数。
朴素做法每次滑完比较 26 个字母计数，O(26n)。优化：维护 valid——窗口与 need 计数相等的字母种类数。每次加入/移除一个字符，只影响该字符一处的相等关系，O(1) 更新 valid。当 valid == 26 时窗口与 p 完全匹配。
graph LR A["need = p 的计数"] --> B["窗口先填前 m 个字符"] B --> C["算初始 valid"] C --> D["r 从 m 滑到 n-1"] D --> E["加入 s[r], 移除 s[i-m]"] E --> F["O(1) 更新 valid"] F --> G{"valid == 26?"} G -- 是 --> H["记录起点"] G -- 否 --> D H --> D
class Solution { public List<Integer> findAnagrams(String s, String p) { List<Integer> res = new ArrayList<>(); int n = s.length(), m = p.length(); if (n < m) return res; int[] need = new int[26], win = new int[26]; for (int i = 0; i < m; i++) { need[p.charAt(i) - 'a']++; win[s.charAt(i) - 'a']++; } int valid = 0; for (int i = 0; i < 26; i++) if (need[i] == win[i]) valid++; // 含 need=0&win=0 的种 if (valid == 26) res.add(0); for (int i = m; i < n; i++) { char in = s.charAt(i), out = s.charAt(i - m); // 加入 in if (need[in - 'a'] == win[in - 'a']) valid--; // 加入前相等, 加入后将不等 win[in - 'a']++; if (need[in - 'a'] == win[in - 'a']) valid++; // 移除 out if (need[out - 'a'] == win[out - 'a']) valid--; win[out - 'a']--; if (need[out - 'a'] == win[out - 'a']) valid++; if (valid == 26) res.add(i - m + 1); } return res; }}
边算前缀和边用哈希记录"之前出现过哪些前缀和、各几次"，当前 pre 减 k 能在哈希里命中多少个，就有多少个以 i 结尾的合法子数组。一次遍历搞定。
graph LR A["维护前缀和 pre"] --> B{"map 含 pre-k?"} B -- 是 --> C["ans += 出现次数"] B -- 否 --> D["map[pre]++"] C --> D D --> A
class Solution { public int subarraySum(int[] nums, int k) { Map<Integer, Integer> map = new HashMap<>(); map.put(0, 1); // 前缀和 0 出现 1 次, 处理从下标 0 起的子数组 int pre = 0, ans = 0; for (int n : nums) { pre += n; if (map.containsKey(pre - k)) ans += map.get(pre - k); map.merge(pre, 1, Integer::sum); } return ans; }}
graph LR A["遍历 i"] --> B["弹出队尾所有 ≤ nums[i] 的"] B --> C["i 入队尾"] C --> D{"队首下标 < i-k+1?"} D -- 是 --> E["队首过期, 弹出"] D -- 否 --> F{"i ≥ k-1?"} E --> F F -- 是 --> G["记录 nums[队首]"] F -- 否 --> A G --> A
class Solution { public int[] maxSlidingWindow(int[] nums, int k) { int n = nums.length; int[] res = new int[n - k + 1]; Deque<Integer> dq = new ArrayDeque<>(); // 存下标, 单调递减 for (int i = 0; i < n; i++) { while (!dq.isEmpty() && nums[dq.peekLast()] <= nums[i]) dq.pollLast(); dq.offerLast(i); if (dq.peekFirst() <= i - k) dq.pollFirst(); // 队首过期 if (i >= k - 1) res[i - k + 1] = nums[dq.peekFirst()]; } return res; }}
用 valid 记录"窗口里满足需求计数的字符种类数"，valid == need.size() 表示已覆盖。覆盖时不断缩 l 并更新最小答案；一旦缩到不覆盖，就退出去继续扩 r。
graph LR A["r 扩张, 加入字符"] --> B{"valid == 需求种类数?"} B -- 否 --> A B -- 是 --> C["缩 l"] C --> D["更新最小窗口"] D --> E["移除 s[l], l++"] E --> F{"仍覆盖?"} F -- 是 --> C F -- 否 --> A
class Solution { public String minWindow(String s, String t) { Map<Character, Integer> need = new HashMap<>(); for (char c : t.toCharArray()) need.merge(c, 1, Integer::sum); Map<Character, Integer> win = new HashMap<>(); int l = 0, valid = 0, needCnt = need.size(); int start = 0, minLen = Integer.MAX_VALUE; for (int r = 0; r < s.length(); r++) { char c = s.charAt(r); if (need.containsKey(c)) { win.merge(c, 1, Integer::sum); if (win.get(c).equals(need.get(c))) valid++; } while (valid == needCnt) { // 覆盖了, 尝试缩 if (r - l + 1 < minLen) { minLen = r - l + 1; start = l; } char d = s.charAt(l++); if (need.containsKey(d)) { if (win.get(d).equals(need.get(d))) valid--; // 移除后该种将不满足 win.merge(d, -1, Integer::sum); } } } return minLen == Integer.MAX_VALUE ? "" : s.substring(start, start + minLen); }}
DP 视角：dp[i] 表示以 i 结尾的最大子数组和。要么把 nums[i] 续在前一段后面（dp[i-1]+nums[i]），要么从 nums[i] 重新开始（nums[i]），取大者。状态只依赖上一个，压缩成一个变量 pre。
前缀和视角：子数组和 = 当前前缀和 − 之前最小前缀和。维护一个最小前缀和即可。
两种都 O(n)。DP 写法更常用。
graph LR A["遍历 num"] --> B["pre = max(num, pre+num)"] B --> C["ans = max(ans, pre)"] C --> A
class Solution { public int maxSubArray(int[] nums) { int pre = 0, ans = Integer.MIN_VALUE; for (int n : nums) { pre = Math.max(n, pre + n); // 续上 或 从头 ans = Math.max(ans, pre); } return ans; }}
[!example] 三次反转推演（动图） [1,2,3,4,5,6,7] k=3：整体反转让后 k 个挪到前面（倒序），再分别反转前后两段恢复内部顺序，得到 [5,6,7,1,2,3,4]。
graph LR A["k %= n"] --> B["反转 0..n-1"] B --> C["反转 0..k-1"] C --> D["反转 k..n-1"]
class Solution { public void rotate(int[] nums, int k) { int n = nums.length; k %= n; // k 可能大于 n reverse(nums, 0, n - 1); reverse(nums, 0, k - 1); reverse(nums, k, n - 1); } void reverse(int[] a, int l, int r) { while (l < r) { int t = a[l]; a[l] = a[r]; a[r] = t; l++; r--; } }}
[!info] 复杂度 时间 O(n)，空间 O(1)。
[!warning] 易错点 忘记 k %= n 会导致越界或重复转。空数组、k=0 要先处理（上面的写法对 k=0 也成立，反转 0 个元素是空操作）。
graph LR A["第一趟: 左到右"] --> B["res[i] = res[i-1]*nums[i-1]"] B --> C["res 存好左侧乘积"] C --> D["第二趟: 右到左"] D --> E["res[i] *= right; right *= nums[i]"] E --> F["res 存最终结果"]
class Solution { public int[] productExceptSelf(int[] nums) { int n = nums.length; int[] res = new int[n]; res[0] = 1; for (int i = 1; i < n; i++) res[i] = res[i - 1] * nums[i - 1]; // 左乘积 int right = 1; for (int i = n - 1; i >= 0; i--) { res[i] *= right; // 乘上右侧乘积 right *= nums[i]; // 更新右侧乘积 } return res; }}
graph LR A["遍历每个位置"] --> B{"nums[i] 在 [1,n] 且未归位?"} B -- 是 --> C["交换到 nums[i]-1 位置"] C --> B B -- 否 --> D["i++"] D --> E["扫一遍找 nums[i]≠i+1"] E --> F["返回 i+1, 否则 n+1"]
class Solution { public int firstMissingPositive(int[] nums) { int n = nums.length; for (int i = 0; i < n; i++) { while (1 <= nums[i] && nums[i] <= n && nums[i] != nums[nums[i] - 1]) { int t = nums[nums[i] - 1]; // 先存目标位原值 nums[nums[i] - 1] = nums[i]; // 归位 nums[i] = t; // 换回来的继续判断 } } for (int i = 0; i < n; i++) if (nums[i] != i + 1) return i + 1; return n + 1; }}
graph LR A["两个布尔标记首行首列是否含0"] --> B["遍历内部, 用首行首列记0位"] B --> C["据首行首列标记清内部"] C --> D["最后据布尔标记清首行首列"]
class Solution { public void setZeroes(int[][] matrix) { int m = matrix.length, n = matrix[0].length; boolean firstRow = false, firstCol = false; for (int j = 0; j < n; j++) if (matrix[0][j] == 0) firstRow = true; for (int i = 0; i < m; i++) if (matrix[i][0] == 0) firstCol = true; for (int i = 1; i < m; i++) for (int j = 1; j < n; j++) if (matrix[i][j] == 0) { matrix[i][0] = 0; matrix[0][j] = 0; } for (int i = 1; i < m; i++) for (int j = 1; j < n; j++) if (matrix[i][0] == 0 || matrix[0][j] == 0) matrix[i][j] = 0; if (firstRow) for (int j = 0; j < n; j++) matrix[0][j] = 0; if (firstCol) for (int i = 0; i < m; i++) matrix[i][0] = 0; }}
graph LR A["top/bottom/left/right 四边界"] --> B["→遍历顶行, top++"] B --> C["↓遍历右列, right--"] C --> D{"top≤bottom? →遍历底行, bottom--"} D --> E{"left≤right? ↑遍历左列, left++"} E --> F{"边界未交叉?"} F -- 是 --> B F -- 否 --> G["结束"]
class Solution { public List<Integer> spiralOrder(int[][] matrix) { List<Integer> res = new ArrayList<>(); int top = 0, bottom = matrix.length - 1, left = 0, right = matrix[0].length - 1; while (top <= bottom && left <= right) { for (int j = left; j <= right; j++) res.add(matrix[top][j]); top++; for (int i = top; i <= bottom; i++) res.add(matrix[i][right]); right--; if (top <= bottom) { for (int j = right; j >= left; j--) res.add(matrix[bottom][j]); bottom--; } if (left <= right) { for (int i = bottom; i >= top; i--) res.add(matrix[i][left]); left++; } } return res; }}
graph LR A["原矩阵"] --> B["沿主对角线转置"] B --> C["每行左右翻转"] C --> D["顺时针90°结果"]
class Solution { public void rotate(int[][] matrix) { int n = matrix.length; for (int i = 0; i < n; i++) // 转置 for (int j = i + 1; j < n; j++) { int t = matrix[i][j]; matrix[i][j] = matrix[j][i]; matrix[j][i] = t; } for (int[] row : matrix) { // 每行翻转 int l = 0, r = n - 1; while (l < r) { int t = row[l]; row[l] = row[r]; row[r] = t; l++; r--; } } }}
graph LR A["从右上角出发"] --> B{"当前值 ? target"} B -- "相等" --> C["返回 true"] B -- "更大" --> D["左移 j--"] B -- "更小" --> E["下移 i++"] D --> F{"越界?"} E --> F F -- 否 --> B F -- 是 --> G["返回 false"]
class Solution { public boolean searchMatrix(int[][] matrix, int target) { int m = matrix.length, n = matrix[0].length; int i = 0, j = n - 1; // 右上角 while (i < m && j >= 0) { if (matrix[i][j] == target) return true; else if (matrix[i][j] > target) j--; // 太大, 这一列下面更大, 排除整列 else i++; // 太小, 这一行左边更小, 排除整行 } return false; }}
思路脉络：找倒数第 N 个，朴素是先数长度再走 len-n。一次遍历做法：快慢指针，fast 先走 n 步，再和 slow 同速，fast 到尾时 slow 恰在倒数第 N+1 个（待删的前驱）。用 dummy 是为了处理"删头"这种边界——否则删头时找不到前驱。
graph LR A["fast 先走 n 步"] --> B["fast/slow 同速前进"] B --> C{"fast.next == null?"} C -- 是 --> D["slow 在待删前驱"] D --> E["slow.next = slow.next.next"] C -- 否 --> B
class Solution { public ListNode removeNthFromEnd(ListNode head, int n) { ListNode dummy = new ListNode(0, head); ListNode fast = dummy, slow = dummy; for (int i = 0; i < n; i++) fast = fast.next; // fast 先走 n 步 while (fast.next != null) { fast = fast.next; slow = slow.next; } slow.next = slow.next.next; // 删除 return dummy.next; }}
[!example] 分组反转接回（动图） 1→2→3→4→5 k=2：每组数 k 个定 tail，区间反转后头尾接回主链，不足 k 保持原样。最终 2→1→4→3→5。reverse 里 prev 从 tail.next 起是省处理的关键。
graph LR A["pre=dummy"] --> B["数 k 个找 tail"] B --> C{"不足 k?"} C -- 是 --> D["返回 dummy.next"] C -- 否 --> E["记 nxt=tail.next"] E --> F["反转 head..tail"] F --> G["pre.next=新头, 新尾.next=nxt"] G --> H["pre=新尾, head=nxt"] H --> B
class Solution { public ListNode reverseKGroup(ListNode head, int k) { ListNode dummy = new ListNode(0, head), pre = dummy; while (head != null) { ListNode tail = pre; for (int i = 0; i < k; i++) { tail = tail.next; if (tail == null) return dummy.next; // 不足 k, 不翻 } ListNode nxt = tail.next; ListNode[] rev = reverse(head, tail); // rev[0]=新头, rev[1]=新尾 head = rev[0]; tail = rev[1]; pre.next = head; // 接回头 tail.next = nxt; // 接回尾 pre = tail; head = nxt; } return dummy.next; } ListNode[] reverse(ListNode head, ListNode tail) { ListNode prev = tail.next, cur = head; // prev 从 tail.next 起 while (prev != tail) { ListNode next = cur.next; cur.next = prev; prev = cur; cur = next; } return new ListNode[]{tail, head}; // 翻转后 tail 是头, head 是尾 }}
思路脉络：难点在 random 指向任意位置，复制时要建立"旧节点→新节点"的映射。哈希法两遍扫描：第一遍建所有新节点存 map，第二遍据旧节点的 next/random 查 map 连新节点。
class Solution { public Node copyRandomList(Node head) { if (head == null) return null; Map<Node, Node> map = new HashMap<>(); for (Node p = head; p != null; p = p.next) map.put(p, new Node(p.val)); for (Node p = head; p != null; p = p.next) { map.get(p).next = map.get(p.next); // null 也安全: map.get(null)=null map.get(p).random = map.get(p.random); } return map.get(head); }}
class Solution { int ans = 0; public int diameterOfBinaryTree(TreeNode root) { depth(root); return ans; } int depth(TreeNode root) { if (root == null) return 0; int l = depth(root.left), r = depth(root.right); ans = Math.max(ans, l + r); // 经过当前节点的直径 return Math.max(l, r) + 1; // 返回单边深度给上层 }}
class Solution { public List<List<Integer>> levelOrder(TreeNode root) { List<List<Integer>> res = new ArrayList<>(); if (root == null) return res; Queue<TreeNode> q = new ArrayDeque<>(); q.offer(root); while (!q.isEmpty()) { int size = q.size(); // 本层节点数 List<Integer> level = new ArrayList<>(); for (int i = 0; i < size; i++) { TreeNode n = q.poll(); level.add(n.val); if (n.left != null) q.offer(n.left); if (n.right != null) q.offer(n.right); } res.add(level); } return res; }}
class Solution { public List<Integer> rightSideView(TreeNode root) { List<Integer> res = new ArrayList<>(); if (root == null) return res; Queue<TreeNode> q = new ArrayDeque<>(); q.offer(root); while (!q.isEmpty()) { int size = q.size(); for (int i = 0; i < size; i++) { TreeNode n = q.poll(); if (i == size - 1) res.add(n.val); // 每层最后一个 if (n.left != null) q.offer(n.left); if (n.right != null) q.offer(n.right); } } return res; }}
[!example] 后序递归找 LCA（动图） 找 p=5、q=4：后序深入，命中 p 直接返回自身；左右都非空→当前是 LCA；单边非空→透传那侧。本例 5 自身就是 p 且是 q 的祖先，命中即返回，5 就是 LCA。
graph LR A["root==null/p/q?"] --> B["返回 root"] B --> C["递归左 l, 递归右 r"] C --> D{"l 和 r 都非空?"} D -- 是 --> E["root 就是 LCA"] D -- "只 l 非空" --> F["返回 l"] D -- "只 r 非空" --> G["返回 r"]
class Solution { public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { if (root == null || root == p || root == q) return root; TreeNode l = lowestCommonAncestor(root.left, p, q); TreeNode r = lowestCommonAncestor(root.right, p, q); if (l != null && r != null) return root; // 分居两侧 return l != null ? l : r; }}
[!info] 复杂度 时间 O(n)，空间 O(h)。
[!tip] 妙处
这套递归巧妙处理了"p 是 q 祖先"的情况：找到 p 时直接返回 p，上层一侧非空一侧空，返回 p，p 自然就是 LCA。无需特判。
graph LR A["gain(root)"] --> B["左贡献=max(0, gain(left))"] B --> C["右贡献=max(0, gain(right))"] C --> D["ans=max(ans, 左+右+root.val)"] D --> E["返回 max(左,右)+root.val 给上层"]
class Solution { int ans = Integer.MIN_VALUE; public int maxPathSum(TreeNode root) { gain(root); return ans; } int gain(TreeNode root) { if (root == null) return 0; int l = Math.max(0, gain(root.left)); // 负贡献截断 int r = Math.max(0, gain(root.right)); ans = Math.max(ans, l + r + root.val); // 经过当前的完整路径 return Math.max(l, r) + root.val; // 单边向上贡献 }}
[!info] 复杂度 时间 O(n)，空间 O(h)。
[!warning] 易错点
ans 用"两边和"（完整路径可分叉在当前节点），return 用"单边"（向上不能分叉）。这是和 [[#543. 二叉树的直径]] 完全同构的思路——一个记和、一个记边数，框架一致。
graph LR A["遍历 grid"] --> B{"是 '1'?"} B -- 是 --> C["DFS 感染整岛为 '0'"] C --> D["ans++"] B -- 否 --> A D --> A
class Solution { public int numIslands(char[][] grid) { int m = grid.length, n = grid[0].length, ans = 0; for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) if (grid[i][j] == '1') { dfs(grid, i, j); ans++; } return ans; } void dfs(char[][] g, int i, int j) { if (i < 0 || i >= g.length || j < 0 || j >= g[0].length || g[i][j] != '1') return; g[i][j] = '0'; // 原地标记 dfs(g, i+1, j); dfs(g, i-1, j); dfs(g, i, j+1); dfs(g, i, j-1); }}
graph LR A["所有烂橘子同时入队"] --> B["按层 BFS 扩散"] B --> C["感染邻居, fresh--"] C --> D["层数++"] D --> E{"fresh==0?"} E -- 是 --> F["返回层数"] E -- 否 --> B F2["队列空仍 fresh>0"] --> G["返回 -1"]
class Solution { public int orangesRotting(int[][] grid) { int m = grid.length, n = grid[0].length, fresh = 0; Queue<int[]> q = new ArrayDeque<>(); for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) { if (grid[i][j] == 2) q.offer(new int[]{i, j}); else if (grid[i][j] == 1) fresh++; } int[][] d = {{1,0},{-1,0},{0,1},{0,-1}}; int min = 0; while (!q.isEmpty() && fresh > 0) { // fresh>0 才继续, 否则多算一层 for (int k = q.size(); k > 0; k--) { int[] c = q.poll(); for (int[] dir : d) { int x = c[0]+dir[0], y = c[1]+dir[1]; if (x<0||x>=m||y<0||y>=n||grid[x][y]!=1) continue; grid[x][y] = 2; fresh--; q.offer(new int[]{x, y}); } } min++; } return fresh == 0 ? min : -1; }}
graph LR A["建图 + 入度表"] --> B["入度 0 的入队"] B --> C["出队, 后继入度--"] C --> D{"新的入度 0?"} D -- 是 --> E["入队"] D -- 否 --> C E --> C C --> F{"处理数 == n?"} F -- 是 --> G["可完成(无环)"] F -- 否 --> H["有环, 不可"]
class Solution { public boolean canFinish(int n, int[][] prerequisites) { List<List<Integer>> g = new ArrayList<>(); int[] indeg = new int[n]; for (int i = 0; i < n; i++) g.add(new ArrayList<>()); for (int[] p : prerequisites) { // p[1] -> p[0] g.get(p[1]).add(p[0]); indeg[p[0]]++; } Queue<Integer> q = new ArrayDeque<>(); for (int i = 0; i < n; i++) if (indeg[i] == 0) q.offer(i); int cnt = 0; while (!q.isEmpty()) { int c = q.poll(); cnt++; for (int nx : g.get(c)) if (--indeg[nx] == 0) q.offer(nx); } return cnt == n; // 全部排完则无环 }}
[!info] 复杂度 时间 O(V+E)，空间 O(V+E)。
[!warning] 易错点
边方向别建反：[a,b] 表示"先 b 后 a"，所以是 b→a（b 是 a 的前驱，a 依赖 b，b 完成后 a 入度才减）。建反了入度语义就错。
graph LR A["选一个未用数"] --> B["加入路径, used=true"] B --> C["递归"] C --> D{"路径满?"} D -- 是 --> E["收集结果"] D -- 否 --> A E --> F["撤销: remove, used=false"] F --> A
class Solution { List<List<Integer>> res = new ArrayList<>(); public List<List<Integer>> permute(int[] nums) { backtrack(nums, new ArrayList<>(), new boolean[nums.length]); return res; } void backtrack(int[] nums, List<Integer> path, boolean[] used) { if (path.size() == nums.length) { res.add(new ArrayList<>(path)); return; } for (int i = 0; i < nums.length; i++) { if (used[i]) continue; path.add(nums[i]); used[i] = true; backtrack(nums, path, used); path.remove(path.size() - 1); used[i] = false; // 撤销 } }}
[!info] 复杂度 时间 O(n·n!)，空间 O(n)。
[!warning] 易错点
收集时要 new ArrayList<>(path) 复制，不能直接 add(path)——path 是同一个引用，回溯后会被清空，最终结果全空。
graph LR A["sb, open, close"] --> B{"open < n?"} B -- 是 --> C["放 (, open++"] C --> A B -- 否 --> D{"close < open?"} D -- 是 --> E["放 ), close++"] E --> A D -- 否 --> F{"len == 2n?"} F -- 是 --> G["收集"]
class Solution { List<String> res = new ArrayList<>(); public List<String> generateParenthesis(int n) { backtrack(new StringBuilder(), 0, 0, n); return res; } void backtrack(StringBuilder sb, int open, int close, int n) { if (sb.length() == 2 * n) { res.add(sb.toString()); return; } if (open < n) { sb.append('('); backtrack(sb, open + 1, close, n); sb.deleteCharAt(sb.length() - 1); } if (close < open) { sb.append(')'); backtrack(sb, open, close + 1, n); sb.deleteCharAt(sb.length() - 1); } }}
[!info] 复杂度 时间 O(4ⁿ/√n)（卡特兰数），空间 O(n)。
[!warning] 易错点
close < open 是合法性的核心：右括号必须匹配一个已放的左括号。写成 close < n 会生成 )( 这种非法串。
graph LR A["每个格子作起点"] --> B["DFS 匹配 word[k]"] B --> C{"匹配?"} C -- 是 --> D["标记 # "] D --> E["四向 DFS k+1"] E --> F["恢复原字符 撤销"] F --> G{"任一方向成功?"} C -- 否 --> H["回退 false"] G -- 是 --> I["返回 true"] G -- 否 --> H
class Solution { public boolean exist(char[][] board, String word) { int m = board.length, n = board[0].length; for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) if (dfs(board, word, i, j, 0)) return true; return false; } boolean dfs(char[][] b, String w, int i, int j, int k) { if (k == w.length()) return true; // 匹配完 if (i<0||i>=b.length||j<0||j>=b[0].length||b[i][j]!=w.charAt(k)) return false; char t = b[i][j]; b[i][j] = '#'; // 标记 boolean f = dfs(b,w,i+1,j,k+1)||dfs(b,w,i-1,j,k+1) ||dfs(b,w,i,j+1,k+1)||dfs(b,w,i,j-1,k+1); b[i][j] = t; // 撤销 return f; }}
graph LR A["逐行 row"] --> B["枚举列 col"] B --> C{"不冲突?"} C -- 是 --> D["放 Q"] D --> E["递归 row+1"] E --> F["撤销, 放 ."] F --> B C -- 否 --> B E --> G{"row == n?"} G -- 是 --> H["收集棋盘"]
class Solution { List<List<String>> res = new ArrayList<>(); public List<List<String>> solveNQueens(int n) { char[][] b = new char[n][n]; for (char[] r : b) Arrays.fill(r, '.'); backtrack(b, 0); return res; } void backtrack(char[][] b, int row) { if (row == b.length) { res.add(build(b)); return; } for (int col = 0; col < b.length; col++) { if (!valid(b, row, col)) continue; b[row][col] = 'Q'; backtrack(b, row + 1); b[row][col] = '.'; // 撤销 } } boolean valid(char[][] b, int r, int c) { for (int i = 0; i < r; i++) if (b[i][c] == 'Q') return false; // 同列 for (int i=r-1,j=c-1; i>=0&&j>=0; i--,j--) if (b[i][j]=='Q') return false; // 左上对角 for (int i=r-1,j=c+1; i>=0&&j<b.length; i--,j++) if (b[i][j]=='Q') return false; // 右上对角 return true; } List<String> build(char[][] b) { List<String> l = new ArrayList<>(); for (char[] r : b) l.add(new String(r)); return l; }}
[!info] 复杂度 时间 O(n!)（每行可选列递减），空间 O(n)。
[!tip] 优化
用三个 Set 记录"已占列、主对角(row−col)、副对角(row+col)"，valid 降到 O(1)。对角线用 row−col、row+col 作 key 是经典技巧。
[!tip] 套路
N 皇后是回溯的"集大成者"：选位置→递归→撤销，加上约束剪枝。掌握它，[[#37. 解数独]]、[[#52. N 皇后 II]] 都是同模板。
思路脉络：标准精确二分。找不到时，l 正好停在该插入的位置——因为循环结束时 l == r + 1，l 指向第一个大于 target 的位置。
class Solution { public int searchInsert(int[] nums, int target) { int l = 0, r = nums.length - 1; while (l <= r) { int m = (l + r) / 2; if (nums[m] == target) return m; else if (nums[m] < target) l = m + 1; else r = m - 1; } return l; // 插入位置 }}
[!info] 复杂度 时间 O(log n)，空间 O(1)。
[!tip] 套路
这题是"左界"二分的简化版。把"找到返回"去掉，return l 就是">= target 的第一个位置"，正是插入位置。
class Solution { public boolean searchMatrix(int[][] matrix, int target) { int m = matrix.length, n = matrix[0].length; int l = 0, r = m * n - 1; while (l <= r) { int mid = (l + r) / 2; int v = matrix[mid / n][mid % n]; // 一维下标转二维 if (v == target) return true; else if (v < target) l = mid + 1; else r = mid - 1; } return false; }}
graph LR A["二分找左界"] --> B{"nums[m] == t?"} B -- 是 --> C["ans=m, r=m-1 往左压"] B -- "<t" --> D["l=m+1"] B -- ">t" --> E["r=m-1"] C --> A D --> A E --> A
class Solution { public int[] searchRange(int[] nums, int target) { return new int[]{findLeft(nums, target), findRight(nums, target)}; } int findLeft(int[] a, int t) { int l = 0, r = a.length - 1, ans = -1; while (l <= r) { int m = (l + r) / 2; if (a[m] == t) { ans = m; r = m - 1; } // 命中往左压 else if (a[m] < t) l = m + 1; else r = m - 1; } return ans; } int findRight(int[] a, int t) { int l = 0, r = a.length - 1, ans = -1; while (l <= r) { int m = (l + r) / 2; if (a[m] == t) { ans = m; l = m + 1; } // 命中往右压 else if (a[m] < t) l = m + 1; else r = m - 1; } return ans; }}
graph LR A["取 mid"] --> B{"nums[l] ≤ nums[m]?"} B -- 是, 左半有序 --> C{"target 在左半?"} C -- 是 --> D["r=mid-1"] C -- 否 --> E["l=mid+1"] B -- 否, 右半有序 --> F{"target 在右半?"} F -- 是 --> E F -- 否 --> D
class Solution { public int search(int[] nums, int target) { int l = 0, r = nums.length - 1; while (l <= r) { int m = (l + r) / 2; if (nums[m] == target) return m; if (nums[l] <= nums[m]) { // 左半有序 if (nums[l] <= target && target < nums[m]) r = m - 1; else l = m + 1; } else { // 右半有序 if (nums[m] < target && target <= nums[r]) l = m + 1; else r = m - 1; } } return -1; }}
思路脉络：和 right 比。nums[m] > nums[r] 说明最小值在 mid 右侧（左半都比 nums[r] 大，不是最小）；否则最小值在 mid 或左侧。注意循环用 l < r，收缩 r = m（不是 m - 1），因为 mid 本身可能是最小值。
class Solution { public int findMin(int[] nums) { int l = 0, r = nums.length - 1; while (l < r) { int m = (l + r) / 2; if (nums[m] > nums[r]) l = m + 1; // 最小在右半 else r = m; // 最小在 m 或左半 } return nums[l]; // l == r 即最小 }}
[!info] 复杂度 时间 O(log n)，空间 O(1)。
[!warning] 易错点
和 right 比而不是 left：和 left 比无法区分"未旋转"和"旋转后最小在右"。r = m 不减一，因为 mid 可能就是答案。
graph LR A["二分 a 的切点 i"] --> B["j = half - i"] B --> C["aL,aR,bL,bR"] C --> D{"aL ≤ bR 且 bL ≤ aR?"} D -- 是 --> E["合法划分, 算中位数"] D -- "aL>bR" --> F["hi=i-1"] D -- "bL>aR" --> G["lo=i+1"] F --> A G --> A
class Solution { public double findMedianSortedArrays(int[] a, int[] b) { if (a.length > b.length) return findMedianSortedArrays(b, a); // 保证 a 短 int m = a.length, n = b.length, half = (m + n + 1) / 2; int lo = 0, hi = m; while (lo <= hi) { int i = (lo + hi) / 2, j = half - i; int aL = i == 0 ? Integer.MIN_VALUE : a[i - 1]; int aR = i == m ? Integer.MAX_VALUE : a[i]; int bL = j == 0 ? Integer.MIN_VALUE : b[j - 1]; int bR = j == n ? Integer.MAX_VALUE : b[j]; if (aL <= bR && bL <= aR) { if ((m + n) % 2 == 1) return Math.max(aL, bL); return (Math.max(aL, bL) + Math.min(aR, bR)) / 2.0; } else if (aL > bR) hi = i - 1; else lo = i + 1; } return 0; }}
[!info] 复杂度 时间 O(log(min(m,n)))，空间 O(1)。
[!warning] 易错点
必须在短数组上二分：否则 j = half - i 可能越界（长数组切太多导致 j 为负）。开头的 swap 保证 a 短。
边界用 ±∞：i==0 时 aL 取 MIN_VALUE，保证 max(aL,bL) 永远是另一边的真实值。漏了会数组越界。
class Solution { public boolean isValid(String s) { Map<Character, Character> m = Map.of(')', '(', ']', '[', '}', '{'); Deque<Character> st = new ArrayDeque<>(); for (char c : s.toCharArray()) { if (!m.containsKey(c)) st.push(c); // 左括号入栈 else if (st.isEmpty() || st.pop() != m.get(c)) return false; // 右括号配对 } return st.isEmpty(); // 栈空才合法 }}
[!info] 复杂度 时间 O(n)，空间 O(n)。
[!warning] 易错点
右括号配对前先判栈空：形如 ] 开头，栈空直接 pop 会异常。st.pop() != m.get(c) 复用短路，但前面要先查 isEmpty。
155. 最小栈
栈支持 push/pop/top/getMin 全 O(1)。
思路脉络：单栈无法 O(1) 取最小。辅助栈 minSt 同步压栈，每步记录"当前栈内最小值"。pop 时两栈同步弹。空间 O(n)。
class MinStack { Deque<Integer> st = new ArrayDeque<>(), minSt = new ArrayDeque<>(); public MinStack() { minSt.push(Integer.MAX_VALUE); } public void push(int v) { st.push(v); minSt.push(Math.min(minSt.peek(), v)); } public void pop() { st.pop(); minSt.pop(); } public int top() { return st.peek(); } public int getMin() { return minSt.peek(); }}
graph LR A["遍历字符"] --> B{"类型?"} B -- 数字 --> C["攒成完整数"] B -- 字母 --> D["拼到 cur"] B -- "[ " --> E["压栈 cur, num; 重置"] B -- "]" --> F["弹出 prev, k; cur=prev+cur×k"]
class Solution { public String decodeString(String s) { Deque<String> strSt = new ArrayDeque<>(); Deque<Integer> numSt = new ArrayDeque<>(); StringBuilder cur = new StringBuilder(); int num = 0; for (char c : s.toCharArray()) { if (Character.isDigit(c)) num = num * 10 + (c - '0'); else if (c == '[') { strSt.push(cur.toString()); numSt.push(num); cur = new StringBuilder(); num = 0; } else if (c == ']') { int k = numSt.pop(); StringBuilder prev = new StringBuilder(strSt.pop()); for (int i = 0; i < k; i++) prev.append(cur); cur = prev; } else cur.append(c); } return cur.toString(); }}
[!info] 复杂度 时间 O(输出长度)，空间 O(嵌套深度)。
[!warning] 易错点
数字可能多位（如 12[a]），必须 num*10 + c-'0' 攒完整数。[ 时重置 num=0 和 cur，] 时用 prev 包裹 cur 重复 k 次。
graph LR A["遍历 i, t"] --> B{"栈非空且 t > 栈顶温度?"} B -- 是 --> C["弹 top, ans=top = i - top"] C --> B B -- 否 --> D["i 入栈"] D --> A
class Solution { public int[] dailyTemperatures(int[] T) { int n = T.length, res[] = new int[n]; Deque<Integer> st = new ArrayDeque<>(); for (int i = 0; i < n; i++) { while (!st.isEmpty() && T[i] > T[st.peek()]) { int top = st.pop(); res[top] = i - top; } st.push(i); } return res; }}
graph LR A["遍历 i, h"] --> B{"栈非空且 h < 栈顶高?"} B -- 是 --> C["弹 top 作高"] C --> D["宽 = i - 新栈顶 - 1"] D --> E["算面积更新答案"] E --> B B -- 否 --> F["i 入栈"] F --> A
class Solution { public int largestRectangleArea(int[] heights) { int n = heights.length, ans = 0; int[] h = new int[n + 2]; // 左右加 0 哨兵 System.arraycopy(heights, 0, h, 1, n); Deque<Integer> st = new ArrayDeque<>(); for (int i = 0; i < h.length; i++) { while (!st.isEmpty() && h[i] < h[st.peek()]) { int height = h[st.pop()]; int width = i - st.peek() - 1; // 新栈顶是左边界 ans = Math.max(ans, height * width); } st.push(i); } return ans; }}
class Solution { public int findKthLargest(int[] nums, int k) { k = nums.length - k; // 第 K 大 = 升序第 (n-k) 个 int l = 0, r = nums.length - 1; while (l < r) { int p = partition(nums, l, r); if (p == k) return nums[p]; else if (p < k) l = p + 1; else r = p - 1; } return nums[l]; } int partition(int[] a, int l, int r) { int pivot = a[r], i = l; for (int j = l; j < r; j++) if (a[j] <= pivot) swap(a, i++, j); swap(a, i, r); return i; } void swap(int[] a, int i, int j) { int t = a[i]; a[i] = a[j]; a[j] = t; }}
[!info] 复杂度 时间 O(n) 期望，空间 O(1)。
[!tip] 辨析
"第 K 大"转成"升序第 (n−K) 个"是关键转换，让快选的索引语义清晰。面试求 O(n) 必用快选，求简单可用小顶堆。
347. 前 K 个高频元素
返回出现频率前 K 高的元素。
思路脉络：先统计频率（哈希），再取前 K。取前 K 用小顶堆：堆大小 K，按频率建堆，频率比堆顶高才入。最后堆里就是前 K 高。
class Solution { public int[] topKFrequent(int[] nums, int k) { Map<Integer, Integer> freq = new HashMap<>(); for (int n : nums) freq.merge(n, 1, Integer::sum); PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> freq.get(a) - freq.get(b)); // 小顶堆按频率 for (int key : freq.keySet()) { pq.offer(key); if (pq.size() > k) pq.poll(); // 超过 K 弹最小的 } int[] res = new int[k]; for (int i = 0; i < k; i++) res[i] = pq.poll(); return res; }}
[!info] 复杂度 时间 O(n log K)，空间 O(n)。
[!tip] 套路
"Top-K 频率"标准两步：哈希计数 + 小顶堆截断。堆大小恒为 K 是精髓——超出就弹最小，最终堆里是前 K 大。桶排序能做 O(n)，但堆更通用。
295. 数据流的中位数
数据流动态加入数字，随时能取中位数。addNum/findMedian 平均 O(log n)。
思路脉络：单有序结构取中位数 O(1) 但插入 O(n)。用两个堆：大顶堆 lo 装较小的一半（堆顶是这半的最大）、小顶堆 hi 装较大的一半（堆顶是这半的最小）。平衡两堆规模差 ≤1，中位数由两堆顶决定。
加入逻辑：先入 lo，把 lo 最大推到 hi，再若 lo 比 hi 少则从 hi 回补一个。保证 lo.size >= hi.size。
graph LR A["加入 num"] --> B["先入大顶堆 lo"] B --> C["lo 最大 → 小顶堆 hi"] C --> D{"lo 比 hi 少?"} D -- 是 --> E["hi 最小 → lo"] D -- 否 --> F["平衡完成"] E --> F F --> G["中位数 = lo 顶 或 两顶平均"]
class MedianFinder { PriorityQueue<Integer> lo = new PriorityQueue<>(Collections.reverseOrder()); // 大顶堆 PriorityQueue<Integer> hi = new PriorityQueue<>(); // 小顶堆 public void addNum(int num) { lo.offer(num); hi.offer(lo.poll()); // lo 最大给 hi if (lo.size() < hi.size()) lo.offer(hi.poll()); // 平衡: hi 回补 lo } public double findMedian() { return lo.size() > hi.size() ? lo.peek() : (lo.peek() + hi.peek()) / 2.0; }}
[!info] 复杂度 addNum O(log n)，findMedian O(1)。
[!warning] 易错点
平衡方向：保证 lo.size >= hi.size，奇数时中位数取 lo.peek。若反过来保证 hi 多，奇数取 hi.peek，要和 findMedian 一致。lo.poll() 给 hi 这步保证"小半的最大 ≤ 大半的最小"的不变量。
class Solution { public int maxProfit(int[] prices) { int minPrice = Integer.MAX_VALUE, ans = 0; for (int p : prices) { minPrice = Math.min(minPrice, p); ans = Math.max(ans, p - minPrice); } return ans; }}
思路脉络：维护"当前能到达的最远位置" maxReach。遍历时若 i > maxReach 说明走不到这里，返回 false；否则更新 maxReach = max(maxReach, i + nums[i])，能覆盖末尾即 true。
graph LR A["遍历 i"] --> B{"i > maxReach?"} B -- 是 --> C["走不到, false"] B -- 否 --> D["maxReach = max(maxReach, i+nums[i])"] D --> E{"maxReach ≥ 末尾?"} E -- 是 --> F["true"] E -- 否 --> A
class Solution { public boolean canJump(int[] nums) { int maxReach = 0; for (int i = 0; i < nums.length; i++) { if (i > maxReach) return false; maxReach = Math.max(maxReach, i + nums[i]); } return true; }}
[!info] 复杂度 时间 O(n)，空间 O(1)。
[!warning] 易错点
判断 i > maxReach 要在更新之前：先确认当前位置可达，才能从这里继续跳。漏判会误把不可达当可达。
graph LR A["l=0,r=0,步数=0"] --> B["扫 l..r 算 nextMax"] B --> C["步数++, l=r+1, r=nextMax"] C --> D{"r ≥ 末尾?"} D -- 是 --> E["返回步数"] D -- 否 --> B
class Solution { public int jump(int[] nums) { int steps = 0, l = 0, r = 0; while (r < nums.length - 1) { int nextMax = 0; for (int i = l; i <= r; i++) nextMax = Math.max(nextMax, i + nums[i]); l = r + 1; r = nextMax; steps++; } return steps; }}
思路脉络：每个字母最后一次出现的位置是该段必须延伸到的下限。遍历时维护"当前段的最远边界" end = max(end, last[c])，当 i == end 时说明当前段所有字母都已在段内，可切。
class Solution { public List<Integer> partitionLabels(String s) { int[] last = new int[26]; for (int i = 0; i < s.length(); i++) last[s.charAt(i) - 'a'] = i; // 记录每个字母最后位置 List<Integer> res = new ArrayList<>(); int start = 0, end = 0; for (int i = 0; i < s.length(); i++) { end = Math.max(end, last[s.charAt(i) - 'a']); if (i == end) { res.add(i - start + 1); start = i + 1; } // 可切 } return res; }}
[!info] 复杂度 时间 O(n)，空间 O(1)。
[!tip] 套路
"区间合并/分割"用"最远边界"统一处理：[[#56. 合并区间]] 按 end 排序后取 max，本题按 last 取 max。核心都是"用一个边界变量吸收所有约束"。
class Solution { public int climbStairs(int n) { if (n <= 2) return n; int a = 1, b = 2; for (int i = 3; i <= n; i++) { int c = a + b; a = b; b = c; } return b; }}
class Solution { public List<List<Integer>> generate(int n) { List<List<Integer>> res = new ArrayList<>(); for (int i = 0; i < n; i++) { List<Integer> row = new ArrayList<>(); for (int j = 0; j <= i; j++) { if (j == 0 || j == i) row.add(1); else row.add(res.get(i - 1).get(j - 1) + res.get(i - 1).get(j)); } res.add(row); } return res; }}
[!info] 复杂度 时间 O(n²)，空间 O(n²)。
198. 打家劫舍
偷一排房子，相邻不能同偷，求最大金额。
思路脉络：dp[i] = 前 i 间能偷的最大金额。偷第 i 间则不能偷 i−1：dp[i] = dp[i-2] + nums[i]；不偷则 dp[i] = dp[i-1]。取大者。
class Solution { public int rob(int[] nums) { int prev2 = 0, prev1 = 0; for (int n : nums) { int cur = Math.max(prev1, prev2 + n); prev2 = prev1; prev1 = cur; } return prev1; }}
graph LR A["遍历 num"] --> B["二分找 tails 中第一个 ≥ num 的位置 p"] B --> C["tails[p] = num"] C --> D["LIS 长度 = tails.length"] D --> A
class Solution { public int lengthOfLIS(int[] nums) { int[] tails = new int[nums.length]; int len = 0; for (int num : nums) { int l = 0, r = len; while (l < r) { // 找第一个 ≥ num int m = (l + r) / 2; if (tails[m] < num) l = m + 1; else r = m; } tails[l] = num; if (l == len) len++; } return len; }}
class Solution { public int maxProduct(int[] nums) { int maxP = nums[0], minP = nums[0], ans = nums[0]; for (int i = 1; i < nums.length; i++) { int n = nums[i]; if (n < 0) { int t = maxP; maxP = minP; minP = t; } // 负数翻转 maxP = Math.max(n, maxP * n); minP = Math.min(n, minP * n); ans = Math.max(ans, maxP); } return ans; }}
思路脉络：总和 sum 奇数则不行。偶数则问"能否挑若干元素凑成 sum/2"——0-1 背包。dp[i] = 能否凑出和 i。每来一个数，从大到小更新（0-1 背包逆序，保证每个用一次）。
class Solution { public boolean canPartition(int[] nums) { int sum = 0; for (int n : nums) sum += n; if (sum % 2 != 0) return false; int target = sum / 2; boolean[] dp = new boolean[target + 1]; dp[0] = true; for (int n : nums) for (int i = target; i >= n; i--) // 逆序, 0-1 背包 dp[i] = dp[i] || dp[i - n]; return dp[target]; }}
class Solution { public int uniquePaths(int m, int n) { int[] dp = new int[n]; Arrays.fill(dp, 1); for (int i = 1; i < m; i++) for (int j = 1; j < n; j++) dp[j] += dp[j - 1]; // dp[j]=上, dp[j-1]=左 return dp[n - 1]; }}
class Solution { public int minPathSum(int[][] grid) { int m = grid.length, n = grid[0].length; for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) { if (i == 0 && j == 0) continue; else if (i == 0) grid[i][j] += grid[i][j - 1]; else if (j == 0) grid[i][j] += grid[i - 1][j]; else grid[i][j] += Math.min(grid[i - 1][j], grid[i][j - 1]); } return grid[m - 1][n - 1]; }}
graph LR A["每个中心 i"] --> B["奇数: 从 i 向两侧扩"] A --> C["偶数: 从 i,i+1 向两侧扩"] B --> D["记录最长起止"] C --> D D --> E["返回最长子串"]
class Solution { public String longestPalindrome(String s) { int st = 0, max = 1; for (int i = 0; i < s.length(); i++) { int l1 = expand(s, i, i), l2 = expand(s, i, i + 1); int len = Math.max(l1, l2); if (len > max) { max = len; st = i - (len - 1) / 2; } } return s.substring(st, st + max); } int expand(String s, int l, int r) { while (l >= 0 && r < s.length() && s.charAt(l) == s.charAt(r)) { l--; r++; } return r - l - 1; // 扩过头了, 回退一步的真实长度 }}
[!info] 复杂度 时间 O(n²)，空间 O(1)。
[!warning] 易错点
expand 返回 r - l - 1：循环退出时 l、r 已是不匹配的位置，真实回文是 (l+1, r-1)，长度 r-1 - (l+1) + 1 = r - l - 1。起点 i - (len-1)/2 对奇偶都成立。
[!example] 二维 DP 表逐格填充（动图） ab→abc：先填边界(全删/全增)，再逐格推。字符相同取左上 dp[i-1][j-1]；不同取左/上/左上三者 min+1。dp[2][3]=1：末尾增一个 c 即可。
graph LR A["dp[i][j]"] --> B{"w1[i-1]==w2[j-1]?"} B -- 是 --> C["dp[i-1][j-1]"] B -- 否 --> D["删 dp[i-1][j]+1"] B -- 否 --> E["增 dp[i][j-1]+1"] B -- 否 --> F["改 dp[i-1][j-1]+1"] D --> G["三者取 min"] E --> G F --> G
class Solution { public int minDistance(String w1, String w2) { int m = w1.length(), n = w2.length(); int[][] dp = new int[m + 1][n + 1]; for (int i = 0; i <= m; i++) dp[i][0] = i; for (int j = 0; j <= n; j++) dp[0][j] = j; for (int i = 1; i <= m; i++) for (int j = 1; j <= n; j++) { if (w1.charAt(i - 1) == w2.charAt(j - 1)) dp[i][j] = dp[i - 1][j - 1]; else dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i - 1][j], dp[i][j - 1])) + 1; } return dp[m][n]; }}
graph LR A["遍历 n"] --> B{"n == 候选?"} B -- 是 --> C["count++"] B -- 否 --> D["count--"] D --> E{"count==0?"} E -- 是 --> F["换候选 = n, count=1"] E -- 否 --> A C --> A F --> A
class Solution { public int majorityElement(int[] nums) { int cand = 0, cnt = 0; for (int n : nums) { if (cnt == 0) { cand = n; cnt = 1; } else if (n == cand) cnt++; else cnt--; } return cand; }}
[!example] 荷兰国旗三指针（动图） 三区随扫描成型：[0,l) 全 0、[l,i) 全 1、(r,n) 全 2。遇 2 换到 r 后 i 不动是关键——换回的值还没判断；遇 0 换到 l 后 i++ 安全。
graph LR A["i 扫描"] --> B{"nums[i]?"} B -- 0 --> C["与 l 交换, l++, i++"] B -- 1 --> D["i++"] B -- 2 --> E["与 r 交换, r--"] E --> F["i 不动, 看换回来的"] F --> B
class Solution { public void sortColors(int[] nums) { int l = 0, r = nums.length - 1, i = 0; while (i <= r) { if (nums[i] == 0) { swap(nums, i++, l++); } else if (nums[i] == 2) { swap(nums, i, r--); } // i 不动 else i++; } } void swap(int[] a, int i, int j) { int t = a[i]; a[i] = a[j]; a[j] = t; }}
[!info] 复杂度 时间 O(n)，空间 O(1)。
[!warning] 易错点
换 2 后 i 不自增：从 r 换回来的可能是 0/1/2 任意值，得重新判断。换 0 后 i++ 安全，因为换到 i 的是 l 位置（l <= i，那里已是 1 或就是 i 自己）。
31. 下一个排列
把数组重排成字典序的下一个排列，没有更大排列就升序。
思路脉络：四步法，每步都有依据：
从右找第一个"降序对" i（nums[i] < nums[i+1]）——这是能变大的最低位。
从右找第一个比 nums[i] 大的 j——这是比原数大的最小替换。
交换 i、j。
反转 i+1 到末尾——降序变升序，让后缀最小。
graph LR A["从右找降序对 i"] --> B{"找到?"} B -- 否 --> C["整体反转(最小排列)"] B -- 是 --> D["从右找 >nums[i] 的 j"] D --> E["交换 i,j"] E --> F["反转 i+1..末尾"]
class Solution { public void nextPermutation(int[] nums) { int n = nums.length, i = n - 2; while (i >= 0 && nums[i] >= nums[i + 1]) i--; // 找降序对 if (i >= 0) { int j = n - 1; while (nums[j] <= nums[i]) j--; // 找比 nums[i] 大的 swap(nums, i, j); } reverse(nums, i + 1, n - 1); // 反转后缀 } void swap(int[] a, int i, int j) { int t = a[i]; a[i] = a[j]; a[j] = t; } void reverse(int[] a, int l, int r) { while (l < r) swap(a, l++, r--); }}
[!info] 复杂度 时间 O(n)，空间 O(1)。
[!warning] 易错点
找 i 用 >=（要严格降序对的左端，跳过相等的）；找 j 用 <=（要严格大于 nums[i]）。两个比较符号方向别搞反。
class Solution { /** * 因为题目说链表节点值是不重复的，所以可以用HashSet存储数组中元素，便于查询 * flag 变量表示当前元素是否属于某个集合，true: 当前元素属于某个集合（组件）， false: 不属于某个集合（组件） * @param head * @param nums * @return */ public int numComponents(ListNode head, int[] nums) { Set<Integer> set = new HashSet<>(); for (int num : nums) { set.add(num); } boolean flag = false; int ans = 0; while (head != null) { if (!set.contains(head.val)) { flag = false; } if (set.contains(head.val) && !flag) { ans++; flag = true; } head = head.next; } return ans; }}
