Jotaro Space
算法题目类型索引
JotaroRD
  2026-08-10 00:00:00   2026-09-04 18:20:23  

算法题目类型与相关题目索引

目录

总览

类型 专题数 题目条目数
精选题解 4 12
数据结构 116 443
动态规划 128 543
图论 130 451
数学 169 403
字符串 63 164
搜索 15 23
位运算 37 119
基础算法 26 76
离线算法 1 2
模拟与构造 2 6
通用思维与技巧 88 660
交互题 10 65
测试与随机化 5 15
杂项 23 35

精选题解

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
1400 CF1790E 数学综合 位运算恒等式 有 main/README.md:35
1800 CF1922E 手玩题（构造、思维） 反向构造+递增子序列 有 main/README.md:9
1900 CF452D 动态规划 状态设计 有 main/README.md:18
1900 CF1054D 手玩题（构造、思维） 正难则反 有 main/README.md:11
1900 CF1914F 手玩题（构造、思维） 树上贪心 有 main/README.md:10
1900 CF1921F 数据结构 带权前缀和+根号算法 有 main/README.md:28
2000 CF1733D2 动态规划 状态设计 有 main/README.md:19
2100 CF1913D 动态规划 单调栈+前缀和优化 DP 有 main/README.md:20
2500 CF1327F 动态规划 状态设计+滑窗优化 有 main/README.md:21
2500 CF1665E 手玩题（构造、思维） 从特殊到一般 有 main/README.md:12
2600 CF1237F 动态规划 计数 DP 有 main/README.md:22
2700 CF1730E 数据结构 单调栈 有 main/README.md:29

数据结构

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
1200 CF1076A 字典序最小 只能删一个 remove-k-digits 有 copypasta/monotone_stack.go:71
1200 CF1730C 字典序最小 remove-k-digits 有 copypasta/monotone_stack.go:72
1300 CF755C 另见 graph.go 中的 MST 有 copypasta/union_find.go:40
1300 CF1736C1 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） guess-number-higher-or-lower-ii
find-maximum-non-decreasing-array-length		 有 copypasta/monotone_queue.go:34
1374 CF1374E2 其它题目 代码 https://codeforces.com/contest//submission/193671570 有 copypasta/heap.go:400
1400 CF1167C 另见 graph.go 中的 MST copypasta/union_find.go:41
1400 CF1905C 字典序最小 remove-k-digits 有 copypasta/monotone_stack.go:73
1500 CF91B 单调栈二分 find-building-where-alice-and-bob-can-meet
maximum-sum-queries		 有 copypasta/monotone_stack.go:64
1500 CF190C 栈的应用 有 copypasta/stack.go:15
1500 CF1106D 第 K 小/大（值/和） 有 copypasta/heap.go:24
1500 CF1765N 字典序最小 remove-k-digits 有 copypasta/monotone_stack.go:70
1500 CF1791F 经典模型是一维区间覆盖染色，通过倒序+并查集解决 sum-of-matrix-after-queries 有 copypasta/union_find.go:85
1500 CF1883D 懒删除堆 max-stack
most-frequent-ids		 有 copypasta/heap.go:213
1500 CF1898B 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） guess-number-higher-or-lower-ii
find-maximum-non-decreasing-array-length		 有 copypasta/monotone_queue.go:33
1500 CF1915F 模板题 range-sum-query-mutable copypasta/fenwick_tree.go:27
1500 CF1985F 模拟 time-to-cross-a-bridge 有 copypasta/heap.go:34
1500 CF2060E 另见 graph.go 中的 MST 有 copypasta/union_find.go:42
1600 CF1041C 经典模型是一维区间覆盖染色，通过倒序+并查集解决 sum-of-matrix-after-queries copypasta/union_find.go:86
1600 CF1140C 第 K 小/大（值/和） 有 copypasta/heap.go:25
1600 CF1234D 模板题 range-sum-query-mutable 有 copypasta/fenwick_tree.go:28
1600 CF1526C2 基于堆的反悔贪心（反悔堆） 有 copypasta/heap.go:80
1600 CF1779C 基于堆的反悔贪心（反悔堆） 前缀和 推荐 有 copypasta/heap.go:81
1600 CF1862E 第 K 小/大（值/和） 有 copypasta/heap.go:27
1600 CF1886C 字典序最小的无重复字符的子序列，包含原串所有字符 remove-duplicate-letters 有 copypasta/monotone_stack.go:384
1600 CF1941E 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） 造桥 入门题 guess-number-higher-or-lower-ii
find-maximum-non-decreasing-array-length		 有 copypasta/monotone_queue.go:35
1600 CF2046B 字典序最小 remove-k-digits 有 copypasta/monotone_stack.go:74
1600 CF2171F 这一结论可以用于思考一些双变量的题目 给定排列 p，构造一棵树，满足每条边的 pos[小端] < pos[大端] next-greater-element-iv 有 copypasta/monotone_stack.go:45
1632 CF650C 树+点权/边权的顺序 LC https://leetcode.cn/problems/rank-transform-of-a-matrix/submissions/ rank-transform-of-a-matrix 有 copypasta/union_find.go:116
1700 CF627B 模板题 模板题 range-sum-query-mutable 有 copypasta/fenwick_tree.go:29
1700 CF631C 这一结论可以用于思考一些双变量的题目 next-greater-element-iv 有 copypasta/monotone_stack.go:46
1700 CF827A 经典模型是一维区间覆盖染色，通过倒序+并查集解决 sum-of-matrix-after-queries 有 copypasta/union_find.go:87
1700 CF1157E 经典模型是一维区间覆盖染色，通过倒序+并查集解决 sum-of-matrix-after-queries 有 copypasta/union_find.go:88
1700 CF1207F 注意：枚举时要做到不重不漏 实际难度 you-le-yuan-de-you-lan-ji-hua
xor-after-range-multiplication-queries-ii		 有 copypasta/sqrt_decomposition.go:31
1700 CF1209D 另见 graph.go 中的 MST 有 copypasta/union_find.go:43
1700 CF1411C 另见 graph.go 中的 MST 有 copypasta/union_find.go:44
1700 CF1413D Lazy 思想在其他数据结构中的应用 已知进货+买最小的顺序，检查是否合法 有 copypasta/segment_tree.go:435
1700 CF1594D 那么就可以推出 2->4 的距离为 (1->3) + (3->4) - (1->2) 种类并查集 有 copypasta/union_find.go:544
1700 CF1709D st[i][j] 对应的区间是 [i, i+2^j) 有 copypasta/sparse_table.go:24
1700 CF1850H 那么就可以推出 2->4 的距离为 (1->3) + (3->4) - (1->2) 有 copypasta/union_find.go:536
1700 CF2050F 《算法竞赛进阶指南》0x43 和 0x48 节 GCD 有 copypasta/segment_tree.go:31
1700 CF2050F st[i][j] 对应的区间是 [i, i+2^j) GCD 有 copypasta/sparse_table.go:25
1800 CF280B 这一结论可以用于思考一些双变量的题目 转换 next-greater-element-iv 有 copypasta/monotone_stack.go:47
1800 CF371D 另见 graph.go 中的 MST 有 copypasta/union_find.go:45
1800 CF371D 区间并查集 / 涂色并查集 / 刷墙并查集 经典题 minimum-interval-to-include-each-query
amount-of-new-area-painted-each-day		 有 copypasta/union_find.go:292
1800 CF652D 模板题 区间包含计数 有 copypasta/fenwick_tree.go:31
1800 CF911D 归并做法见 misc.go 中的 mergeCount shu-zu-zhong-de-ni-xu-dui-lcof 有 copypasta/fenwick_tree.go:525
1800 CF986B 归并做法见 misc.go 中的 mergeCount copypasta/fenwick_tree.go:526
1800 CF1042D EXTRA: 权值线段树 值域线段树 有 copypasta/segment_tree.go:125
1800 CF1227D2 另见 union_find.go 中的「可持久化并查集」 用在线算法解决 有 copypasta/segment_tree.go:908
1800 CF1548B st[i][j] 对应的区间是 [i, i+2^j) GCD 有 copypasta/sparse_table.go:26
1800 CF1691D 这一结论可以用于思考一些双变量的题目 max >= sum 有 copypasta/monotone_stack.go:48
1800 CF1870D 字典序最小 remove-k-digits 有 copypasta/monotone_stack.go:75
1800 CF1935C 第 K 小/大（值/和） 有 copypasta/heap.go:29
1800 CF2020D 区间并查集 / 涂色并查集 / 刷墙并查集 minimum-interval-to-include-each-query
amount-of-new-area-painted-each-day		 有 copypasta/union_find.go:293
1900 CF6E 单调队列求最值等 copypasta/monotone_queue.go:63
1900 CF61E 归并做法见 misc.go 中的 mergeCount 三元逆序对 有 copypasta/fenwick_tree.go:527
1900 CF292E 一般情况可以用于区间更新单点查询 代码 https://codeforces.com/contest/292/submission/173666674 range-module
falling-squares		 有 copypasta/odt_bst.go:12
1900 CF292E 【单个更新操作】 单点查询的简化写法 有 copypasta/segment_tree.go:365
1900 CF362C 归并做法见 misc.go 中的 mergeCount 扩展 有 copypasta/fenwick_tree.go:528
1900 CF597C 模板题 长为 k 的上升子序列个数 有 copypasta/fenwick_tree.go:33
1900 CF724D 经典模型是一维区间覆盖染色，通过倒序+并查集解决 sum-of-matrix-after-queries 有 copypasta/union_find.go:89
1900 CF724D 区间并查集 / 涂色并查集 / 刷墙并查集 minimum-interval-to-include-each-query
amount-of-new-area-painted-each-day		 有 copypasta/union_find.go:294
1900 CF796C 懒删除堆 max-stack
most-frequent-ids		 有 copypasta/heap.go:214
1900 CF817D 贡献法（计算所有子数组的……的和） sum-of-subarray-minimums
sum-of-subarray-ranges		 有 copypasta/monotone_stack.go:83
1900 CF914D 《算法竞赛进阶指南》0x43 和 0x48 节 GCD 有 copypasta/segment_tree.go:32
1900 CF926E f[i][j] 表示前 i 颗行星，向右的质量之和为 j 时，向左的质量之和的最小值 难度虚高 robot-collisions 有 copypasta/stack.go:10
1900 CF961E 模板题 （不止一种做法） 有 copypasta/fenwick_tree.go:34
1900 CF961E 另见 union_find.go 中的「可持久化并查集」 用在线算法解决（一边读入一边计算答案） 有 copypasta/segment_tree.go:909
1900 CF1208D 【单个更新操作】 copypasta/segment_tree.go:347
1900 CF1313C2 单调栈优化 DP beautiful-towers-ii 有 copypasta/monotone_stack.go:95
1900 CF1430E 归并做法见 misc.go 中的 mergeCount reverse 有 copypasta/fenwick_tree.go:529
1900 CF1585D 归并做法见 misc.go 中的 mergeCount 有 copypasta/fenwick_tree.go:530
1900 CF1777D 另见单调栈 monotone_stack.go 有 copypasta/cartesian_tree.go:11
1900 CF1899G 一边从小到大枚举 x，一边更新【值域树状数组】，一边回答离线后的询问 maximum-area-rectangle-with-point-constraints-ii 有 copypasta/fenwick_tree.go:222
1900 CF1918D 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） find-maximum-non-decreasing-array-length 有 copypasta/monotone_queue.go:36
1900 CF1921F 注意：枚举时要做到不重不漏 you-le-yuan-de-you-lan-ji-hua
xor-after-range-multiplication-queries-ii		 有 copypasta/sqrt_decomposition.go:32
1900 CF1969D 动态维护最大的 k 个数用最小堆，动态维护最小的 k 个数用最大堆 有 copypasta/heap.go:20
1900 CF2001D 字典序最小 有 copypasta/monotone_stack.go:76
1900 CF2001D 字典序最小的无重复字符的子序列，包含原串所有字符 remove-duplicate-letters 有 copypasta/monotone_stack.go:385
1900 CF2042D 模板题 有 copypasta/fenwick_tree.go:35
1900 CF2117G 另见 graph.go 中的 MST 枚举大，维护小 有 copypasta/union_find.go:46
2000 CF380C 《算法竞赛进阶指南》0x43 和 0x48 节 区间最长括号子序列 有 copypasta/segment_tree.go:33
2000 CF383C = (m+1)∑diff[i] - ∑i*diff[i] 有 copypasta/fenwick_tree.go:285
2000 CF474E 《算法竞赛进阶指南》0x43 和 0x48 节 最值及其下标 有 copypasta/segment_tree.go:34
2000 CF487B 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） 有 copypasta/monotone_queue.go:37
2000 CF522D 《算法竞赛进阶指南》0x43 和 0x48 节 区间最短线段长度 有 copypasta/segment_tree.go:35
2000 CF629D 模板题 有 copypasta/fenwick_tree.go:37
2000 CF730I 基于堆的反悔贪心（反悔堆） 有 copypasta/heap.go:82
2000 CF730I 模拟费用流 有 copypasta/heap.go:103
2000 CF766D 那么就可以推出 2->4 的距离为 (1->3) + (3->4) - (1->2) 种类并查集 有 copypasta/union_find.go:545
2000 CF797E 注意：枚举时要做到不重不漏 you-le-yuan-de-you-lan-ji-hua
xor-after-range-multiplication-queries-ii		 有 copypasta/sqrt_decomposition.go:33
2000 CF899E 懒删除堆 max-stack
most-frequent-ids		 有 copypasta/heap.go:215
2000 CF899E 模拟双向链表 有 copypasta/monotone_stack.go:355
2000 CF899E 经典模型是一维区间覆盖染色，通过倒序+并查集解决 也可以用双向链表 sum-of-matrix-after-queries 有 copypasta/union_find.go:90
2000 CF920F 《算法竞赛进阶指南》0x43 和 0x48 节 开方（也可以用并查集做） 有 copypasta/segment_tree.go:36
2000 CF940E 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） 有 copypasta/monotone_queue.go:38
2000 CF1237D 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） 有 copypasta/monotone_queue.go:39
2000 CF1288E 模板题 转化 有 copypasta/fenwick_tree.go:38
2000 CF1321E 【单个更新操作】 有 copypasta/segment_tree.go:348
2000 CF1514D 《算法竞赛进阶指南》0x43 和 0x48 节 区间绝对众数及其次数（摩尔投票算法） copypasta/segment_tree.go:39
2000 CF1726D 另见 graph.go 中的 MST 处理图上的环 有 copypasta/union_find.go:47
2000 CF1851G 另见 graph.go 中的 MST 离线 有 copypasta/union_find.go:48
2000 CF1881G 【单个更新操作】 不含任何长度 >= 2 的回文串 copypasta/segment_tree.go:367
2000 CF1891F 模板题 离线 树 回溯 有 copypasta/fenwick_tree.go:39
2000 CF1974G 基于堆的反悔贪心（反悔堆） 有 copypasta/heap.go:84
2100 CF103D 注意：枚举时要做到不重不漏 you-le-yuan-de-you-lan-ji-hua
xor-after-range-multiplication-queries-ii		 copypasta/sqrt_decomposition.go:34
2100 CF165D 模板题 copypasta/fenwick_tree.go:40
2100 CF455C 树+点权/边权的顺序 有 copypasta/union_find.go:113
2100 CF540E 归并做法见 misc.go 中的 mergeCount 1e9 范围逆序对 copypasta/fenwick_tree.go:531
2100 CF620E 【单个更新操作】 有 copypasta/segment_tree.go:368
2100 CF620E 另见 union_find.go 中的「可持久化并查集」 种类数 有 copypasta/segment_tree.go:910
2100 CF689D st[i][j] 对应的区间是 [i, i+2^j) 二分/三指针 有 copypasta/sparse_table.go:27
2100 CF703D 模板题 区间元素去重后的异或和 有 copypasta/fenwick_tree.go:41
2100 CF703D 《算法竞赛进阶指南》0x43 和 0x48 节 区间元素去重后的异或和 majority-element
online-majority-element-in-subarray		 有 copypasta/segment_tree.go:44
2100 CF912D 思维·转换 贡献 trapping-rain-water-ii
minimum-cost-to-hire-k-workers		 copypasta/heap.go:44
2100 CF1077F2 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） 有 copypasta/monotone_queue.go:40
2100 CF1158C 2. 横着累加：见单调栈的做法（找上一个更大元素，在找的过程中填坑） collecting-chocolates 有 copypasta/monotone_stack.go:111
2100 CF1195E 输入：高 h 宽 w 的窗口大小 copypasta/monotone_queue.go:261
2100 CF1216F 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） copypasta/monotone_queue.go:41
2100 CF1483C 单调栈优化 DP 结合线段树，或者巧妙地在单调栈中去维护最值 beautiful-towers-ii 有 copypasta/monotone_stack.go:96
2100 CF1660F2 模板题 建模 有 copypasta/fenwick_tree.go:43
2100 CF1667B 模板题 有 copypasta/fenwick_tree.go:44
2100 CF1790F 自动 O(n√n) 有 copypasta/sqrt_decomposition.go:64
2100 CF1913D 单调栈优化 DP beautiful-towers-ii 有 copypasta/monotone_stack.go:97
2100 CF1919D 这一结论可以用于思考一些双变量的题目 结论 有 copypasta/monotone_stack.go:49
2200 CF52C 【单个更新操作】 有 copypasta/segment_tree.go:349
2200 CF301D 模板题 整除对统计 有 copypasta/fenwick_tree.go:45
2200 CF369E 模板题 区间统计技巧 有 copypasta/fenwick_tree.go:46
2200 CF538F 另见 union_find.go 中的「可持久化并查集」 二维数点 copypasta/segment_tree.go:911
2200 CF617E 注 2：为防止块大小为 0，代码中要取 ceil(n/√m) 有 copypasta/mo.go:54
2200 CF762E 模板题 离散化 有 copypasta/fenwick_tree.go:47
2200 CF875D 2. 横着累加：见单调栈的做法（找上一个更大元素，在找的过程中填坑） collecting-chocolates 有 copypasta/monotone_stack.go:112
2200 CF1045G 模板题 同 762E 有 copypasta/fenwick_tree.go:48
2200 CF1179C 《算法竞赛进阶指南》0x43 和 0x48 节 online-majority-element-in-subarray 有 copypasta/segment_tree.go:47
2200 CF1181D 另见 union_find.go 中的「可持久化并查集」 做法不止一种 有 copypasta/segment_tree.go:912
2200 CF1194E 模板题 多变量统计 有 copypasta/fenwick_tree.go:49
2200 CF1196F 第 K 小/大（值/和） 有 copypasta/heap.go:30
2200 CF1295E 【单个更新操作】 有 copypasta/segment_tree.go:370
2200 CF1407D 单调栈优化 DP beautiful-towers-ii 有 copypasta/monotone_stack.go:99
2200 CF1428E 基于堆的反悔贪心（反悔堆） 用堆来不断修正最优决策 有 copypasta/heap.go:86
2200 CF1557D 【单个更新操作】 max max 离散化 有 copypasta/segment_tree.go:371
2200 CF1557D 动态开点线段树·其二·延迟标记（区间修改） （内存受限） 有 copypasta/segment_tree.go:668
2200 CF1567E 《算法竞赛进阶指南》0x43 和 0x48 节 区间连续递增子数组个数 todo majority-element
online-majority-element-in-subarray		 copypasta/segment_tree.go:46
2200 CF1580C 注意：枚举时要做到不重不漏 you-le-yuan-de-you-lan-ji-hua
xor-after-range-multiplication-queries-ii		 copypasta/sqrt_decomposition.go:35
2200 CF1615D 那么就可以推出 2->4 的距离为 (1->3) + (3->4) - (1->2) copypasta/union_find.go:546
2200 CF1806E 这样，以 √n 为界，我们将所有对象划分成了两组，并用两个不同的算法处理 有 copypasta/sqrt_decomposition.go:23
2200 CF1806E 注意：枚举时要做到不重不漏 xor-after-range-multiplication-queries-ii 有 copypasta/sqrt_decomposition.go:36
2200 CF1906F 《算法竞赛进阶指南》0x43 和 0x48 节 最大子数组和（非空） 离线 有 copypasta/segment_tree.go:48
2200 CF1968G2 注意：枚举时要做到不重不漏 也可以直接记忆化 有 copypasta/sqrt_decomposition.go:37
2200 CF2000H 基于 295E 的性能测试： maximum-number-of-jumps-to-reach-the-last-index
maximum-sum-queries		 有 copypasta/segment_tree.go:600
2200 CF2009G2 懒删除堆 max-stack
most-frequent-ids		 有 copypasta/heap.go:216
2200 CF2009G2 单调栈二分 find-building-where-alice-and-bob-can-meet
maximum-sum-queries		 有 copypasta/monotone_stack.go:65
2200 CF2018D 经典模型是一维区间覆盖染色，通过倒序+并查集解决 copypasta/union_find.go:91
2200 CF2065H 模板题 copypasta/fenwick_tree.go:50
2200 CF2101C 用来求 <= x 的最大剩余元素 有 copypasta/union_find.go:80
2200 CF2143D2 模板题 有 copypasta/fenwick_tree.go:51
2300 CF85D 本质上属于笛卡尔树，见 cartesian_tree.go 较为复杂的维护 copypasta/treap.go:26
2300 CF87D 另见 graph.go 中的 MST 有 copypasta/union_find.go:49
2300 CF87D 树+点权/边权的顺序 number-of-good-paths 有 copypasta/union_find.go:99
2300 CF425D 注意：枚举时要做到不重不漏 有 copypasta/sqrt_decomposition.go:38
2300 CF438D 《算法竞赛进阶指南》0x43 和 0x48 节 取模 有 copypasta/segment_tree.go:49
2300 CF558E 一般情况可以用于区间更新单点查询 代码 https://codeforces.com/problemset/submission/558/117163317 range-module
falling-squares		 有 copypasta/odt_bst.go:13
2300 CF558E 【单个更新操作】 有 copypasta/segment_tree.go:361
2300 CF628E 模板题 Z 形状个数 有 copypasta/fenwick_tree.go:52
2300 CF677D 注意：枚举时要做到不重不漏 有 copypasta/sqrt_decomposition.go:39
2300 CF713C 思维·转换 使序列严格递增的最小操作次数 (+1/-1) trapping-rain-water-ii
minimum-cost-to-hire-k-workers		 有 copypasta/heap.go:45
2300 CF718C 【单个更新操作】 矩阵乘法 ∑ 有 copypasta/segment_tree.go:373
2300 CF786B 这个性质可以用于优化建图 有 copypasta/segment_tree.go:145
2300 CF803G 动态开点线段树·其二·延迟标记（区间修改） copypasta/segment_tree.go:669
2300 CF817F 一般情况可以用于区间更新单点查询 （数据水）代码 https://codeforces.com/contest/817/submission/118365591 range-module
falling-squares		 copypasta/odt_bst.go:14
2300 CF884D 思维·转换 从结果倒推（类似霍夫曼编码） minimum-cost-to-hire-k-workers 有 copypasta/heap.go:48
2300 CF893F 另见 union_find.go 中的「可持久化并查集」 树 时间戳 有 copypasta/segment_tree.go:913
2300 CF915E 一般情况可以用于区间更新单点查询 代码【比较全面】https://codeforces.com/problemset/submission/915/117158161 range-module
falling-squares		 有 copypasta/odt_bst.go:15
2300 CF915E 动态开点线段树·其二·延迟标记（区间修改） （注：此题有多种解法） 有 copypasta/segment_tree.go:670
2300 CF1093G 《算法竞赛进阶指南》0x43 和 0x48 节 k 维曼哈顿（单点修改+区间最大值） 有 copypasta/segment_tree.go:50
2300 CF1096F 归并做法见 misc.go 中的 mergeCount 扩展：某些位置上的数待定时的逆序对的期望值 copypasta/fenwick_tree.go:532
2300 CF1167F 模板题 max-black-square-lcci 有 copypasta/fenwick_tree.go:54
2300 CF1404C 这里每个叶子 t[i] 表示 i 的个数 有 copypasta/fenwick_tree.go:153
2300 CF1468M 注意：枚举时要做到不重不漏 或四元环 有 copypasta/sqrt_decomposition.go:40
2300 CF1584E 应用见 graph.go 中的 01 最短路 单调双端队列 有 copypasta/deque.go:9
2300 CF1584E 其他单调队列 有 copypasta/monotone_queue.go:66
2300 CF1654E 注意：枚举时要做到不重不漏 copypasta/sqrt_decomposition.go:41
2300 CF1797E 【单个更新操作】 phi* copypasta/segment_tree.go:374
2300 CF1849E 这一结论可以用于思考一些双变量的题目 思想类似启发式合并 copypasta/monotone_stack.go:50
2300 CF1967C 模板题 max-black-square-lcci copypasta/fenwick_tree.go:55
2400 CF5E 这一结论可以用于思考一些双变量的题目 number-of-good-paths
number-of-visible-people-in-a-queue		 有 copypasta/monotone_stack.go:40
2400 CF5E 单调栈优化 DP beautiful-towers-ii 有 copypasta/monotone_stack.go:100
2400 CF12D 模板题 三维偏序 max-black-square-lcci 有 copypasta/fenwick_tree.go:56
2400 CF115E 【单个更新操作】 DP 有 copypasta/segment_tree.go:375
2400 CF121E 【单个更新操作】 特殊的 update，有时候会退化成单点更新 有 copypasta/segment_tree.go:376
2400 CF145E 【单个更新操作】 有 copypasta/segment_tree.go:377
2400 CF145E 某些情况下可作为 Bitset 的替代品 handling-sum-queries-after-update 有 copypasta/segment_tree01.go:13
2400 CF220E 归并做法见 misc.go 中的 mergeCount 前缀+后缀 有 copypasta/fenwick_tree.go:533
2400 CF246E 模板题 max-black-square-lcci 有 copypasta/fenwick_tree.go:57
2400 CF246E 静态区间种类 - 离线做法 有 copypasta/fenwick_tree.go:80
2400 CF258E 矩形面积并（离散化+扫描线） 转化 rectangle-area-ii
separate-squares-ii		 有 copypasta/segment_tree_rect.go:15
2400 CF258E sumLen -= t[1].minCoverLen 转化 有 copypasta/segment_tree_rect.go:147
2400 CF323C 另见 union_find.go 中的「可持久化并查集」 二维数点 有 copypasta/segment_tree.go:914
2400 CF342E 注意：枚举时要做到不重不漏 有 copypasta/sqrt_decomposition.go:42
2400 CF377D 【单个更新操作】 有 copypasta/segment_tree.go:378
2400 CF444C 分块数据结构 DZY Loves Colors 经典题 有 copypasta/sqrt_decomposition.go:96
2400 CF446C 线段树二分 https://gemini.google.com/app/62b7bb3403b692db 往上翻 t3fKg1
subarrays-distinct-element-sum-of-squares-ii		 有 copypasta/segment_tree.go:406
2400 CF446C 【单个更新操作】 斐波那契数列 广义斐波那契数列 https://gemini.google.com/app/62b7bb3403b692db 往上翻 有 copypasta/segment_tree.go:379
2400 CF498D 《算法竞赛进阶指南》0x43 和 0x48 节 有 copypasta/segment_tree.go:51
2400 CF506D 注意：枚举时要做到不重不漏 有 copypasta/sqrt_decomposition.go:43
2400 CF506D 哈希表并查集 most-stones-removed-with-same-row-or-column 有 copypasta/union_find.go:255
2400 CF524E 《算法竞赛进阶指南》0x43 和 0x48 节 扫描线 有 copypasta/segment_tree.go:52
2400 CF593D 另见 graph.go 中的 MST 单边修改，输出 floor(val / 路径边权乘积) 有 copypasta/union_find.go:50
2400 CF749E 归并做法见 misc.go 中的 mergeCount 期望 贡献 有 copypasta/fenwick_tree.go:534
2400 CF767E 基于堆的反悔贪心（反悔堆） Change-free 有 copypasta/heap.go:88
2400 CF786C 另见 union_find.go 中的「可持久化并查集」 有 copypasta/segment_tree.go:915
2400 CF786C 注意：枚举时要做到不重不漏 见下面的 floorDivide 有 copypasta/sqrt_decomposition.go:44
2400 CF813E 另见 union_find.go 中的「可持久化并查集」 差分 有 copypasta/segment_tree.go:916
2400 CF865D 基于堆的反悔贪心（反悔堆） 股票买卖 有 copypasta/heap.go:89
2400 CF869E 二维差分树状数组 有 copypasta/fenwick_tree.go:376
2400 CF916E = (m+1)∑diff[i] - ∑i*diff[i] 有 copypasta/fenwick_tree.go:286
2400 CF939F 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） 状态设计 有 copypasta/monotone_queue.go:42
2400 CF990G 另见 graph.go 中的 MST 有 copypasta/union_find.go:51
2400 CF1000F 另见 union_find.go 中的「可持久化并查集」 有 copypasta/segment_tree.go:917
2400 CF1074D 那么就可以推出 2->4 的距离为 (1->3) + (3->4) - (1->2) ? 1700! 有 copypasta/union_find.go:537
2400 CF1080F 另见 union_find.go 中的「可持久化并查集」 强制在线 有 copypasta/segment_tree.go:918
2400 CF1093E 二维树状数组 第一维度分块，把空间复杂度从 O(n^2) 降至 O(n^2 / B) 有 copypasta/fenwick_tree.go:333
2400 CF1093E 动态二维数点 也可以分块 有 copypasta/seg_in_bit.go:12
2400 CF1093E 分块数据结构 动态二维数点 也可以树套树 有 copypasta/sqrt_decomposition.go:97
2400 CF1107G 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） 有 copypasta/monotone_queue.go:43
2400 CF1114F 【单个更新操作】 有 copypasta/segment_tree.go:380
2400 CF1132G 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） 有 copypasta/monotone_queue.go:44
2400 CF1132G 另见 graph.go 中的 MST 有 copypasta/union_find.go:52
2400 CF1132G 经典模型是一维区间覆盖染色，通过倒序+并查集解决 有 copypasta/union_find.go:92
2400 CF1137D LC142. 环形链表 II 有 copypasta/linked_list.go:13
2400 CF1147D 那么就可以推出 2->4 的距离为 (1->3) + (3->4) - (1->2) 种类并查集 有 copypasta/union_find.go:547
2400 CF1166F 另见 graph.go 中的 MST 有 copypasta/union_find.go:53
2400 CF1187D 《算法竞赛进阶指南》0x43 和 0x48 节 转换的好题 有 copypasta/segment_tree.go:53
2400 CF1221F 【单个更新操作】 正方形覆盖点 技巧：把加点转化成加区间 有 copypasta/segment_tree.go:381
2400 CF1251E2 思维·转换 有 copypasta/heap.go:49
2400 CF1290C 那么就可以推出 2->4 的距离为 (1->3) + (3->4) - (1->2) 种类并查集 + 维护集合大小 有 copypasta/union_find.go:548
2400 CF1304F2 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） 有 copypasta/monotone_queue.go:45
2400 CF1326E 《算法竞赛进阶指南》0x43 和 0x48 节 有 copypasta/segment_tree.go:54
2400 CF1401E 模板题 线段把矩形分割成多少块 max-black-square-lcci 有 copypasta/fenwick_tree.go:58
2400 CF1401F 《算法竞赛进阶指南》0x43 和 0x48 节 区间 swap & reverse 有 copypasta/segment_tree.go:55
2400 CF1436E 联想 reverse bit 的递归思路 所有子数组的 mex 的 mex 有 copypasta/segment_tree.go:57
2400 CF1609E 在线做法是可持久化线段树（维护元素上一次出现的位置，以及区间 min） 单点修改 + 不含子序列 abc 有 copypasta/segment_tree.go:64
2400 CF1619H 注意：枚举时要做到不重不漏 大步+小步，有点分段打表的味道 copypasta/sqrt_decomposition.go:45
2400 CF1638E 一般情况可以用于区间更新单点查询 Colorful Operations 结合树状数组 falling-squares 有 copypasta/odt_bst.go:16
2400 CF1638E 【单个更新操作】 Colorful Operations 有 copypasta/segment_tree.go:382
2400 CF1713E 那么就可以推出 2->4 的距离为 (1->3) + (3->4) - (1->2) 转化 有 copypasta/union_find.go:549
2400 CF1732D2 懒删除堆 简化版懒删除堆 max-stack
most-frequent-ids		 有 copypasta/heap.go:217
2400 CF1736C2 这一结论可以用于思考一些双变量的题目 用的是队列，但思路是一样的 number-of-visible-people-in-a-queue
next-greater-element-iv		 有 copypasta/monotone_stack.go:43
2400 CF1736C2 如果没有，那么结果为 n 用的是队列，但思路是一样的 next-greater-element-iv
next-greater-element-iv		 有 copypasta/monotone_stack.go:285
2400 CF1750E 贡献法（计算所有子数组的……的和） 所有括号子串变成平衡的最小操作次数总和 sum-of-subarray-ranges
maximum-subarray-min-product		 有 copypasta/monotone_stack.go:86
2400 CF1827B2 这一结论可以用于思考一些双变量的题目 Range Sorting number-of-visible-people-in-a-queue
next-greater-element-iv		 有 copypasta/monotone_stack.go:44
2400 CF1827B2 贡献法（计算所有子数组的……的和） Range Sorting 双单调栈 sum-of-subarray-ranges
maximum-subarray-min-product		 有 copypasta/monotone_stack.go:87
2400 CF1852C 基于堆的反悔贪心（反悔堆） 差分思想 有 copypasta/heap.go:90
2400 CF1905E 趣味研究：∑ 叶子子集的 LCA 有 copypasta/segment_tree.go:210
2400 CF1969E 【单个更新操作】 有 copypasta/segment_tree.go:383
2400 CF2171H 模板题 max-black-square-lcci 有 copypasta/fenwick_tree.go:59
2500 CF60D 另见 graph.go 中的 MST 有 copypasta/union_find.go:54
2500 CF266E 【单个更新操作】 k 次幂带权前缀和 有 copypasta/segment_tree.go:384
2500 CF295E 在线做法是可持久化线段树（维护元素上一次出现的位置，以及区间 min） 难度虚高 有 copypasta/segment_tree.go:65
2500 CF341D 二维差分树状数组 XOR 区间更新 区间查询 有 copypasta/fenwick_tree.go:377
2500 CF348C 注意：枚举时要做到不重不漏 有 copypasta/sqrt_decomposition.go:46
2500 CF484E 另见 union_find.go 中的「可持久化并查集」 二分，转换成找最长的已填入数字的区间，做法类似最大子段和 有 copypasta/segment_tree.go:919
2500 CF551E 分块数据结构 GukiZ and GukiZiana Go1.22 推荐块大小为 sqrt(n/5)，比 sqrt(n) 快一倍 有 copypasta/sqrt_decomposition.go:98
2500 CF594D 模板题 有 copypasta/fenwick_tree.go:60
2500 CF594D 静态区间种类 - 离线做法 有 copypasta/fenwick_tree.go:81
2500 CF605D 线段树二分 booking-concert-tickets-in-groups
find-building-where-alice-and-bob-can-meet		 有 copypasta/segment_tree.go:119
2500 CF609F 本质上属于笛卡尔树，见 cartesian_tree.go copypasta/treap.go:27
2500 CF618E 【单个更新操作】 旋转 http://poj.org/problem?id=2991 有 copypasta/segment_tree.go:385
2500 CF706E 模拟链表 copypasta/linked_list.go:7
2500 CF739C 【单个更新操作】 形状设计 有 copypasta/segment_tree.go:386
2500 CF837G 另见 union_find.go 中的「可持久化并查集」 copypasta/segment_tree.go:920
2500 CF840D 另见 union_find.go 中的「可持久化并查集」 区间出现次数大于 区间长度/k 的最小元素 有 copypasta/segment_tree.go:921
2500 CF911G 基于 295E 的性能测试： merge move maximum-number-of-jumps-to-reach-the-last-index
maximum-sum-queries		 有 copypasta/segment_tree.go:602
2500 CF911G 注意：枚举时要做到不重不漏 攒够 B 个询问才执行一次处理 有 copypasta/sqrt_decomposition.go:47
2500 CF963D 且支持动态修改 s[i] 有 copypasta/bitset.go:383
2500 CF981G 一般情况可以用于区间更新单点查询 copypasta/odt_bst.go:17
2500 CF992E 模板题 Nastya and King-Shamans si <= sj * 2，这个不等式至多成立 O(log U) 次 有 copypasta/fenwick_tree.go:61
2500 CF992E 这里每个叶子 t[i] 表示 i 的个数 有 copypasta/fenwick_tree.go:154
2500 CF1030F 这里每个叶子 t[i] 表示 i 的个数 有 copypasta/fenwick_tree.go:155
2500 CF1037F 贡献法（计算所有子数组的……的和） sum-of-subarray-ranges
maximum-subarray-min-product		 有 copypasta/monotone_stack.go:88
2500 CF1107G st[i][j] 对应的区间是 [i, i+2^j) 有 copypasta/sparse_table.go:28
2500 CF1117G 这一结论可以用于思考一些双变量的题目 最大子数组和 copypasta/monotone_stack.go:51
2500 CF1175F 其他单调队列 copypasta/monotone_queue.go:67
2500 CF1253F 另见 graph.go 中的 MST 启发式合并 有 copypasta/union_find.go:55
2500 CF1301E 二维 ST 表 有 copypasta/sparse_table.go:172
2500 CF1334F 模板题 有 copypasta/fenwick_tree.go:62
2500 CF1559D2 另见 graph.go 中的 MST 构造 有 copypasta/union_find.go:56
2500 CF1665E 在线做法是可持久化线段树（维护元素上一次出现的位置，以及区间 min） 区间最小的 31 个数 有 copypasta/segment_tree.go:66
2500 CF1687C 区间并查集 / 涂色并查集 / 刷墙并查集 BFS minimum-interval-to-include-each-query
amount-of-new-area-painted-each-day		 有 copypasta/union_find.go:295
2500 CF1701F 【单个更新操作】 状态设计 有 copypasta/segment_tree.go:387
2500 CF1771F 另见 union_find.go 中的「可持久化并查集」 异或哈希 element-appearing-more-than-25-in-sorted-array 有 copypasta/segment_tree.go:923
2500 CF1771F 动态开点主席树 代码 https://codeforces.com/contest/1771/submission/245657179 有 copypasta/segment_tree.go:1108
2500 CF1788F 那么就可以推出 2->4 的距离为 (1->3) + (3->4) - (1->2) 有 copypasta/union_find.go:550
2500 CF1840G2 随机+分块 有 copypasta/sqrt_decomposition.go:67
2500 CF1876D 另见 graph.go 中的 MST copypasta/union_find.go:57
2500 CF1903F 这个性质可以用于优化建图 copypasta/segment_tree.go:146
2500 CF1945G 模拟 time-to-cross-a-bridge copypasta/heap.go:35
2500 CF2117H 在线做法是可持久化线段树（维护元素上一次出现的位置，以及区间 min） copypasta/segment_tree.go:67
2600 CF3D 基于堆的反悔贪心（反悔堆） 难度虚高 有 copypasta/heap.go:91
2600 CF240F 【单个更新操作】 有 copypasta/segment_tree.go:388
2600 CF436E 基于堆的反悔贪心（反悔堆） copypasta/heap.go:92
2600 CF797F 基于堆的反悔贪心（反悔堆） course-schedule-iii
minimum-total-distance-traveled		 有 copypasta/heap.go:74
2600 CF797F 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） 有 copypasta/monotone_queue.go:46
2600 CF1110F 【单个更新操作】 有 copypasta/segment_tree.go:350
2600 CF1140F 适用于包含三类操作的题目：添加 删除 查询 copypasta/segment_tree.go:826
2600 CF1270F 注意：枚举时要做到不重不漏 有 copypasta/sqrt_decomposition.go:48
2600 CF1416D 树+点权/边权的顺序 DSU 重构树 gcd-sort-of-an-array 有 copypasta/union_find.go:123
2600 CF1439C 【单个更新操作】 =max 求和的 O(log^2) 性质 有 copypasta/segment_tree.go:389
2600 CF1580B 另见单调栈 monotone_stack.go 思想 有 copypasta/cartesian_tree.go:12
2600 CF1614E 【单个更新操作】 有 copypasta/segment_tree.go:390
2600 CF1614E 基于 295E 的性能测试： todo maximum-number-of-jumps-to-reach-the-last-index
maximum-sum-queries		 有 copypasta/segment_tree.go:603
2600 CF1793F 在线做法是可持久化线段树（维护元素上一次出现的位置，以及区间 min） 和 CF765F 是同一题 有 copypasta/segment_tree.go:73
2600 CF1827C 这一结论可以用于思考一些双变量的题目 Manacher DP 有 copypasta/monotone_stack.go:52
2600 CF2042F 在线做法是可持久化线段树（维护元素上一次出现的位置，以及区间 min） 两段最大子段和 有 copypasta/segment_tree.go:68
2600 CF2064F 这一结论可以用于思考一些双变量的题目 copypasta/monotone_stack.go:53
2600 CF2173F 注意：枚举时要做到不重不漏 copypasta/sqrt_decomposition.go:49
2700 CF13E 分块数据结构 有 copypasta/sqrt_decomposition.go:99
2700 CF444E 另见 graph.go 中的 MST 最大化 min_{路径} 路径边权最大值 有 copypasta/union_find.go:58
2700 CF455D 分块数据结构 copypasta/sqrt_decomposition.go:100
2700 CF780G 在线做法是可持久化线段树（维护元素上一次出现的位置，以及区间 min） 栈 有 copypasta/segment_tree.go:69
2700 CF827D 经典模型是一维区间覆盖染色，通过倒序+并查集解决 有 copypasta/union_find.go:93
2700 CF827D 区间并查集 / 涂色并查集 / 刷墙并查集 amount-of-new-area-painted-each-day 有 copypasta/union_find.go:296
2700 CF1422E 这一结论可以用于思考一些双变量的题目 有 copypasta/monotone_stack.go:54
2700 CF1730E 贡献法（计算所有子数组的……的和） 最大值是最小值的倍数 maximum-subarray-min-product 有 copypasta/monotone_stack.go:89
2700 CF2009G3 【单个更新操作】 copypasta/segment_tree.go:391
2700 CF2026F 用两个最小栈底对底 离线可持久化 有 copypasta/deque_min.go:40
2700 CF2104G 适用于包含三类操作的题目：添加 删除 查询 copypasta/segment_tree.go:827
2800 CF19D 在线做法是可持久化线段树（维护元素上一次出现的位置，以及区间 min） copypasta/segment_tree.go:70
2800 CF19D 树状数组套动态开点权值线段树（AC） range-sum-query-2d-mutable copypasta/segment_tree.go:139
2800 CF280D 在线做法是可持久化线段树（维护元素上一次出现的位置，以及区间 min） copypasta/segment_tree.go:71
2800 CF280D 如果一个题目可以用分治解决，那么这个题目的带修改版本可以用线段树解决 用网络流的思想「反悔」 longest-substring-of-one-repeating-character copypasta/segment_tree.go:89
2800 CF377E 注意 last 的位置在队首左边，需要注意是否小于左边界（或者保证区间长度至少为 2） copypasta/monotone_queue.go:47
2800 CF547E 另见 union_find.go 中的「可持久化并查集」 上联：AC 自动机 fail 树 DFS 序建可持久化线段树（用树状数组也可以） element-appearing-more-than-25-in-sorted-array 有 copypasta/segment_tree.go:924
2800 CF601E 适用于包含三类操作的题目：添加 删除 查询 入门题 有 copypasta/segment_tree.go:828
2800 CF794F 【单个更新操作】 数位修改 考察对懒标记的理解 有 copypasta/segment_tree.go:392
2800 CF1039D 注意：枚举时要做到不重不漏 copypasta/sqrt_decomposition.go:50
2800 CF1635F 模板题 有 copypasta/fenwick_tree.go:63
2800 CF2069F 适用于包含三类操作的题目：添加 删除 查询 copypasta/segment_tree.go:829
2900 CF505E 维护最小 pi 可以用最小堆 有 copypasta/heap.go:53
2900 CF938G 适用于包含三类操作的题目：添加 删除 查询 copypasta/segment_tree.go:830
3000 CF464E 另见 union_find.go 中的「可持久化并查集」 最短路 element-appearing-more-than-25-in-sorted-array copypasta/segment_tree.go:925
3000 CF914F 统计 [l,r) 中的 1 的个数 有 copypasta/bitset.go:171
3000 CF914F 且支持动态修改 s[i] 有 copypasta/bitset.go:384
3000 CF2043G 分块数据结构 copypasta/sqrt_decomposition.go:101
3100 CF765F 在线做法是可持久化线段树（维护元素上一次出现的位置，以及区间 min） 最小差值 有 copypasta/segment_tree.go:72
3200 CF482E TIPS: 对于卡常的题目，用 findRoot 判断连通性的逻辑可以用并查集代替 动态修改 + 任意两点 LCA 的权值的期望 copypasta/link_cut_tree.go:26
3200 CF1209G2 【单个更新操作】 todo copypasta/segment_tree.go:393
3200 CF1446F 模板题 copypasta/fenwick_tree.go:64
3400 CF1039E 注意：枚举时要做到不重不漏 copypasta/sqrt_decomposition.go:51
CF33D 有时候也可以用 big.Int 代替 （也可以用 LCA） copypasta/bitset.go:18
CF44G k-d tree: k-dimensional tree; k 维树 copypasta/kd_tree.go:14
CF69E EXTRA: 权值线段树 值域线段树 有 copypasta/segment_tree.go:126
CF86D 注 2：为防止块大小为 0，代码中要取 ceil(n/√m) 有 copypasta/mo.go:53
CF91E 分块数据结构 copypasta/sqrt_decomposition.go:92
CF220B 注 2：为防止块大小为 0，代码中要取 ceil(n/√m) 有 copypasta/mo.go:48
CF292D 树+点权/边权的顺序 trapping-rain-water-ii 有 copypasta/union_find.go:107
CF371D 树+点权/边权的顺序 number-of-good-paths 有 copypasta/union_find.go:103
CF372C 滑动窗口最值（固定区间大小的区间最值） （另一种做法是用堆） sliding-window-maximum 有 copypasta/monotone_queue.go:114
CF375D 注 2：为防止块大小为 0，代码中要取 ceil(n/√m) 有 copypasta/mo.go:46
CF455D 替罪羊树 copypasta/scapegoat_tree.go:21
CF487B 对每个右端点，求最远的左端点，满足这一区间内的最大值减最小值不超过 limit 有 copypasta/monotone_queue.go:183
CF543D 括号匹配/有效括号 minimum-number-of-swaps-to-make-the-string-balanced
check-if-a-parentheses-string-can-be-valid		 有 copypasta/stack.go:24
CF547B EXTRA: 求所有长为 i 的子区间的最小值的最大值 有 copypasta/monotone_stack.go:260
CF555B 最小不相交区间划分数 有 copypasta/heap.go:111
CF558E t.put1(l, r, val) 有 copypasta/odt_bst.go:55
CF566D 树+点权/边权的顺序 trapping-rain-water-ii 有 copypasta/union_find.go:108
CF600E EXTRA: 线段树合并 有 copypasta/segment_tree.go:763
CF629D 树状数组的性质能使其支持动态 [1,x] 或 [x,n] 范围上的最值更新查询等操作 有 copypasta/fenwick_tree.go:86
CF675E 下标版本，查询返回的是区间最值的下标 有 copypasta/sparse_table.go:76
CF702F 伸展树 splay tree range-xor-queries-with-subarray-reversals
finding-mk-average		 copypasta/splay.go:21
CF706E 十字链表 copypasta/linked_list.go:16
CF754D 最小不相交区间划分数 有 copypasta/heap.go:112
CF786C 时间复杂度类似整除分块 O(f(n)√n) 有 copypasta/sqrt_decomposition.go:158
CF797F 在有多个相同转移来源 f[j] 的情况下，保证 a[j] 最大的在队首 有 copypasta/monotone_queue.go:58
CF845C 会议室 有 copypasta/heap.go:64
CF845C 最小不相交区间划分数 有 copypasta/heap.go:110
CF859E 树+点权/边权的顺序 有 copypasta/union_find.go:115
CF877E 某些情况下可作为 Bitset 的替代品 handling-sum-queries-after-update 有 copypasta/segment_tree01.go:12
CF877F 注 2：为防止块大小为 0，代码中要取 ceil(n/√m) copypasta/mo.go:55
CF884E 树+点权/边权的顺序 rank-transform-of-a-matrix
gcd-sort-of-an-array		 copypasta/union_find.go:122
CF891C 可撤销并查集 回滚并查集 有 copypasta/union_find.go:702
CF896C 这里用 slice 实现 O(nlogn) 有 copypasta/odt.go:8
CF914F 右移 k 位 有 copypasta/bitset.go:281
CF915F 树+点权/边权的顺序 number-of-good-paths 有 copypasta/union_find.go:100
CF940E 滑动窗口最值（固定区间大小的区间最值） sliding-window-maximum 有 copypasta/monotone_queue.go:113
CF940F 带修莫队（支持单点修改） 有 copypasta/mo.go:126
CF962D 哈希表：支持插入和删除，并能够按照插入顺序遍历哈希表中的元素 时有感而发 有 copypasta/orderedset.go:6
CF990G 带时间戳的写法，适用于需要频繁初始化小并查集的场景 有 copypasta/union_find.go:149
CF992E 返回第 k 小的数（k 从 1 开始） 有 copypasta/fenwick_tree.go:186
CF1000F 栈的应用 有 copypasta/stack.go:14
CF1012B 树+点权/边权的顺序 有 copypasta/union_find.go:111
CF1092D1 栈的应用 有 copypasta/stack.go:16
CF1092D2 栈的应用 有 copypasta/stack.go:17
CF1106E 调用 remove(p.hi) 可以从堆中删除 p 有 copypasta/heap.go:191
CF1107D 判断 [l,r] 范围内的数是否全为 0 （标准做法是二维前缀和） 有 copypasta/bitset.go:131
CF1156E 算完 perm[i] 后把 perm[i] 从链表中删掉 有 copypasta/monotone_stack.go:318
CF1175G 用来维护在平面直角坐标系上的线段关系，常用于斜率优化的题目 copypasta/segment_tree.go:1126
CF1194E 树状数组的性质能使其支持动态 [1,x] 或 [x,n] 范围上的最值更新查询等操作 有 copypasta/fenwick_tree.go:89
CF1208E 滑动窗口最值（固定区间大小的区间最值） sliding-window-maximum 有 copypasta/monotone_queue.go:115
CF1217F 可撤销并查集 回滚并查集 copypasta/union_find.go:703
CF1237D 枚举区间左端点更为方便的情况 · 其二 有 copypasta/monotone_queue.go:232
CF1253D 树+点权/边权的顺序 rank-transform-of-a-matrix
gcd-sort-of-an-array		 有 copypasta/union_find.go:119
CF1303G 用来维护在平面直角坐标系上的线段关系，常用于斜率优化的题目 copypasta/segment_tree.go:1127
CF1466F 树+点权/边权的顺序 copypasta/union_find.go:112
CF1476G 带修莫队（支持单点修改） copypasta/mo.go:127
CF1494D 树+点权/边权的顺序 trapping-rain-water-ii 有 copypasta/union_find.go:109
CF1609D 维护的可以是集合的大小、最值、XOR、GCD 等 有 copypasta/union_find.go:480
CF1635F 树状数组的性质能使其支持动态 [1,x] 或 [x,n] 范围上的最值更新查询等操作 有 copypasta/fenwick_tree.go:87
CF1681F 可撤销并查集 回滚并查集 copypasta/union_find.go:704
CF1701D 最小不相交区间划分数 有 copypasta/heap.go:113
CF1705E 反转 [l,r) 范围内的比特 有 copypasta/bitset.go:191
CF1705E 某些情况下可作为 Bitset 的替代品 handling-sum-queries-after-update 有 copypasta/segment_tree01.go:11
CF1788E 如果不存在，返回 [-1,-1] maximum-width-ramp
longest-well-performing-interval		 copypasta/monotone_stack.go:415
CF1824D = (m+1)∑diff[i] - ∑i*diff[i] copypasta/fenwick_tree.go:288
CF1826E 有时候也可以用 big.Int 代替 有 copypasta/bitset.go:19
CF1851G 树+点权/边权的顺序 rank-transform-of-a-matrix
gcd-sort-of-an-array		 有 copypasta/union_find.go:121
CF1922D 数组实现的双向链表见 monotone_stack.go 中的 permLR 有 copypasta/linked_list.go:19
CF1971G 同一连通块内的数字从小到大排序 有 copypasta/union_find.go:342
CF1978D cmp 需要改成 > 的麻烦写法 copypasta/treap_kthsum.go:138
CF1978F 预处理质因子（见 math.go 中的 primeDivisorsAll） graph-connectivity-with-threshold
largest-component-size-by-common-factor		 有 copypasta/union_find.go:76
CF2042F 如果一个题目可以用分治解决，那么这个题目的带修改版本可以用线段树解决 longest-substring-of-one-repeating-character 有 copypasta/segment_tree.go:88
CF2069F 应用：动态图连通性·离线（求 CC 个数或判断 v 和 w 是否连通） copypasta/union_find.go:707
CFEDU-A 归并做法见 misc.go 中的 mergeCount Codeforces EDU copypasta/fenwick_tree.go:522
CFEDU-A 如果一个题目可以用分治解决，那么这个题目的带修改版本可以用线段树解决 Codeforces EDU copypasta/segment_tree.go:86
CFEDU-A 【单个更新操作】 Codeforces EDU copypasta/segment_tree.go:346
CFEDU-A 【多个更新操作复合】 Codeforces EDU copypasta/segment_tree.go:420
CFEDU-A 类似算法：双栈滑动窗口 Codeforces EDU copypasta/sparse_table.go:118
CFEDU-B 线段树二分 Codeforces EDU copypasta/segment_tree.go:408
CFEDU-B 维护的可以是集合的大小、最值、XOR、GCD 等 Codeforces EDU copypasta/union_find.go:479
CFEDU-C 【单个更新操作】 Codeforces EDU copypasta/segment_tree.go:358
CFEDU-C 那么就可以推出 2->4 的距离为 (1->3) + (3->4) - (1->2) Codeforces EDU copypasta/union_find.go:552
CFEDU-C 可撤销并查集 回滚并查集 Codeforces EDU copypasta/union_find.go:698
CFEDU-D 2. 横着累加：见单调栈的做法（找上一个更大元素，在找的过程中填坑） Codeforces EDU copypasta/monotone_stack.go:110
CFEDU-D 【单个更新操作】 Codeforces EDU copypasta/segment_tree.go:354
CFEDU-D 那么就可以推出 2->4 的距离为 (1->3) + (3->4) - (1->2) Codeforces EDU copypasta/union_find.go:539
CFEDU-E 【单个更新操作】 Codeforces EDU copypasta/segment_tree.go:359
CFEDU-F TIPS: 对于卡常的题目，用 findRoot 判断连通性的逻辑可以用并查集代替 Codeforces EDU copypasta/link_cut_tree.go:25
CFEDU-F 【单个更新操作】 Codeforces EDU copypasta/segment_tree.go:360
CFEDU-F 动态开点线段树·其二·延迟标记（区间修改） Codeforces EDU copypasta/segment_tree.go:671
CFEDU-J 那么就可以推出 2->4 的距离为 (1->3) + (3->4) - (1->2) Codeforces EDU copypasta/union_find.go:543
CF100551A 可撤销并查集 回滚并查集 copypasta/union_find.go:697
CF101234G 维护最小 pi 可以用最小堆 https://leetcode.cn/problems/find-the-k-sum-of-an-array/ find-the-k-sum-of-an-array copypasta/heap.go:60
CF294041E 【单个更新操作】 copypasta/segment_tree.go:351

动态规划

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
1083 CF431D 数位 DP https://www.acwing.com/problem/content// 有 copypasta/dp.go:3110
1200 CF327A 状态机 DP 有 copypasta/dp.go:2309
1200 CF1987C 变形：改成环形数组要怎么做 有 copypasta/dp.go:41
1300 CF1178B 状态机 DP 有 copypasta/dp.go:2310
1300 CF1285B 另一种做法是计算前缀和的最大值与最小值的差 k-concatenation-maximum-sum 有 copypasta/dp.go:511
1300 CF1900C 另见树上背包 treeKnapsack 入门 二叉树 有 copypasta/dp.go:4173
1300 CF2144C 状态机 DP 做法不止一种 有 copypasta/dp.go:2311
1400 CF414B 另见 math_comb.go 中的「一些组合问题」 刷表法 letter-tile-possibilities
minimum-incompatibility		 有 copypasta/dp.go:311
1400 CF698A 状态机 DP 有 copypasta/dp.go:2312
1400 CF940B 从 X 操作到 Y（部分题目也可以用 BFS） broken-calculator
minimum-number-of-days-to-eat-n-oranges		 有 copypasta/dp.go:99
1400 CF1195C 入门视频 min-cost-climbing-stairs
house-robber		 有 copypasta/dp.go:30
1400 CF1350B 这样能更容易地看出转移的顺序，然后变成一个 DAG 上求最长路的问题 有 copypasta/dp.go:842
1400 CF1461B 状态设计 copypasta/dp.go:197
1400 CF2033C 状态机 DP 有 copypasta/dp.go:2313
1400 CF2034C 记忆化搜索 有 copypasta/dp.go:85
1400 CF2114E 另一种做法是计算前缀和的最大值与最小值的差 树上最大交替子段和 k-concatenation-maximum-sum 有 copypasta/dp.go:512
1400 CF2114E 另见树上背包 treeKnapsack 树上最大交替子段和 自顶向下 symmetric-tree 有 copypasta/dp.go:4176
1500 CF212E 关于「超大背包问题」见 search.go 有 copypasta/dp.go:1391
1500 CF553A 状态设计 有 copypasta/dp.go:198
1500 CF855B 状态机 DP copypasta/dp.go:2314
1500 CF982C 另见树上背包 treeKnapsack symmetric-tree 有 copypasta/dp.go:4177
1500 CF991D 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 迷你状压 有 copypasta/dp.go:2473
1500 CF1005D 划分型 DP ① 最优分割 palindrome-partitioning-ii 有 copypasta/dp.go:2089
1500 CF1547E 变形：改成环形数组要怎么做 两次扫描 有 copypasta/dp.go:42
1500 CF1673C 完全背包 EXTRA: 方案数 coin-change-ii 有 copypasta/dp.go:1611
1500 CF1881E 变形：改成环形数组要怎么做 有 copypasta/dp.go:43
1500 CF2050E 见下面的「最长公共子序列」，包含大量扩展题目 有 copypasta/dp.go:59
1500 CF2069C 状态机 DP 有 copypasta/dp.go:2315
1500 CF2107C 另一种做法是计算前缀和的最大值与最小值的差 构造 k-concatenation-maximum-sum 有 copypasta/dp.go:513
1500 CF2115A 多维 DP 也可以 BFS，或者更快的做法 有 copypasta/dp.go:62
1500 CF2121E 数位 DP 有 copypasta/dp.go:3105
1600 CF369C 另见树上背包 treeKnapsack symmetric-tree 有 copypasta/dp.go:4178
1600 CF446A 状态机 DP count-number-of-special-subsequences 有 copypasta/dp.go:2317
1600 CF763A 换根 DP / 二次扫描法 （有更巧妙的做法） minimum-height-trees
sum-of-distances-in-tree		 有 copypasta/dp.go:4592
1600 CF788A 另一种做法是计算前缀和的最大值与最小值的差 k-concatenation-maximum-sum 有 copypasta/dp.go:514
1600 CF1373D 另一种做法是计算前缀和的最大值与最小值的差 k-concatenation-maximum-sum 有 copypasta/dp.go:515
1600 CF1689C 另见树上背包 treeKnapsack 二叉树 symmetric-tree 有 copypasta/dp.go:4179
1600 CF1714D 划分型 DP ① 最优分割 允许重叠 输出方案 palindrome-partitioning-ii 有 copypasta/dp.go:2090
1600 CF1741E 变形：改成环形数组要怎么做 有 copypasta/dp.go:44
1600 CF1875D 变形：改成环形数组要怎么做 有 copypasta/dp.go:45
1600 CF1994C 变形：改成环形数组要怎么做 结合滑窗 有 copypasta/dp.go:46
1600 CF2043C 另一种做法是计算前缀和的最大值与最小值的差 介值定理 k-concatenation-maximum-sum 有 copypasta/dp.go:516
1600 CF2061C 变形：改成环形数组要怎么做 也可以状态机 DP 有 copypasta/dp.go:47
1600 CF2061C 状态机 DP 也可以线性 DP count-number-of-special-subsequences 有 copypasta/dp.go:2318
1600 CF2070D 另见树上背包 treeKnapsack symmetric-tree 有 copypasta/dp.go:4180
1600 CF2125D 在本题中，选或不选不是人为决定的，而是由概率决定的 入门题 有 copypasta/dp.go:2395
1600 CF2167G 这样能更容易地看出转移的顺序，然后变成一个 DAG 上求最长路的问题 有 copypasta/dp.go:843
1600 CF2193F 网格路径问题 网格图 DP 三方向移动 cherry-pickup
cherry-pickup-ii		 有 copypasta/dp.go:165
1600 CF2193F 状态机 DP 三方向移动 count-number-of-special-subsequences 有 copypasta/dp.go:2319
1600 CF2242D 最长公共子序列 (LCS) shortest-common-supersequence
minimum-operations-to-make-a-subsequence		 有 copypasta/dp.go:739
1700 CF4D 更简单的做法是用线段树 二维 LIS + 打印方案 minimum-number-of-increasing-subsequence-to-be-removed
minimum-operations-to-make-a-subsequence		 有 copypasta/dp.go:887
1700 CF163A 最长公共子序列 (LCS) 其中一个改为子串 shortest-common-supersequence
minimum-operations-to-make-a-subsequence		 有 copypasta/dp.go:740
1700 CF219D 换根 DP / 二次扫描法 minimum-height-trees
sum-of-distances-in-tree		 有 copypasta/dp.go:4593
1700 CF269B 更简单的做法是用线段树 建模 minimum-number-of-increasing-subsequence-to-be-removed
minimum-operations-to-make-a-subsequence		 有 copypasta/dp.go:885
1700 CF1516C 关于「超大背包问题」见 search.go 转换 有 copypasta/dp.go:1392
1700 CF1554B 判断是否有两个子集满足 x&y=0 且 idx[x]>=0 且 idx[y]>=0 求下标最大次大，与 k 大小无关的写法 有 copypasta/dp.go:2896
1700 CF1695C 网格路径问题 网格图 DP 变形：连续性 & 上下界思想 unique-paths-ii
minimum-path-sum		 有 copypasta/dp.go:153
1700 CF1822F 换根 DP / 二次扫描法 minimum-edge-reversals-so-every-node-is-reachable
count-number-of-possible-root-nodes		 有 copypasta/dp.go:4596
1700 CF1822F 换根 DP · 其二（维护最大次大） time-taken-to-mark-all-nodes 有 copypasta/dp.go:4715
1700 CF1822F 使用时根据题目修改 data unit moveEdge merge 有 copypasta/dp.go:4780
1700 CF1826D 状态机 DP 式子变形 count-number-of-special-subsequences 有 copypasta/dp.go:2321
1700 CF1881F 树的直径（两遍 DFS 求法另见 graph_tree.go 中的 diameter） diameter-of-binary-tree
amount-of-time-for-binary-tree-to-be-infected		 有 copypasta/dp.go:4223
1700 CF1893B 更简单的做法是用线段树 插入后最小化 LIS minimum-number-of-increasing-subsequence-to-be-removed
minimum-operations-to-make-a-subsequence		 有 copypasta/dp.go:888
1700 CF1969C 部分题目可以用 WQS 二分（或者四边形不等式）优化 sum-of-k-subarrays-with-length-at-least-m
minimum-operations-to-make-elements-within-k-subarrays-equal		 有 copypasta/dp.go:2120
1700 CF2027D1 多维 DP 有 copypasta/dp.go:63
1700 CF2029C 状态机 DP 有 copypasta/dp.go:2323
1700 CF2052F 状态机 DP 地板镶嵌 count-number-of-special-subsequences 有 copypasta/dp.go:2322
1700 CF2086D 关于「超大背包问题」见 search.go 有 copypasta/dp.go:1393
1800 CF30C 变形：改成环形数组要怎么做 有 copypasta/dp.go:48
1800 CF33C 另一种做法是计算前缀和的最大值与最小值的差 有 copypasta/dp.go:517
1800 CF245H 另见 LPS 有 copypasta/dp.go:2184
1800 CF580D 旅行商问题 travelling salesman problem TSP 有 copypasta/dp.go:2639
1800 CF743D 另见树上背包 treeKnapsack symmetric-tree 有 copypasta/dp.go:4181
1800 CF1083A 另见树上背包 treeKnapsack 有 copypasta/dp.go:4182
1800 CF1286A 状态设计 有 copypasta/dp.go:199
1800 CF1324F 换根 DP / 二次扫描法 类似最大子数组和 minimum-edge-reversals-so-every-node-is-reachable
count-number-of-possible-root-nodes		 有 copypasta/dp.go:4597
1800 CF1324F 记录子树大小 size[v] 和子树每个节点的深度之和 sum(dep[sub]) 类似最大子数组和 有 copypasta/dp.go:4628
1800 CF1381B 关于「超大背包问题」见 search.go 转换 有 copypasta/dp.go:1394
1800 CF1446B 最长公共子序列 (LCS) shortest-common-supersequence
minimum-operations-to-make-a-subsequence		 有 copypasta/dp.go:741
1800 CF1509C 另见 LPS 有 copypasta/dp.go:2185
1800 CF1525D 预处理 选或不选 [·hot10] 有 copypasta/dp.go:112
1800 CF1582F1 更简单的做法是用线段树 minimum-operations-to-make-a-subsequence 有 copypasta/dp.go:889
1800 CF1833G 另见树上背包 treeKnapsack copypasta/dp.go:4183
1800 CF1845D 另一种做法是计算前缀和的最大值与最小值的差 本质是去掉一个最小的子段 copypasta/dp.go:518
1800 CF1862F 关于「超大背包问题」见 search.go 有 copypasta/dp.go:1395
1800 CF1912K 合法子序列 DP 有 copypasta/dp.go:1242
1800 CF1954D 关于「超大背包问题」见 search.go 有 copypasta/dp.go:1396
1800 CF1974E 时间复杂度 O(n * sum(values)) 或 O(n^2 * maxV) 有 copypasta/dp.go:1557
1800 CF1987D 状态设计 有 copypasta/dp.go:200
1800 CF2081A 状态机 DP 有 copypasta/dp.go:2324
1800 CF2081A 在本题中，选或不选不是人为决定的，而是由概率决定的 转化成概率 DP 有 copypasta/dp.go:2396
1800 CF2081A 如果状态转移左右两边都包含 f[i]，则需要移项化简 有 copypasta/dp.go:2423
1800 CF2091F 逆序对为 k 时的排列个数 count-the-number-of-inversions 有 copypasta/dp.go:3826
1800 CF2145D 多维 DP 构造 有 copypasta/dp.go:64
1900 CF14E 状态设计 copypasta/dp.go:201
1900 CF16E 在本题中，选或不选不是人为决定的，而是由概率决定的 有 copypasta/dp.go:2397
1900 CF16E 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 与概率 DP 结合 有 copypasta/dp.go:2474
1900 CF19B f[0] 表示至少为 0 的情况，也表示没有任何约束的情况 有 copypasta/dp.go:1465
1900 CF46E 逆序对为 k 时的排列个数 前缀最大值/后缀最大值 count-the-number-of-inversions
count-routes-to-climb-a-rectangular-grid		 有 copypasta/dp.go:3828
1900 CF67D 更简单的做法是用线段树 最多相交问题 典题 minimum-operations-to-make-a-subsequence 有 copypasta/dp.go:890
1900 CF109C 换根 DP / 二次扫描法 也有组合数学做法 minimum-edge-reversals-so-every-node-is-reachable
count-number-of-possible-root-nodes		 有 copypasta/dp.go:4598
1900 CF109C 记录子树大小 size[v] 和子树每个节点的深度之和 sum(dep[sub]) 也有组合数学做法 有 copypasta/dp.go:4629
1900 CF137D 部分题目可以用 WQS 二分（或者四边形不等式）优化 输出具体方案 sum-of-k-subarrays-with-length-at-least-m
minimum-operations-to-make-elements-within-k-subarrays-equal		 有 copypasta/dp.go:2121
1900 CF148E 分组背包·每组至多选一个（恰好选一个见后面） 有 copypasta/dp.go:1777
1900 CF149D 另见 LPS 有 copypasta/dp.go:2186
1900 CF366C f[i][j] 表示前 i 个数，凑成 j 的所有方案中，最小下标的最大值 partition-equal-subset-sum 有 copypasta/dp.go:1418
1900 CF404D 多维 DP 有 copypasta/dp.go:65
1900 CF404D 状态机 DP 有 copypasta/dp.go:2325
1900 CF417D 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 基础状压 有 copypasta/dp.go:2475
1900 CF452D 状态设计 题解 https://www.luogu.com.cn/blog/endlesscheng/solution-cf452d 有 copypasta/dp.go:202
1900 CF463D 最长公共子序列 (LCS) 多个排列的 LCS shortest-common-supersequence
minimum-operations-to-make-a-subsequence		 有 copypasta/dp.go:742
1900 CF479E 逆序对为 k 时的排列个数 count-the-number-of-inversions
count-routes-to-climb-a-rectangular-grid		 有 copypasta/dp.go:3829
1900 CF540D 在本题中，选或不选不是人为决定的，而是由概率决定的 有 copypasta/dp.go:2398
1900 CF577B 关于「超大背包问题」见 search.go 抽屉原理 有 copypasta/dp.go:1398
1900 CF582B 更简单的做法是用线段树 重复数组的 LIS 有 copypasta/dp.go:893
1900 CF597C 数据结构优化 DP 长为 k 的上升子序列个数 有 copypasta/dp.go:3797
1900 CF607B 另见 LPS 回文消除 有 copypasta/dp.go:2187
1900 CF687C 状态设计 有 copypasta/dp.go:203
1900 CF687C 关于「超大背包问题」见 search.go 恰好组成 k 的数中能恰好组成哪些数 有 copypasta/dp.go:1399
1900 CF835D 一般用于 DP 预处理 palindrome-partitioning-ii 有 copypasta/dp.go:1300
1900 CF1012C 状态设计 有 copypasta/dp.go:204
1900 CF1092F 换根 DP / 二次扫描法 minimum-edge-reversals-so-every-node-is-reachable
count-number-of-possible-root-nodes		 有 copypasta/dp.go:4599
1900 CF1114D 最长公共子序列 (LCS) 转换【巧妙】 有 copypasta/dp.go:744
1900 CF1114D 另见 LPS palindrome-removal 有 copypasta/dp.go:2190
1900 CF1155D 另一种做法是计算前缀和的最大值与最小值的差 有 copypasta/dp.go:519
1900 CF1183H 返回一个数组 sumF，其中 sumF[k] 表示长度为 k 的本质不同子序列个数 有 copypasta/dp.go:1270
1900 CF1197D 另一种做法是计算前缀和的最大值与最小值的差 思路 https://docs.qq.com/sheet/DWGFoRGVZRmxNaXFz 里面搜本题链接 有 copypasta/dp.go:520
1900 CF1613D 状态机 DP 爽 有 copypasta/dp.go:2326
1900 CF1739D 另见树上背包 treeKnapsack 二分答案 有 copypasta/dp.go:4184
1900 CF1794D 另见 math_comb.go 中的「一些组合问题」 letter-tile-possibilities
minimum-incompatibility		 有 copypasta/dp.go:312
1900 CF1801C 不相交区间 DP 有 copypasta/dp.go:132
1900 CF1882D 换根 DP / 二次扫描法 minimum-edge-reversals-so-every-node-is-reachable
count-number-of-possible-root-nodes		 有 copypasta/dp.go:4600
1900 CF1926G 另见树上背包 treeKnapsack 有 copypasta/dp.go:4185
1900 CF1950G 时间复杂度通常是 O(n^2*2^n) 有 copypasta/dp.go:2584
1900 CF2000F 分组背包·每组至多选一个（恰好选一个见后面） 至少 有 copypasta/dp.go:1778
1900 CF2049D 网格路径问题 网格图 DP rotate 每行 unique-paths-ii
minimum-path-sum		 有 copypasta/dp.go:155
2000 CF8C 旅行商问题 travelling salesman problem TSP 有 copypasta/dp.go:2640
2000 CF66E 数据结构优化 DP copypasta/dp.go:3798
2000 CF75D 另一种做法是计算前缀和的最大值与最小值的差 多个小数组合并 有 copypasta/dp.go:523
2000 CF213C 网格路径问题 网格图 DP triangle
cherry-pickup		 有 copypasta/dp.go:160
2000 CF235B 如果状态转移左右两边都包含 f[i]，则需要移项化简 有 copypasta/dp.go:2424
2000 CF264C 维护最大次大 minimum-number-of-operations-to-satisfy-conditions 有 copypasta/dp.go:3815
2000 CF337D 换根 DP / 二次扫描法 count-number-of-possible-root-nodes 有 copypasta/dp.go:4601
2000 CF346B 最长公共子序列 (LCS) 与 KMP 结合 有 copypasta/dp.go:745
2000 CF360B 状态设计 有 copypasta/dp.go:205
2000 CF401D 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 有 copypasta/dp.go:2476
2000 CF453B 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 与质因数分解结合 有 copypasta/dp.go:2477
2000 CF461B 状态设计 有 copypasta/dp.go:206
2000 CF461B 另见树上背包 treeKnapsack 如何定义状态 有 copypasta/dp.go:4187
2000 CF571B 状态设计 copypasta/dp.go:207
2000 CF855C 另见树上背包 treeKnapsack copypasta/dp.go:4186
2000 CF864E 关于「超大背包问题」见 search.go 打印方案 有 copypasta/dp.go:1400
2000 CF895C 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 有 copypasta/dp.go:2478
2000 CF958C2 逆序对为 k 时的排列个数 count-routes-to-climb-a-rectangular-grid 有 copypasta/dp.go:3831
2000 CF1082E 另一种做法是计算前缀和的最大值与最小值的差 需要一些转换技巧 有 copypasta/dp.go:521
2000 CF1132F 另见 LPS palindrome-removal 有 copypasta/dp.go:2192
2000 CF1142B 倍增 path-existence-queries-in-a-graph-ii 有 copypasta/dp.go:3657
2000 CF1296E2 更简单的做法是用线段树 转化成最小划分数+打印划分方案 有 copypasta/dp.go:896
2000 CF1408D 状态设计 有 copypasta/dp.go:208
2000 CF1624E 变形：改成环形数组要怎么做 有 copypasta/dp.go:40
2000 CF1646D 变形：同一层至多选一个节点（蓝桥杯） 输出具体方案 有 copypasta/dp.go:4467
2000 CF1753C 如果状态转移左右两边都包含 f[i]，则需要移项化简 有 copypasta/dp.go:2425
2000 CF1783D 状态设计 推公式 有 copypasta/dp.go:209
2000 CF1920E 多维 DP 有 copypasta/dp.go:66
2000 CF1923E 另见树上背包 treeKnapsack 两端点颜色相同，中间节点颜色不等于两端点 有 copypasta/dp.go:4188
2000 CF1988D 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 有 copypasta/dp.go:4190
2000 CF1988D 变形：同一层至多选一个节点（蓝桥杯） 相似，但不完全是 有 copypasta/dp.go:4468
2000 CF2014F 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 推荐 经典状态机 有 copypasta/dp.go:4191
2000 CF2075D 关于「超大背包问题」见 search.go 双背包 恰好装满+至少装满 有 copypasta/dp.go:1401
2000 CF2075D f[0] 表示至少为 0 的情况，也表示没有任何约束的情况 双背包 恰好装满+至少装满 painting-the-walls 有 copypasta/dp.go:1467
2000 CF2114F 变形：改成环形数组要怎么做 有 copypasta/dp.go:49
2000 CF2194E 网格路径问题 网格图 DP 修改一个格子后的最大路径和的最小值 cherry-pickup-ii 有 copypasta/dp.go:166
2100 CF56D 输出具体方案 有 copypasta/dp.go:89
2100 CF56D 最长公共子序列 (LCS) edit-distance
one-edit-distance		 有 copypasta/dp.go:734
2100 CF229D 决策单调性优化 DP stone-game-v copypasta/dp.go:4127
2100 CF238C 记录子树大小 size[v] 和子树每个节点的深度之和 sum(dep[sub]) 有 O(n) 做法 有 copypasta/dp.go:4630
2100 CF319C 思考：三维凸包优化 DP？ 有 copypasta/dp.go:3895
2100 CF734E 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 巧妙的转换 有 copypasta/dp.go:4192
2100 CF791D 换根 DP / 二次扫描法 有 copypasta/dp.go:4602
2100 CF791D 记录子树大小 size[v] 和子树每个节点的深度之和 sum(dep[sub]) 任意两点距离除以 k 的上取整之和 有 copypasta/dp.go:4631
2100 CF960F 在一维 LIS 的基础上，a[i] 可以从多个数中选一个，问 LIS 最长可以多长 图上的路径的 LIS 有 copypasta/dp.go:902
2100 CF985E 滑动窗口优化 DP 有 copypasta/dp.go:3845
2100 CF1025D 状态设计 有 copypasta/dp.go:210
2100 CF1025D 另见 LPS 状态设计 palindrome-removal 有 copypasta/dp.go:2193
2100 CF1027E 状态设计 有 copypasta/dp.go:211
2100 CF1029E 下面的定义省去了（……时的最小支配集的元素个数） w 为 i 的儿子 binary-tree-cameras 有 copypasta/dp.go:4518
2100 CF1117D 数据结构优化 DP 矩阵快速幂 有 copypasta/dp.go:3799
2100 CF1185G1 时间复杂度通常是 O(n^2*2^n) 有 copypasta/dp.go:2585
2100 CF1187E 换根 DP / 二次扫描法 有 copypasta/dp.go:4603
2100 CF1370E 这题做法需要用到上面说到的第二种思路 转换 copypasta/dp.go:525
2100 CF1516D 倍增 path-existence-queries-in-a-graph-ii copypasta/dp.go:3658
2100 CF1575L 在一维 LIS 的基础上，a[i] 可以从多个数中选一个，问 LIS 最长可以多长 删除元素使得 a[i] = i 尽量多 有 copypasta/dp.go:903
2100 CF1667B 数据结构优化 DP 有 copypasta/dp.go:3800
2100 CF1767C 另见 math_comb.go 中的「一些组合问题」 带约束的计数 DP letter-tile-possibilities
minimum-incompatibility		 copypasta/dp.go:313
2100 CF1771D 最长回文子序列 (LPS) count-different-palindromic-subsequences
minimum-insertion-steps-to-make-a-string-palindrome		 有 copypasta/dp.go:2216
2100 CF1778D 如果状态转移左右两边都包含 f[i]，则需要移项化简 有 copypasta/dp.go:2426
2100 CF2051G 时间复杂度通常是 O(n^2*2^n) copypasta/dp.go:2586
2100 CF2074G 另见 LPS palindrome-removal 有 copypasta/dp.go:2194
2100 CF2161D 入门视频 house-robber
delete-and-earn		 有 copypasta/dp.go:32
2200 CF11D 无向图简单环数量 有 copypasta/dp.go:2708
2200 CF13C 同上，把这个序列视作 1 2 2 4 2 2，总的修改次数仍然为 11 有 copypasta/dp.go:656
2200 CF165E 判断是否有两个子集满足 x&y=0 且 idx[x]>=0 且 idx[y]>=0 有 copypasta/dp.go:2897
2200 CF377C 下面的写法常数是 1/2 枚举来源 beautiful-arrangement 有 copypasta/dp.go:2542
2200 CF385D 下面的写法常数是 1/2 计算几何 beautiful-arrangement 有 copypasta/dp.go:2543
2200 CF486E 在一维 LIS 的基础上，a[i] 可以从多个数中选一个，问 LIS 最长可以多长 将所有 a[i] 分成三类：不在任何 LIS 中 / 在至少一个 LIS 中 / 在所有 LIS 中 有 copypasta/dp.go:904
2200 CF538E 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） **如何转移 有 copypasta/dp.go:4193
2200 CF645E 本质不同非空子序列个数 需要一点构造能力 distinct-subsequences-ii
number-of-unique-good-subsequences		 有 copypasta/dp.go:1251
2200 CF678E 在本题中，选或不选不是人为决定的，而是由概率决定的 有 copypasta/dp.go:2399
2200 CF743E 下面的写法常数是 1/2 状态设计 有 copypasta/dp.go:2544
2200 CF833B 数据结构优化 DP 有 copypasta/dp.go:3801
2200 CF903F 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 轮廓线 有 copypasta/dp.go:2479
2200 CF903F 训练指南 6.1 有 copypasta/dp.go:3005
2200 CF908D 如果状态转移左右两边都包含 f[i]，则需要移项化简 有 copypasta/dp.go:2427
2200 CF946E 思维扩展 重排成回文串 有 copypasta/dp.go:3185
2200 CF981E 关于「超大背包问题」见 search.go 转移对象是下标 有 copypasta/dp.go:1403
2200 CF1097D 如果状态转移左右两边都包含 f[i]，则需要移项化简 有 copypasta/dp.go:2428
2200 CF1175E 倍增 path-existence-queries-in-a-graph-ii 有 copypasta/dp.go:3659
2200 CF1215E 下面的写法常数是 1/2 有 copypasta/dp.go:2545
2200 CF1220E 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 可以重复走 有 copypasta/dp.go:4194
2200 CF1234F 判断是否有两个子集满足 x&y=0 且 idx[x]>=0 且 idx[y]>=0 有 copypasta/dp.go:2898
2200 CF1238E 下面的写法常数是 1/2 式子变形 有 copypasta/dp.go:2546
2200 CF1238F 树的直径（两遍 DFS 求法另见 graph_tree.go 中的 diameter） diameter-of-binary-tree
amount-of-time-for-binary-tree-to-be-infected		 有 copypasta/dp.go:4224
2200 CF1249F 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 好题 copypasta/dp.go:4195
2200 CF1295E 数据结构优化 DP 有 copypasta/dp.go:3803
2200 CF1303E 多维 DP 状态设计 经典题 有 copypasta/dp.go:67
2200 CF1336C 另见 LPS 状态设计 有 copypasta/dp.go:2195
2200 CF1468A 在一维 LIS 的基础上，a[i] 可以从多个数中选一个，问 LIS 最长可以多长 LaIS 与单调栈结合 有 copypasta/dp.go:909
2200 CF1515E 插入 DP / 连续段 DP 有 copypasta/dp.go:135
2200 CF1552F 优化空间时，可以直接把前缀和保存到 f 数组上，然后倒序遍历，计算实际的 f 数据加强 count-the-number-of-inversions
number-of-ways-to-separate-numbers		 有 copypasta/dp.go:3821
2200 CF1579G 状态设计 有 copypasta/dp.go:212
2200 CF1627E 变形：改成环形数组要怎么做 刷表法 双指针 有 copypasta/dp.go:50
2200 CF1650F 时间复杂度 O(n * sum(values)) 或 O(n^2 * maxV) 有 copypasta/dp.go:1558
2200 CF1788E 数据结构优化 DP copypasta/dp.go:3804
2200 CF2027D2 多维 DP 在 DP 数组上滑窗 有 copypasta/dp.go:68
2200 CF2045H 多维 DP 有 copypasta/dp.go:69
2200 CF2060F 另见 math_comb.go 中的「一些组合问题」 letter-tile-possibilities
minimum-incompatibility		 copypasta/dp.go:314
2200 CF2143D2 数据结构优化 DP 两个递增子序列 二维树状数组优化 DP 有 copypasta/dp.go:3805
2300 CF327E 下面的写法常数是 1/2 卡常优化 另一种做法是折半枚举 有 copypasta/dp.go:2547
2300 CF543D 换根 DP / 二次扫描法 注意不存在逆元的情形 有 copypasta/dp.go:4604
2300 CF543D 使用时根据题目修改 data unit moveEdge merge 有 copypasta/dp.go:4781
2300 CF570E 网格路径问题 网格图 DP cherry-pickup
cherry-pickup-ii		 有 copypasta/dp.go:164
2300 CF623B 状态机 DP 有 copypasta/dp.go:2327
2300 CF713C 同上，把这个序列视作 1 2 2 4 2 2，总的修改次数仍然为 11 严格单调递增 https://codeforces.com/blog/entry/47094?#comment-315161 make-array-non-decreasing-or-non-increasing 有 copypasta/dp.go:659
2300 CF1073E 返回 [low, high] 中的所有元素的价值总和 有 copypasta/dp.go:3374
2300 CF1198D 另见 LPS 二维区间 DP 有 copypasta/dp.go:2197
2300 CF1203F2 关于「超大背包问题」见 search.go 排序+转换 有 copypasta/dp.go:1404
2300 CF1245F 贪心：求 <= N 的最大数 二维（互相独立） count-beautiful-numbers 有 copypasta/dp.go:3156
2300 CF1292C 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 有 copypasta/dp.go:4196
2300 CF1316E 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 与排序贪心结合 有 copypasta/dp.go:2480
2300 CF1453E 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 好题 有 copypasta/dp.go:4197
2300 CF1603C 数论分块优化 DP copypasta/dp.go:3855
2300 CF1623D 如果状态转移左右两边都包含 f[i]，则需要移项化简 copypasta/dp.go:2429
2300 CF1623D E(x) = ∑i*P(x=i) = ∑P(x>=i) copypasta/dp.go:2456
2300 CF1824B2 如果状态转移左右两边都包含 f[i]，则需要移项化简 有 copypasta/dp.go:2430
2300 CF1842E 数据结构优化 DP 有 copypasta/dp.go:3806
2300 CF1843F2 这题做法需要用到上面说到的第二种思路 树上的情况 copypasta/dp.go:526
2300 CF1927G 状态设计 有 copypasta/dp.go:213
2300 CF1955H 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 copypasta/dp.go:2481
2300 CF1995D 所以转换成求每个 ai 的补集的 SOS，维护子集二进制 1 的个数的最大值 copypasta/dp.go:2902
2300 CF2028E 在本题中，选或不选不是人为决定的，而是由概率决定的 copypasta/dp.go:2400
2300 CF2121H 在一维 LIS 的基础上，a[i] 可以从多个数中选一个，问 LIS 最长可以多长 狸猫换太子 copypasta/dp.go:900
2400 CF24D 如果状态转移左右两边都包含 f[i]，则需要移项化简 高斯消元 托马斯算法 copypasta/dp.go:2431
2400 CF31E 多维 DP 有 copypasta/dp.go:70
2400 CF31E 输出具体方案 有 copypasta/dp.go:90
2400 CF115E 数据结构优化 DP 线段树 式子变形 划分型 DP 有 copypasta/dp.go:3807
2400 CF125E 具体请看下面的代码注释 单度限制最小生成树（恰好） maximum-profit-in-job-scheduling
minimum-white-tiles-after-covering-with-carpets		 copypasta/dp.go:4034
2400 CF283D 变形：改成环形数组要怎么做 x 可以被表示为 y 个连续整数的和 有 copypasta/dp.go:51
2400 CF288D 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 形状设计，两条相交路径（枚举 acd + b），也有简单的做法 形状设计的做法 https://codeforces.com/contest/288/submission/326209476 有 copypasta/dp.go:4199
2400 CF311B 思考：三维凸包优化 DP？ 划分型 DP 有 copypasta/dp.go:3896
2400 CF316D3 另见 math_comb.go 中的「一些组合问题」 交换环 letter-tile-possibilities
minimum-incompatibility		 有 copypasta/dp.go:315
2400 CF441E 状态设计 考虑 x+i 的尾零个数 有 copypasta/dp.go:214
2400 CF449D 所以转换成求每个 ai 的补集的 SOS，维护子集二进制 1 的个数的最大值 容斥 有 copypasta/dp.go:2903
2400 CF498B 如果状态转移左右两边都包含 f[i]，则需要移项化简 有 copypasta/dp.go:2432
2400 CF526E 变形：改成环形数组要怎么做 滑动窗口 有 copypasta/dp.go:52
2400 CF626F 插入 DP / 连续段 DP 有 copypasta/dp.go:136
2400 CF626F 另见 math_comb.go 中的「一些组合问题」 转换 minimum-incompatibility 有 copypasta/dp.go:316
2400 CF632E 完全背包 Unbounded Knapsack copypasta/dp.go:1591
2400 CF641D 概率 式子变形 有 copypasta/dp.go:2390
2400 CF643C 部分题目可以用 WQS 二分（或者四边形不等式）优化 斜率优化 minimum-operations-to-make-elements-within-k-subarrays-equal
palindrome-partitioning-iii		 有 copypasta/dp.go:2123
2400 CF643C 思考：三维凸包优化 DP？ 划分型 DP + 期望 DP 有 copypasta/dp.go:3897
2400 CF698C 如果状态转移左右两边都包含 f[i]，则需要移项化简 有 copypasta/dp.go:2433
2400 CF698C 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 概率 有 copypasta/dp.go:2482
2400 CF744C 状态设计 有 copypasta/dp.go:217
2400 CF744C 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 状态设计 有 copypasta/dp.go:2483
2400 CF744C 下面的写法常数是 1/2 状态设计 todo 有 copypasta/dp.go:2548
2400 CF756D 返回一个数组 sumF，其中 sumF[k] 表示长度为 k 的本质不同子序列个数 子序列相邻字母一定不同 有 copypasta/dp.go:1271
2400 CF796E 多维 DP 状态设计 有 copypasta/dp.go:71
2400 CF796E 状态设计 有 copypasta/dp.go:218
2400 CF796E 状态机 DP 有 copypasta/dp.go:2328
2400 CF815C 所以每个点对会贡献（且只在 LCA 处贡献）一个转移，所以总的转移次数是 O(n^2) 有 copypasta/dp.go:1856
2400 CF822E 预处理 适合刷表法 有 copypasta/dp.go:128
2400 CF822E 部分题目可以用 WQS 二分（或者四边形不等式）优化 双序列 状态设计 刷表法 minimum-operations-to-make-elements-within-k-subarrays-equal
palindrome-partitioning-iii		 有 copypasta/dp.go:2124
2400 CF825F 划分型 DP ① 最优分割 KMP palindrome-partitioning-ii 有 copypasta/dp.go:2091
2400 CF865C 如果状态转移左右两边都包含 f[i]，则需要移项化简 copypasta/dp.go:2434
2400 CF939F 状态设计 有 copypasta/dp.go:219
2400 CF946F 多维 DP 状态设计 todo 有 copypasta/dp.go:72
2400 CF983C 多维 DP copypasta/dp.go:73
2400 CF1042F 树的直径（两遍 DFS 求法另见 graph_tree.go 中的 diameter） 贪心 diameter-of-binary-tree
amount-of-time-for-binary-tree-to-be-infected		 有 copypasta/dp.go:4225
2400 CF1059E 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 取往上冲的最高的点（子树） 有 copypasta/dp.go:4200
2400 CF1083E 思考：三维凸包优化 DP？ 入门题 有 copypasta/dp.go:3898
2400 CF1088E 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 有 copypasta/dp.go:4201
2400 CF1093F 状态设计 容斥 有 copypasta/dp.go:220
2400 CF1101F 决策单调性优化 DP 看似二分，但实际上只是对状态定义有帮助（最大间距的最小值） stone-game-v 有 copypasta/dp.go:4128
2400 CF1107E 一般定义 f[i][j] 表示子数组 a[i] 到 a[j] 的最优解 minimum-score-triangulation-of-polygon
remove-boxes		 有 copypasta/dp.go:2177
2400 CF1107E 另见 LPS 有 copypasta/dp.go:2198
2400 CF1304F2 数据结构优化 DP 单调队列 有 copypasta/dp.go:3808
2400 CF1348E 状态设计 做到 O(nk) todo 需要复习 有 copypasta/dp.go:221
2400 CF1523D 所以转换成求每个 ai 的补集的 SOS，维护子集二进制 1 的个数的最大值 有 copypasta/dp.go:2904
2400 CF1575M 思考：三维凸包优化 DP？ 固定变量 有 copypasta/dp.go:3899
2400 CF1598F 下面的写法常数是 1/2 合法括号字符串 有 copypasta/dp.go:2550
2400 CF1609E 数据结构优化 DP 线段树 分治 有 copypasta/dp.go:3809
2400 CF1620G 所以转换成求每个 ai 的补集的 SOS，维护子集二进制 1 的个数的最大值 容斥 有 copypasta/dp.go:2905
2400 CF1626E 换根 DP / 二次扫描法 有 copypasta/dp.go:4605
2400 CF1670F 贪心：求 <= N 的最大数 count-beautiful-numbers 有 copypasta/dp.go:3157
2400 CF1679E 所以转换成求每个 ai 的补集的 SOS，维护子集二进制 1 的个数的最大值 有 copypasta/dp.go:2906
2400 CF1715E 思考：三维凸包优化 DP？ Dijkstra 有 copypasta/dp.go:3900
2400 CF1739E 变形：改成环形数组要怎么做 maximize-the-distance-between-points-on-a-square 有 copypasta/dp.go:54
2400 CF1794E 换根 DP / 二次扫描法 copypasta/dp.go:4606
2400 CF1826E 在一维 LIS 的基础上，a[i] 可以从多个数中选一个，问 LIS 最长可以多长 bitset 优化 有 copypasta/dp.go:910
2400 CF1852C 同上，把这个序列视作 1 2 2 4 2 2，总的修改次数仍然为 11 make-array-non-decreasing-or-non-increasing 有 copypasta/dp.go:662
2400 CF1866M 如果状态转移左右两边都包含 f[i]，则需要移项化简 期望的线性性 有 copypasta/dp.go:2435
2400 CF1886E 下面的写法常数是 1/2 状态设计 打印具体方案 有 copypasta/dp.go:2549
2400 CF1943D1 逆序对为 k 时的排列个数 结论 count-routes-to-climb-a-rectangular-grid 有 copypasta/dp.go:3832
2400 CF2109E 另见 math_comb.go 中的「一些组合问题」 翻转前缀的不同操作顺序的个数 有 copypasta/dp.go:317
2400 CF2122D 图 DP t 时刻只能去 g[v][t%len(g[v])] 有 copypasta/dp.go:171
2500 CF23E 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） copypasta/dp.go:4202
2500 CF55D 贪心：求 <= N 的最大数 被每个非零数位都整除的数字个数 count-beautiful-numbers
find-sum-of-array-product-of-magical-sequences		 有 copypasta/dp.go:3159
2500 CF95D 贪心：求 <= N 的最大数 考虑 memo 的复用 count-beautiful-numbers
find-sum-of-array-product-of-magical-sequences		 有 copypasta/dp.go:3160
2500 CF147B 倍增 path-existence-queries-in-a-graph-ii 有 copypasta/dp.go:3661
2500 CF360C 多维 DP 有 copypasta/dp.go:74
2500 CF437E 一般定义 f[i][j] 表示子数组 a[i] 到 a[j] 的最优解 minimum-cost-to-cut-a-stick
minimum-score-triangulation-of-polygon		 copypasta/dp.go:2174
2500 CF437E 另见 LPS copypasta/dp.go:2199
2500 CF543C 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 状态转移 有 copypasta/dp.go:2484
2500 CF660F 思考：三维凸包优化 DP？ 有 copypasta/dp.go:3901
2500 CF678F 思考：三维凸包优化 DP？ 线段树分治 todo copypasta/dp.go:3902
2500 CF704B 插入 DP / 连续段 DP copypasta/dp.go:137
2500 CF735E 下面的定义省去了（……时的最小支配集的元素个数） w 为 i 的儿子 支配距离 <= k 的方案数 binary-tree-cameras 有 copypasta/dp.go:4519
2500 CF771D 多维 DP 逆序对 有 copypasta/dp.go:75
2500 CF835F 树的直径（两遍 DFS 求法另见 graph_tree.go 中的 diameter） 基环树 形状设计 diameter-of-binary-tree
amount-of-time-for-binary-tree-to-be-infected		 有 copypasta/dp.go:4226
2500 CF840C 状态设计 多重集排列，相邻元素不同 有 copypasta/dp.go:222
2500 CF845F 轮廓线 DP 状态设计 一个格子一个格子地算 有 copypasta/dp.go:2505
2500 CF868F 决策单调性优化 DP 分治+莫队均摊 todo stone-game-v 有 copypasta/dp.go:4129
2500 CF946G 在一维 LIS 的基础上，a[i] 可以从多个数中选一个，问 LIS 最长可以多长 有 copypasta/dp.go:911
2500 CF946G 状态机 DP LIS 有 copypasta/dp.go:2329
2500 CF958C3 其他 同余 找最优决策点 有 copypasta/dp.go:3858
2500 CF1065F 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 可以跳到叶子，也可以往上跳至多 k 步，问：至多可以访问多少个叶子？ 有 copypasta/dp.go:4203
2500 CF1146F 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 把叶子分成若干集合，每个集合的斯坦纳树互不相交 状态设计 todo 复习 有 copypasta/dp.go:4204
2500 CF1209E2 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 循环移位 有 copypasta/dp.go:2485
2500 CF1280D 所以每个点对会贡献（且只在 LCA 处贡献）一个转移，所以总的转移次数是 O(n^2) copypasta/dp.go:1857
2500 CF1550E 下面的写法常数是 1/2 状态设计 有 copypasta/dp.go:2551
2500 CF1556F 如果状态转移左右两边都包含 f[i]，则需要移项化简 状压 DP copypasta/dp.go:2436
2500 CF1556F 把相同的大质数归类，避免重复选择（分组背包） copypasta/dp.go:2755
2500 CF1556F 将 n 个集合分成尽量多组，使得对于每组，组内所有集合的并集等于全集 期望 DP copypasta/dp.go:2759
2500 CF1562E 这样能更容易地看出转移的顺序，然后变成一个 DAG 上求最长路的问题 有 copypasta/dp.go:844
2500 CF1691F 换根 DP / 二次扫描法 计数 copypasta/dp.go:4607
2500 CF1701E follow up: 要求某个子串 sub 一定在 LCS 中 状态机 DP / 前后缀分解 有 copypasta/dp.go:747
2500 CF1701E 状态机 DP LCS 变形题 有 copypasta/dp.go:2330
2500 CF1779F 输出具体方案 树上背包 有 copypasta/dp.go:91
2500 CF1779F 所以每个点对会贡献（且只在 LCA 处贡献）一个转移，所以总的转移次数是 O(n^2) 输出具体方案 有 copypasta/dp.go:1858
2500 CF1854C 如果状态转移左右两边都包含 f[i]，则需要移项化简 期望的线性性（独立计算） 有 copypasta/dp.go:2437
2500 CF1866K 思考：三维凸包优化 DP？ 凸包次大值：把从单调栈中淘汰的数据再建一个（更内部的）凸包 有 copypasta/dp.go:3903
2500 CF1866K 换根 DP · 其二（维护最大次大） 凸包 time-taken-to-mark-all-nodes 有 copypasta/dp.go:4716
2500 CF1903D2 所以转换成求每个 ai 的补集的 SOS，维护子集二进制 1 的个数的最大值 状态设计 有 copypasta/dp.go:2907
2600 CF6D 多维 DP 有 copypasta/dp.go:76
2600 CF10E 【脑洞】求极限：lim_{maxW->∞} f[maxW]/maxW 有 copypasta/dp.go:1596
2600 CF67C 最长公共子序列 (LCS) edit-distance
one-edit-distance		 copypasta/dp.go:735
2600 CF93E 多维 DP 记忆化搜索 时间换空间 有 copypasta/dp.go:77
2600 CF115D 逆序对为 k 时的排列个数 count-routes-to-climb-a-rectangular-grid copypasta/dp.go:3833
2600 CF150D 另见 LPS 回文消除 每个长度有不同的权值 palindrome-removal copypasta/dp.go:2189
2600 CF248E 如果状态转移左右两边都包含 f[i]，则需要移项化简 移动架子上的蜂蜜罐 有 copypasta/dp.go:2438
2600 CF258D 在本题中，选或不选不是人为决定的，而是由概率决定的 有 copypasta/dp.go:2401
2600 CF261D 更简单的做法是用线段树 copypasta/dp.go:894
2600 CF321E 部分题目可以用 WQS 二分（或者四边形不等式）优化 minimum-operations-to-make-elements-within-k-subarrays-equal
palindrome-partitioning-iii		 有 copypasta/dp.go:2125
2600 CF321E 具体请看下面的代码注释 maximum-profit-in-job-scheduling
minimum-white-tiles-after-covering-with-carpets		 有 copypasta/dp.go:4035
2600 CF321E 满足该性质的 DAG 叫做 Monge 图 super-egg-drop 有 copypasta/dp.go:4138
2600 CF346D 图 DP 有 copypasta/dp.go:172
2600 CF382E 另见 math_comb.go 中的「一些组合问题」 copypasta/dp.go:318
2600 CF494C 如果状态转移左右两边都包含 f[i]，则需要移项化简 copypasta/dp.go:2439
2600 CF599E 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 树上子集状压 有 copypasta/dp.go:2486
2600 CF599E 将 n 个集合分成尽量多组，使得对于每组，组内所有集合的并集等于全集 树上子集状压 DP 有 copypasta/dp.go:2760
2600 CF627D 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 看似换根，但其实不是 有 copypasta/dp.go:4205
2600 CF631E 思考：三维凸包优化 DP？ 往左还是往右可以变形成同一个式子 有 copypasta/dp.go:3904
2600 CF633F 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 形状设计 有 copypasta/dp.go:4206
2600 CF633F 最大路径和 最大路径点权和 两条不相交路径的最大点权和 difference-between-maximum-and-minimum-price-sum 有 copypasta/dp.go:4391
2600 CF633F 换根 DP · 其二（维护最大次大） 计算最大次大第三大（也可以直接树形 DP，无需换根） time-taken-to-mark-all-nodes 有 copypasta/dp.go:4717
2600 CF650D 在一维 LIS 的基础上，a[i] 可以从多个数中选一个，问 LIS 最长可以多长 有 copypasta/dp.go:908
2600 CF662C 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 状态设计 也可以 FWT 有 copypasta/dp.go:2487
2600 CF797F 部分题目可以用 WQS 二分（或者四边形不等式）优化 palindrome-partitioning-iii 有 copypasta/dp.go:2126
2600 CF1172C2 如果状态转移左右两边都包含 f[i]，则需要移项化简 有 copypasta/dp.go:2440
2600 CF1208F 所以转换成求每个 ai 的补集的 SOS，维护子集二进制 1 的个数的最大值 也有枚举子集+剪枝的做法 有 copypasta/dp.go:2908
2600 CF1237F 另见 math_comb.go 中的「一些组合问题」 有 copypasta/dp.go:319
2600 CF1380G 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 放 k 个宝箱怪 贡献法 排序不等式 式子变形 有 copypasta/dp.go:2489
2600 CF1430G 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 有 copypasta/dp.go:2490
2600 CF1437F 状态设计 钓鱼佬 情绪化展示顺序的方案数 有 copypasta/dp.go:223
2600 CF1523E E(x) = ∑i*P(x=i) = ∑P(x>=i) 有 copypasta/dp.go:2457
2600 CF1580B 另见 math_comb.go 中的「一些组合问题」 有 copypasta/dp.go:320
2600 CF1584F follow up: 要求某个子串 sub 一定在 LCS 中 多串 + 每种字母至多出现两次 有 copypasta/dp.go:748
2600 CF1793E 状态设计 读书 满足尽量多的人 有 copypasta/dp.go:224
2600 CF1823F 如果状态转移左右两边都包含 f[i]，则需要移项化简 树上随机游走 有 copypasta/dp.go:2441
2600 CF1863F 另见 LPS 有 copypasta/dp.go:2200
2600 CF1863F 其他 有 copypasta/dp.go:3859
2600 CF2042F 如矩阵乘积，矩阵和等等。线段树的区间操作可以应对区间修改问题。 有 copypasta/dp.go:3873
2700 CF98E 在本题中，选或不选不是人为决定的，而是由概率决定的 纳什均衡 有 copypasta/dp.go:2402
2700 CF183D 如果状态转移左右两边都包含 f[i]，则需要移项化简 copypasta/dp.go:2442
2700 CF183D 逆序对为 k 时的排列个数 copypasta/dp.go:3834
2700 CF249D 修改 2 个数呢？修改 k 个数呢？ copypasta/dp.go:914
2700 CF367E 多维 DP 状态设计 有 copypasta/dp.go:78
2700 CF383E 问题变成 (^ai)&aj&ak + ai 的最大值 正难则反 有 copypasta/dp.go:2912
2700 CF494D 记录子树大小 size[v] 和子树每个节点的深度之和 sum(dep[sub]) 式子变形 copypasta/dp.go:4633
2700 CF772D 问题变成 (^ai)&aj&ak + ai 的最大值 copypasta/dp.go:2913
2700 CF932F 思考：三维凸包优化 DP？ 平衡树+启发式合并 有 copypasta/dp.go:3905
2700 CF938F 状态设计 扩散至超集的写法 有 copypasta/dp.go:225
2700 CF995F 另见 math_comb.go 中的「一些组合问题」 也可以用拉格朗日插值 copypasta/dp.go:321
2700 CF1303G 思考：三维凸包优化 DP？ 李超线段树 copypasta/dp.go:3906
2700 CF1338D 树的直径（两遍 DFS 求法另见 graph_tree.go 中的 diameter） 橡皮筋嵌套 最长长度 形状设计 todo 复习 diameter-of-binary-tree
amount-of-time-for-binary-tree-to-be-infected		 有 copypasta/dp.go:4227
2700 CF1366F 思考：三维凸包优化 DP？ 图 DP 有 copypasta/dp.go:3907
2700 CF1366G follow up: 要求某个子串 sub 一定在 LCS 中 结合括号匹配，挖掘性质 copypasta/dp.go:750
2700 CF1487G 关于「超大背包问题」见 search.go copypasta/dp.go:1408
2700 CF1542E2 逆序对为 k 时的排列个数 有 copypasta/dp.go:3835
2700 CF1789F follow up: 要求某个子串 sub 一定在 LCS 中 分类讨论 多串 有 copypasta/dp.go:751
2700 CF1799F 贪心+DP minimum-time-to-make-array-sum-at-most-x 有 copypasta/dp.go:284
2700 CF1997F 完全背包 Unbounded Knapsack 有 copypasta/dp.go:1592
2700 CF2026F 关于「超大背包问题」见 search.go 有 copypasta/dp.go:1405
2700 CF2209F 换根 DP · 其二（维护最大次大） time-taken-to-mark-all-nodes copypasta/dp.go:4718
2800 CF79D 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 BFS 有 copypasta/dp.go:2491
2800 CF850F 如果状态转移左右两边都包含 f[i]，则需要移项化简 鞅与停时定理 copypasta/dp.go:2443
2800 CF908G 贪心：求 <= N 的最大数 排序后的数字之和 find-sum-of-array-product-of-magical-sequences 有 copypasta/dp.go:3162
2800 CF1442D 分组背包·每组至多选一个（恰好选一个见后面） todo 进一步优化 有 copypasta/dp.go:1779
2800 CF1842G 如果状态转移左右两边都包含 f[i]，则需要移项化简 题解 https://codeforces.com/blog/entry/117640 有 copypasta/dp.go:2444
2800 CF2034F2 另见 math_comb.go 中的「一些组合问题」 有 copypasta/dp.go:322
2800 CF2034F2 如果状态转移左右两边都包含 f[i]，则需要移项化简 todo 复习 有 copypasta/dp.go:2445
2800 CF2107F2 思考：三维凸包优化 DP？ copypasta/dp.go:3908
2900 CF497E 本质不同非空子序列个数 distinct-subsequences-ii
number-of-unique-good-subsequences		 copypasta/dp.go:1252
2900 CF497E 贪心：求 <= N 的最大数 find-sum-of-array-product-of-magical-sequences copypasta/dp.go:3164
3000 CF739E 具体请看下面的代码注释 也可以费用流 maximum-profit-in-job-scheduling
minimum-white-tiles-after-covering-with-carpets		 copypasta/dp.go:4036
3000 CF1152F2 状态设计 值域 插入法 有 copypasta/dp.go:226
3000 CF1152F2 状压 DP 本质上就是在集合与集合之间转移，所以一定要能熟练地把集合语言翻译成位运算 状态设计 值域 插入法 有 copypasta/dp.go:2492
3000 CF1175G 思考：三维凸包优化 DP？ 李超线段树 copypasta/dp.go:3909
3000 CF1320E 换根 DP / 二次扫描法 虚树 有 copypasta/dp.go:4608
3000 CF1342F 状态设计 有 copypasta/dp.go:227
3000 CF1342F 输出方案 shortest-common-supersequence
maximum-points-in-an-archery-competition		 有 copypasta/dp.go:259
3000 CF1342F 将 n 个集合分成尽量多组，使得对于每组，组内所有集合的并集等于全集 状态设计 有 copypasta/dp.go:2761
3100 CF708E 对于 f[i] = sum_j f[j] * |i-j|，可以用前缀和优化 有 copypasta/dp.go:3838
3100 CF720F 具体请看下面的代码注释 maximum-profit-in-job-scheduling
minimum-white-tiles-after-covering-with-carpets		 copypasta/dp.go:4037
3200 CF1025G 如果状态转移左右两边都包含 f[i]，则需要移项化简 鞅与停时定理 有 copypasta/dp.go:2446
3200 CF1349D 如果状态转移左右两边都包含 f[i]，则需要移项化简 鞅与停时定理 copypasta/dp.go:2447
3300 CF582D 贪心：求 <= N 的最大数 模数为 p^a copypasta/dp.go:3170
3300 CF582D 二维数位 DP 模数为 p^a copypasta/dp.go:3548
3300 CF1787H 同上，把这个序列视作 1 2 2 4 2 2，总的修改次数仍然为 11 make-array-non-decreasing-or-non-increasing copypasta/dp.go:663
3500 CF1479E 如果状态转移左右两边都包含 f[i]，则需要移项化简 鞅与停时定理 copypasta/dp.go:2448
CF2B NOTE:（区间 DP）正向计算不易时，试着反向计算 new-21-game 有 copypasta/dp.go:297
CF9D 预处理 由 n 个值互不相同的点组成的高度不小于 h 的 BST 有多少个 有 copypasta/dp.go:117
CF10D 最长公共上升子序列 (LCIS) 有 copypasta/dp.go:1124
CF13C 2.3 节 有 copypasta/dp.go:384
CF38E 预处理 有 copypasta/dp.go:118
CF95E 多重背包 Bounded Knapsack 有 copypasta/dp.go:1635
CF106C 多重背包 Bounded Knapsack 有 copypasta/dp.go:1630
CF137D 划分型 DP ① 最优分割 palindrome-partitioning-ii 有 copypasta/dp.go:2088
CF156C 另见 math_comb.go 中的「多重集组合数」容斥做法 也可以用容斥 有 copypasta/dp.go:1719
CF176B 预处理 有 copypasta/dp.go:113
CF238C 对于每个点，统计往上走能到哪些同色点（中途不能经过同色点） 做到 O(n) ~2400 有 copypasta/dp.go:4198
CF245H 返回一个二维数组 f, f[i][j] 表示 s[i:j+1] 内的回文串的个数 有 copypasta/dp.go:2238
CF283B NOTE: 若状态转移不构成 DAG，请尝试建图+BFS，见： 活用 012 染色 有 copypasta/dp.go:289
CF335B 最长回文子序列 (LPS) 输出具体方案 count-different-palindromic-subsequences
minimum-insertion-steps-to-make-a-string-palindrome		 有 copypasta/dp.go:2214
CF358D 预处理 好题：涉及到相邻状态先后关系的 DP（喂兔子） 有 copypasta/dp.go:119
CF358D 如何消除后效性（通过巧妙地设计状态/发现性质） burst-balloons
remove-boxes		 有 copypasta/dp.go:249
CF446A 预处理 有 copypasta/dp.go:120
CF478D 0-1 背包 EXTRA: 从序列 a 中选若干个数，使其总和为 sum 的方案数 profitable-schemes 有 copypasta/dp.go:1504
CF505C 预处理 copypasta/dp.go:115
CF510D 由于数据范围的原因，采用 map 记忆化 dpMap minimum-number-of-operations-to-make-x-and-y-equal
shopping-offers		 有 copypasta/dp.go:428
CF520E 思维转换 super-egg-drop
number-of-music-playlists		 有 copypasta/dp.go:276
CF543A 注意：「恰好使用 m 个物品」这个条件要当成一种费用来看待 有 copypasta/dp.go:1627
CF603A 预处理 有 copypasta/dp.go:121
CF623B 思维转换 有 copypasta/dp.go:279
CF626F 枚举子集的子集 maximum-students-taking-exam
minimum-incompatibility		 有 copypasta/dp.go:2750
CF628D 数位 DP 有 copypasta/dp.go:3111
CF682D NOTE:（区间 DP）正向计算不易时，试着反向计算 new-21-game 有 copypasta/dp.go:298
CF713C 2.3 节 有 copypasta/dp.go:385
CF718C 如矩阵乘积，矩阵和等等。线段树的区间操作可以应对区间修改问题。 有 copypasta/dp.go:3870
CF730J 0-1 背包 EXTRA: 恰好装满 有 copypasta/dp.go:1439
CF739E O(n√nw) 的 shuffle 做法（这里 w=max(wi)） copypasta/dp.go:1363
CF750E 如矩阵乘积，矩阵和等等。线段树的区间操作可以应对区间修改问题。 有 copypasta/dp.go:3871
CF762E CDQ 分治优化 DP 有 copypasta/dp.go:4151
CF811C 预处理 处理区间元素不能在区间外面的技巧 https://codeforces.com/contest/811/submission/174568255 有 copypasta/dp.go:122
CF837D f[i][j] 表示前 i 个数，凑成 j 的所有方案中，最小下标的最大值 partition-equal-subset-sum
ones-and-zeroes		 有 copypasta/dp.go:1420
CF838E 思维转换 super-egg-drop
number-of-music-playlists		 copypasta/dp.go:273
CF848C CDQ 分治优化 DP copypasta/dp.go:4150
CF855E 数位 DP 有 copypasta/dp.go:3112
CF864E 贪心优化 DP 有 copypasta/dp.go:335
CF883I 思维转换 super-egg-drop
number-of-music-playlists		 有 copypasta/dp.go:277
CF883I 双指针优化 DP 有 copypasta/dp.go:338
CF917B 转移：让「自己与对手的分差」最大 有 copypasta/dp.go:2343
CF922E 多重背包 - 未优化 （由于要取 min 所以不能用二进制优化） 有 copypasta/dp.go:1644
CF959C 求最小顶点覆盖，以及所有最小顶点覆盖中，两端点都被覆盖的边的最大个数 有 copypasta/dp.go:4491
CF999F 多重背包 Bounded Knapsack copypasta/dp.go:1634
CF1032F 树上完美匹配子集个数 copypasta/dp.go:4577
CF1036C 数位 DP 有 copypasta/dp.go:3108
CF1045G CDQ 分治优化 DP https://codeforces.com/problemset/problem/762/E 有 copypasta/dp.go:4151
CF1102F 旅行商问题 travelling salesman problem TSP 有 copypasta/dp.go:2641
CF1120C 预处理 有 copypasta/dp.go:123
CF1149B 如矩阵乘积，矩阵和等等。线段树的区间操作可以应对区间修改问题。 有 copypasta/dp.go:3872
CF1163D 预处理 与 KMP 结合 有 copypasta/dp.go:124
CF1168C 预处理 有 copypasta/dp.go:125
CF1223D 思维转换 super-egg-drop
number-of-music-playlists		 有 copypasta/dp.go:274
CF1225E 思维转换 number-of-music-playlists 有 copypasta/dp.go:278
CF1272F NOTE: 若状态转移不构成 DAG，请尝试建图+BFS，见： 有 copypasta/dp.go:290
CF1304D LIS 相关构造题 有 copypasta/dp.go:1114
CF1324E 预处理 有 copypasta/dp.go:114
CF1354E 允许物品重量为 0 minimize-the-difference-between-target-and-chosen-elements 有 copypasta/dp.go:1809
CF1359D 也可以前后缀分解 maximum-sum-circular-subarray 有 copypasta/dp.go:505
CF1380F 如矩阵乘积，矩阵和等等。线段树的区间操作可以应对区间修改问题。 有 copypasta/dp.go:3869
CF1420C2 有两种思路： minimum-number-of-increments-on-subarrays-to-form-a-target-array
best-time-to-buy-and-sell-stock-ii		 有 copypasta/dp.go:618
CF1442D 分治 DP 有 copypasta/dp.go:2337
CF1479B2 交替 DP 有 copypasta/dp.go:303
CF1542D 预处理 有 copypasta/dp.go:126
CF1542D 思维转换 super-egg-drop
number-of-music-playlists		 有 copypasta/dp.go:275
CF1554B 对于位运算的题，直接把 a[i] 当作 T 有 copypasta/dp.go:2970
CF1582F1 常见于递增子序列相关的题目 maximize-consecutive-elements-in-an-array-after-modification 有 copypasta/dp.go:264
CF1591F 状态设计 copypasta/dp.go:216
CF1624E 思维转换 有 copypasta/dp.go:280
CF1637D 允许物品重量为 0 minimize-the-difference-between-target-and-chosen-elements 有 copypasta/dp.go:1810
CF1670F 另一种情况 有 copypasta/dp.go:3505
CF1673C 0-1 背包 EXTRA: 从序列 a 中选若干个数，使其总和为 sum 的方案数 ways-to-express-an-integer-as-sum-of-powers
profitable-schemes		 有 copypasta/dp.go:1502
CF1692H 除了返回最大子段和外，还返回最大子段和对应的子段 [l,r] copypasta/dp.go:544
CF1692H 维护前缀和的最小值的写法 copypasta/dp.go:566
CF1695C 介值定理 有 copypasta/dp.go:145
CF1710C 贪心：求 <= N 的最大数 maximum-number-of-balls-in-a-box
count-symmetric-integers		 有 copypasta/dp.go:3144
CF1738C 转移：让「自己与对手的分差」最大 stone-game-ii
stone-game-iii		 有 copypasta/dp.go:2352
CF1746D 由于数据范围的原因，采用 map 记忆化 dpMap minimum-number-of-operations-to-make-x-and-y-equal
shopping-offers		 有 copypasta/dp.go:429
CF1796D 《算法导论》练习 4.1-5 有 copypasta/dp.go:493
CF1842C 数据结构优化 DP 有 copypasta/dp.go:3787
CF1843F2 有三种思路 maximum-subarray copypasta/dp.go:478
CF1845E 预处理 copypasta/dp.go:127
CF1881F 换根 DP / 二次扫描法 minimum-height-trees 有 copypasta/dp.go:4590
CF1926F 枚举子集的子集 find-minimum-time-to-finish-all-jobs
maximum-students-taking-exam		 有 copypasta/dp.go:2748
CF1932F 常规题目 有 copypasta/dp.go:191
CF1950G 输入的 g 是邻接矩阵，第二维度压缩成一个 int 有 copypasta/dp.go:2678
CF2043C 介值定理 有 copypasta/dp.go:146
CF2104F 贪心：求 <= N 的最大数 find-sum-of-array-product-of-magical-sequences copypasta/dp.go:3163
CF2121E 贪心：求 <= N 的最大数 只用到了思想，无需记忆化 maximum-number-of-balls-in-a-box
count-symmetric-integers		 有 copypasta/dp.go:3143
CFEDU-I 关于「超大背包问题」见 search.go Codeforces EDU copypasta/dp.go:1409
CF104337B 贪心：求 <= N 的最大数 【妙】数位众数，把 freq 排序作为 key copypasta/dp.go:3165
CF104373J 变形：两个异色点的最远距离 https://www.luogu.com.cn/problem/P9665 copypasta/dp.go:4275

图论

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
1200 CF489B 超级源点连左部，右部连超级汇点，所有边的容量均为 1，最大流即为最大匹配 有 copypasta/graph_flow.go:81
1300 CF862B 注：二分图也叫偶图 考察定义 树至多加多少条边仍然是二分图 is-graph-bipartite
possible-bipartition		 有 copypasta/graph.go:3118
1300 CF1675D 简单 DFS 树分成尽量少的链 有 copypasta/graph_tree.go:32
1300 CF1948C 网格图 DFS pacific-atlantic-water-flow
making-a-large-island		 有 copypasta/graph_grid.go:23
1400 CF1670C 更简单的做法是倍增 无向图 longest-cycle-in-a-graph 有 copypasta/graph.go:3965
1400 CF1714E 反复迭代 a <- a + a%10 有 copypasta/graph.go:4677
1400 CF2034C 网格图 DFS making-a-large-island 有 copypasta/graph_grid.go:24
1500 CF35C 网格图 BFS copypasta/graph_grid.go:31
1500 CF329B 网格图 BFS copypasta/graph_grid.go:32
1500 CF580C 简单 DFS copypasta/graph_tree.go:33
1500 CF744A DFS 有 copypasta/graph.go:164
1500 CF2027C 建图 有 copypasta/graph.go:20
1500 CF2115A BFS 也可以 DP，或者更快的做法 有 copypasta/graph.go:419
1600 CF34D 简单 DFS 有 copypasta/graph_tree.go:34
1600 CF131D 更简单的做法是倍增 【无向图 建反图】 longest-cycle-in-a-graph 有 copypasta/graph.go:3966
1600 CF601A BFS 脑筋急转弯 有 copypasta/graph.go:421
1600 CF616C 网格图 DFS pacific-atlantic-water-flow
making-a-large-island		 copypasta/graph_grid.go:20
1600 CF659E DFS 有 copypasta/graph.go:165
1600 CF689B BFS 最短路模板题 有 copypasta/graph.go:420
1600 CF723D 网格图 DFS making-a-large-island copypasta/graph_grid.go:25
1600 CF1511D 模板题（输出边） 构造 valid-arrangement-of-pairs
cracking-the-safe		 copypasta/graph.go:739
1600 CF1530D 更简单的做法是倍增 把基环树拆分成若干条链，然后把这些链合并成一个大环 longest-cycle-in-a-graph 有 copypasta/graph.go:3967
1600 CF1833E 更简单的做法是倍增 longest-cycle-in-a-graph 有 copypasta/graph.go:3963
1700 CF229B st 也可以是一个点集，这相当于同时对多个点跑最短路 二分 有 copypasta/graph.go:1521
1700 CF295B EXTRA: 打印负环 动态加点 有 copypasta/graph.go:1949
1700 CF598D 网格图 DFS 有 copypasta/graph_grid.go:26
1700 CF765D 建图 有 copypasta/graph.go:21
1700 CF1027D 更简单的做法是倍增 有 copypasta/graph.go:3969
1700 CF1093D 注：二分图也叫偶图 is-graph-bipartite
possible-bipartition		 有 copypasta/graph.go:3119
1700 CF1176E DFS 有 copypasta/graph.go:167
1700 CF1204C EXTRA: 打印负环 有 copypasta/graph.go:1950
1700 CF1365D 网格图 DFS 有 copypasta/graph_grid.go:27
1700 CF1406C 树的重心是点分治中的一个划分步骤 求两个重心 有 copypasta/graph_tree.go:721
1700 CF1873H 更简单的做法是倍增 复杂分类讨论 longest-cycle-in-a-graph copypasta/graph.go:3968
1700 CF1881F 可以用来判断有向图是否有环、求 DAG 上的 DP 等 largest-color-value-in-a-directed-graph
minimum-height-trees		 有 copypasta/graph.go:3555
1700 CF2018C BFS 有 copypasta/graph_tree.go:46
1700 CF2023B st 也可以是一个点集，这相当于同时对多个点跑最短路 建模 有 copypasta/graph.go:1522
1700 CF2041D 网格图 BFS copypasta/graph_grid.go:33
1700 CF2110D 可以用来判断有向图是否有环、求 DAG 上的 DP 等 parallel-courses-iii
largest-color-value-in-a-directed-graph		 有 copypasta/graph.go:3552
1783 CF1783F 正则就是所有点的度数都一样 题解 https://www.luogu.com.cn/blog/DaiRuiChen007/CFF copypasta/graph.go:3257
1794 CF1794E 与换根 DP 结合： 参考代码 https://codeforces.com/contest//submission/196015876 copypasta/graph_tree.go:125
1800 CF33B EXTRA: 打印负环 有 copypasta/graph.go:1951
1800 CF161D 或者说，每个点至多被 O(log n) 个在重心拐弯的路径覆盖 有 copypasta/graph_tree.go:771
1800 CF161D 但是，这里的重儿子不再是子树大小最大的，而是深度最大的子节点（长儿子） 距离等于 k 的点对数 有 copypasta/graph_tree.go:1943
1800 CF161D 树上启发式合并 DSU on tree / small to large 距离等于 k 的点对数 有 copypasta/graph_tree.go:2097
1800 CF173B 0-1 最短路 / 0-1 BFS 有 copypasta/graph.go:1809
1800 CF645D 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 有 copypasta/graph.go:3558
1800 CF721C 可以用来判断有向图是否有环、求 DAG 上的 DP 等 parallel-courses-iii
largest-color-value-in-a-directed-graph		 有 copypasta/graph.go:3553
1800 CF1063B 0-1 最短路 / 0-1 BFS 有 copypasta/graph.go:1810
1800 CF1076D 最短路树 最短路树上跑拓扑排序 number-of-restricted-paths-from-first-to-last-node 有 copypasta/graph.go:1562
1800 CF1426E 如果满流，则表示恰好选了 lim 个元素 完全二分图 + 多对多 有 copypasta/graph_flow.go:759
1800 CF1437C 带权二分图匹配 有 copypasta/graph_flow.go:87
1800 CF1437C 这样跑 MCMF 得到的结果是匹配全部 A（或 B）的最小花费 有 copypasta/graph_flow.go:253
1800 CF1437C 如果满流，则表示恰好选了 lim 个元素 完全二分图 + 一对一 有 copypasta/graph_flow.go:760
1800 CF1468J 边权 [0,1] 的随机完全图的 MST 权值和是 ζ(3) = 1.202… 分类讨论 有 copypasta/graph.go:2322
1800 CF1525D 如果满流，则表示恰好选了 lim 个元素 完全二分图 + 一对一 有 copypasta/graph_flow.go:761
1800 CF1572A 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 sequence-reconstruction 有 copypasta/graph.go:3560
1800 CF1721D BFS 带撤销的 BFS 有 copypasta/graph.go:422
1800 CF1725M st 也可以是一个点集，这相当于同时对多个点跑最短路 分层图最短路 有 copypasta/graph.go:1523
1800 CF1805D 反例： tree-diameter 有 copypasta/graph_tree.go:522
1800 CF1851F BFS 带撤销的 BFS 有 copypasta/graph.go:423
1800 CF1915G st 也可以是一个点集，这相当于同时对多个点跑最短路 双关键字 copypasta/graph.go:1524
1900 CF20C st 也可以是一个点集，这相当于同时对多个点跑最短路 有 copypasta/graph.go:1515
1900 CF25C EXTRA: 打印负环 动态加边 copypasta/graph.go:1952
1900 CF25C 动态加边 copypasta/graph.go:2004
1900 CF41E a(n) = C(n, 2)-n/2+1 n%2==1 构造 有 copypasta/graph.go:54
1900 CF685B 树的重心是点分治中的一个划分步骤 求每棵子树的重心 有 copypasta/graph_tree.go:722
1900 CF691E EXTRA: 打印负环 传递闭包+矩阵快速幂 有 copypasta/graph.go:1953
1900 CF711D 更简单的做法是倍增 longest-cycle-in-a-graph 有 copypasta/graph.go:3964
1900 CF1076E 与深度时间戳结合，二分求某个子树在某个深度的节点范围 有 copypasta/graph_tree.go:427
1900 CF1095F 边权 [0,1] 的随机完全图的 MST 权值和是 ζ(3) = 1.202… 边权为 a[i]+a[j] 的混合 MST 有 copypasta/graph.go:2323
1900 CF1242B 反图的连通分量 O(n+m) copypasta/graph.go:3028
1900 CF1245D 有些题目需要在连通分量上求 MST，这时就需要用到 root 超级源点 打印方案 min-cost-to-connect-all-points 有 copypasta/graph.go:2396
1900 CF1272E BFS 建模 有 copypasta/graph.go:424
1900 CF1328E 另见后面的 inOutTimestamp 例题 minimum-score-after-removals-on-a-tree
check-if-dfs-strings-are-palindromes		 有 copypasta/graph_tree.go:297
1900 CF1360G 注意这题用到了操纵超级源点的技巧：容量限制与解除容量限制 网格模型 有 copypasta/graph_flow.go:119
1900 CF1404B 反例： tree-diameter 有 copypasta/graph_tree.go:523
1900 CF1651D 网格图 DFS pacific-atlantic-water-flow 有 copypasta/graph_grid.go:18
1900 CF1842D st 也可以是一个点集，这相当于同时对多个点跑最短路 转换 copypasta/graph.go:1525
1900 CF1846G st 也可以是一个点集，这相当于同时对多个点跑最短路 吃药 状压 有 copypasta/graph.go:1526
1900 CF1899G 另见后面的 inOutTimestamp minimum-score-after-removals-on-a-tree
check-if-dfs-strings-are-palindromes		 有 copypasta/graph_tree.go:298
1900 CF1927F DFS 找包含指定边的环 有 copypasta/graph.go:168
1900 CF2154D 黑白染色 奇偶层染色 有 copypasta/graph_tree.go:41
1900 CF2154D 对于无向树，BFS 序的逆序就是拓扑序 有 copypasta/graph_tree.go:50
2000 CF33D O(n) kth-ancestor-of-a-tree-node copypasta/graph_tree.go:1153
2000 CF237E 这样跑 MCMF 得到的结果是匹配全部 A（或 B）的最小花费 | 代码 https://codeforces.com/problemset/submission/237/241222973 有 copypasta/graph_flow.go:252
2000 CF237E 要求初始网络中无负权圈 有 copypasta/graph_flow.go:748
2000 CF337D 反例： tree-diameter 有 copypasta/graph_tree.go:524
2000 CF337D 从任意直径的两个端点出发跑 DFS，取最大值 有 copypasta/graph_tree.go:637
2000 CF383C 另见后面的 inOutTimestamp minimum-score-after-removals-on-a-tree
check-if-dfs-strings-are-palindromes		 有 copypasta/graph_tree.go:300
2000 CF412D a(n) = C(n, 2)-n/2+1 n%2==1 归纳 有 copypasta/graph.go:55
2000 CF449B st 也可以是一个点集，这相当于同时对多个点跑最短路 【理解本质】通过最短路找到可以删除的边 有 copypasta/graph.go:1527
2000 CF468B A,B 同时或都不在 (¬(A^B)) A⇒B, B⇒A, ¬A⇒¬B, ¬B⇒¬A 建边练习 有 copypasta/graph.go:3875
2000 CF540C 综合 有 copypasta/graph_grid.go:45
2000 CF545E st 也可以是一个点集，这相当于同时对多个点跑最短路 MST 有 copypasta/graph.go:1528
2000 CF877E 另见后面的 inOutTimestamp minimum-score-after-removals-on-a-tree
check-if-dfs-strings-are-palindromes		 有 copypasta/graph_tree.go:299
2000 CF938D st 也可以是一个点集，这相当于同时对多个点跑最短路 超级源点 有 copypasta/graph.go:1530
2000 CF999E 强连通分量分解 Strongly Connected Component (SCC) 有 copypasta/graph.go:3645
2000 CF1142B 更简单的做法是倍增 可以做到线性 有 copypasta/graph.go:3970
2000 CF1304E O(n) kth-ancestor-of-a-tree-node 有 copypasta/graph_tree.go:1154
2000 CF1385E 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 混合图拓扑排序+定向 sequence-reconstruction 有 copypasta/graph.go:3561
2000 CF1702G2 if nodes[v].l > nodes[w].l { v, w = w, v } minimum-score-after-removals-on-a-tree 有 copypasta/graph_tree.go:345
2000 CF1702G2 O(n) 分类讨论 kth-ancestor-of-a-tree-node 有 copypasta/graph_tree.go:1155
2000 CF1702G2 如果 to 不是 v 的子孙，返回 -1 判断节点列表能否连成线（在某条路径上） 有 copypasta/graph_tree.go:1279
2000 CF1770D 更简单的做法是倍增 有 copypasta/graph.go:3971
2000 CF1857G 完全图找个最小的 a[i] 和其余点连边 有 copypasta/graph.go:2325
2000 CF1941G 0-1 最短路 / 0-1 BFS 也可以 BFS（需要合适的建图方式） 有 copypasta/graph.go:1811
2024 CF527120B 提示：结合【贡献法】 CCPC 上海市赛 copypasta/graph_tree.go:1005
2100 CF190E 反图的连通分量 O(n+m) 有 copypasta/graph.go:3029
2100 CF208E 与深度时间戳结合，二分求某个子树在某个深度的节点范围 有 copypasta/graph_tree.go:428
2100 CF208E 但是，这里的重儿子不再是子树大小最大的，而是深度最大的子节点（长儿子） 树上 k 级祖先 有 copypasta/graph_tree.go:1944
2100 CF208E 树上启发式合并 DSU on tree / small to large 有 copypasta/graph_tree.go:2099
2100 CF269C 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 构造 sequence-reconstruction 有 copypasta/graph.go:3562
2100 CF321C 或者说，每个点至多被 O(log n) 个在重心拐弯的路径覆盖 有 copypasta/graph_tree.go:772
2100 CF343D 注：如果只有路径修改+查询，可以用欧拉序列 + 树状数组/线段树，见《挑战》p.332 有 copypasta/graph_tree.go:1826
2100 CF455C 反例： 两棵树连边，连边之后直径最小 tree-diameter 有 copypasta/graph_tree.go:525
2100 CF498C 注意这题用到了操纵超级源点的技巧：容量限制与解除容量限制 建模题，推荐 有 copypasta/graph_flow.go:120
2100 CF498C 给一 DAG，求它的最大反链大小、一组最大反链构造以及所有最大反链的并 最大流 建模 有 copypasta/graph_flow.go:346
2100 CF507E st 也可以是一个点集，这相当于同时对多个点跑最短路 双关键字+记录路径编号 minimum-cost-to-buy-apples 有 copypasta/graph.go:1533
2100 CF519E O(n) 到两点距离相同的点的数量 kth-ancestor-of-a-tree-node 有 copypasta/graph_tree.go:1157
2100 CF546E 注意这题用到了操纵超级源点的技巧：容量限制与解除容量限制 有 copypasta/graph_flow.go:121
2100 CF546E 给一 DAG，求它的最大反链大小、一组最大反链构造以及所有最大反链的并 模板题 输出具体方案 有 copypasta/graph_flow.go:347
2100 CF546E EXTRA: 求流的分配方案（即反向边上的 cap） 有 copypasta/graph_flow.go:456
2100 CF609E O(n) maximize-value-of-function-in-a-ball-passing-game
minimum-edge-weight-equilibrium-queries-in-a-tree		 有 copypasta/graph_tree.go:1179
2100 CF609E EXTRA: 倍增的时候维护其他属性，如边权最值等 有 copypasta/graph_tree.go:1366
2100 CF609E 也可以转换成子树所有点的 dis 都增加了 delta，用欧拉序+差分树状数组维护 与最小生成树结合（边权） 有 copypasta/graph_tree.go:1829
2100 CF620E 另见后面的 inOutTimestamp minimum-score-after-removals-on-a-tree
check-if-dfs-strings-are-palindromes		 有 copypasta/graph_tree.go:301
2100 CF702E 如果题目涉及到基环树上的路径，用倍增会更简单 find-closest-node-to-given-two-nodes
maximize-value-of-function-in-a-ball-passing-game		 copypasta/graph.go:3960
2100 CF734E 反例： 转换的好题 tree-diameter
find-minimum-diameter-after-merging-two-trees		 有 copypasta/graph_tree.go:527
2100 CF788B a(n) = C(n, 2)-n/2+1 n%2==1 转换 有 copypasta/graph.go:56
2100 CF877D 0-1 最短路 / 0-1 BFS 也可以 BFS 有 copypasta/graph.go:1812
2100 CF920E 反图的连通分量 O(n+m) 有 copypasta/graph.go:3030
2100 CF1000E 反例： e-BCC find-minimum-diameter-after-merging-two-trees 有 copypasta/graph_tree.go:528
2100 CF1005F st 也可以是一个点集，这相当于同时对多个点跑最短路 minimum-cost-to-buy-apples 有 copypasta/graph.go:1534
2100 CF1029E 树上贪心 有 copypasta/graph_tree.go:58
2100 CF1108F 完全图找个最小的 a[i] 和其余点连边 MST 的唯一性 copypasta/graph.go:2327
2100 CF1354E 注：二分图也叫偶图 与分组背包结合 is-graph-bipartite
possible-bipartition		 有 copypasta/graph.go:3120
2100 CF1547G DFS 对每个点 i，判断 1 到 i 有多少条路径（0/1/>=2/∞） 有 copypasta/graph.go:169
2100 CF1547G vis[v] == 2：该顶点已经被访问，其子树已遍历完 find-eventual-safe-states 有 copypasta/graph.go:301
2100 CF1863E 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 与「环形」结合 sequence-reconstruction copypasta/graph.go:3563
2100 CF1971H A,B 同时或都不在 (¬(A^B)) A⇒B, B⇒A, ¬A⇒¬B, ¬B⇒¬A 建边练习 有 copypasta/graph.go:3876
2200 CF553C 注：二分图也叫偶图 染色的技巧 有 copypasta/graph.go:3122
2200 CF567E st 也可以是一个点集，这相当于同时对多个点跑最短路 * 关键边、伪关键边（与割边结合） minimum-cost-to-buy-apples 有 copypasta/graph.go:1535
2200 CF570D 与深度时间戳结合，二分求某个子树在某个深度的节点范围 有 copypasta/graph_tree.go:431
2200 CF570D 树上启发式合并 DSU on tree / small to large 有 copypasta/graph_tree.go:2100
2200 CF587C O(n) checking-existence-of-edge-length-limited-paths
checking-existence-of-edge-length-limited-paths-ii		 有 copypasta/graph_tree.go:1185
2200 CF587C 也可以转换成子树所有点的 dis 都增加了 delta，用欧拉序+差分树状数组维护 归并树 有 copypasta/graph_tree.go:1830
2200 CF590C 0-1 最短路 / 0-1 BFS 网格图 有 copypasta/graph.go:1813
2200 CF653D 注意这题用到了操纵超级源点的技巧：容量限制与解除容量限制 转换 有 copypasta/graph_flow.go:122
2200 CF662B 注：二分图也叫偶图 染色的技巧 copypasta/graph.go:3123
2200 CF723E a(n) = C(n, 2)-n/2+1 n%2==1 加边 有 copypasta/graph.go:57
2200 CF723E 模板题（输出边） 虚点 valid-arrangement-of-pairs
cracking-the-safe		 有 copypasta/graph.go:740
2200 CF733F 完全图找个最小的 a[i] 和其余点连边 与 LCA 结合 有 copypasta/graph.go:2328
2200 CF733F O(n) maximize-value-of-function-in-a-ball-passing-game
minimum-edge-weight-equilibrium-queries-in-a-tree		 有 copypasta/graph_tree.go:1180
2200 CF821D 0-1 最短路 / 0-1 BFS 建图技巧 有 copypasta/graph.go:1814
2200 CF915D 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 好题 sequence-reconstruction 有 copypasta/graph.go:3564
2200 CF980E O(n) 有 copypasta/graph_tree.go:1191
2200 CF1037E 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 拓扑思想 sequence-reconstruction 有 copypasta/graph.go:3565
2200 CF1100E 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 混合图拓扑排序+定向 有 copypasta/graph.go:3566
2200 CF1105E if !d { 有 copypasta/graph.go:4386
2200 CF1196F a(n) = C(n, 2)-n/2+1 n%2==1 第k小路径 有 copypasta/graph.go:58
2200 CF1283F 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 与堆结合 有 copypasta/graph.go:3567
2200 CF1335F 更简单的做法是倍增 有 copypasta/graph.go:3972
2200 CF1470D DFS 先染色，再递归 有 copypasta/graph.go:170
2200 CF1486E st 也可以是一个点集，这相当于同时对多个点跑最短路 涉及到相邻两条边的最短路 minimum-cost-to-buy-apples 有 copypasta/graph.go:1536
2200 CF1535E O(n) copypasta/graph_tree.go:1158
2200 CF1535E 从 v 开始，向上跳到指定深度 d copypasta/graph_tree.go:1225
2200 CF1537F 注：二分图也叫偶图 possible-bipartition copypasta/graph.go:3121
2200 CF1635E 建图 有 copypasta/graph.go:22
2200 CF1848D 反复迭代 a <- a + a%10 copypasta/graph.go:4678
2200 CF1907G 更简单的做法是倍增 有 copypasta/graph.go:3973
2200 CF2118D2 如果无论 v 怎么走，都会走到环中（无限走下去），返回 false 有 copypasta/graph.go:206
2200 CF2118D2 完全图找个最小的 a[i] 和其余点连边 有 copypasta/graph.go:2329
2300 CF78E 超级源点连左部，右部连超级汇点，所有边的容量均为 1，最大流即为最大匹配 有 copypasta/graph_flow.go:82
2300 CF160D 完全图找个最小的 a[i] 和其余点连边 关键边、伪关键边（与割边结合） 有 copypasta/graph.go:2331
2300 CF294E 树中所有点到某个点的距离和中，到重心的距离和是最小的；如果有两个重心，那么距离和一样 有 copypasta/graph_tree.go:701
2300 CF294E 树的重心是点分治中的一个划分步骤 有 copypasta/graph_tree.go:723
2300 CF311E 对于左部，不割表示选，割表示不选，要反过来思考 建图设计 有 copypasta/graph_flow.go:58
2300 CF600E 树上启发式合并 DSU on tree / small to large 有 copypasta/graph_tree.go:2101
2300 CF708C 树的重心是点分治中的一个划分步骤 Edge replacement 后哪些点可以是重心 copypasta/graph_tree.go:724
2300 CF715B st 也可以是一个点集，这相当于同时对多个点跑最短路 https://leetcode.cn/problems/modify-graph-edge-weights/ modify-graph-edge-weights 有 copypasta/graph.go:1537
2300 CF786B st 也可以是一个点集，这相当于同时对多个点跑最短路 线段树优化建图 modify-graph-edge-weights 有 copypasta/graph.go:1538
2300 CF788C a(n) = C(n, 2)-n/2+1 n%2==1 转换 有 copypasta/graph.go:59
2300 CF825E 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 与堆结合 有 copypasta/graph.go:3568
2300 CF891C 完全图找个最小的 a[i] 和其余点连边 判断给定的边是否均在同一棵 MST 中 有 copypasta/graph.go:2330
2300 CF893F 另见后面的 inOutTimestamp 可持久化线段树 check-if-dfs-strings-are-palindromes 有 copypasta/graph_tree.go:302
2300 CF1009F 具体实现时还有一些技巧，见后面的有关 DP 优化的 EXTRA 子树深度众数 有 copypasta/graph_tree.go:1950
2300 CF1009F 树上启发式合并 DSU on tree / small to large 有 copypasta/graph_tree.go:2102
2300 CF1200F 更简单的做法是倍增 拆点 有 copypasta/graph.go:3974
2300 CF1528C 另见后面的 inOutTimestamp 好题（需要充分利用入出时间戳的性质） 有 copypasta/graph_tree.go:303
2300 CF1693C st 也可以是一个点集，这相当于同时对多个点跑最短路 转换 modify-graph-edge-weights 有 copypasta/graph.go:1540
2300 CF1790G BFS 锻炼分类讨论能力 copypasta/graph.go:426
2300 CF1805E 树上启发式合并 DSU on tree / small to large copypasta/graph_tree.go:2103
2300 CF1843F2 O(n) checking-existence-of-edge-length-limited-paths
checking-existence-of-edge-length-limited-paths-ii		 copypasta/graph_tree.go:1186
2300 CF1878G O(n) checking-existence-of-edge-length-limited-paths
checking-existence-of-edge-length-limited-paths-ii		 copypasta/graph_tree.go:1187
2300 CF1955H 网格图 BFS escape-the-spreading-fire copypasta/graph_grid.go:37
2300 CF2002D2 另见后面的 inOutTimestamp copypasta/graph_tree.go:304
2400 CF21D 模板题（输出边） 可以重复经过边的欧拉回路 valid-arrangement-of-pairs
cracking-the-safe		 copypasta/graph.go:741
2400 CF209C 模板题（输出边） 添加边使得图存在欧拉回路 valid-arrangement-of-pairs
cracking-the-safe		 有 copypasta/graph.go:742
2400 CF246E 与深度时间戳结合，二分求某个子树在某个深度的节点范围 CF208E + 离线 有 copypasta/graph_tree.go:432
2400 CF246E 树上启发式合并 DSU on tree / small to large 有 copypasta/graph_tree.go:2104
2400 CF258E 另见后面的 inOutTimestamp 有 copypasta/graph_tree.go:305
2400 CF375D 树上启发式合并 DSU on tree / small to large 有 copypasta/graph_tree.go:2105
2400 CF379F 反例： find-minimum-diameter-after-merging-two-trees 有 copypasta/graph_tree.go:529
2400 CF379F O(n) 有 copypasta/graph_tree.go:1159
2400 CF467D 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 缩点后的反图拓扑序 DP 有 copypasta/graph.go:3569
2400 CF467D 强连通分量分解 Strongly Connected Component (SCC) 缩点 + DAG DP 有 copypasta/graph.go:3646
2400 CF593D O(n) 单边修改，输出 floor(val / 路径边权乘积) 只需模拟 LCA 有 copypasta/graph_tree.go:1160
2400 CF632F a(n) = C(n, 2)-n/2+1 n%2==1 转换 copypasta/graph.go:60
2400 CF632F 完全图找个最小的 a[i] 和其余点连边 find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree copypasta/graph.go:2333
2400 CF653E 反图的连通分量 O(n+m) 单点度数限制 有 copypasta/graph.go:3031
2400 CF679C 网格图 DFS 有 copypasta/graph_grid.go:28
2400 CF802N 如果满流，则表示恰好选了 lim 个元素 时间约束：从第 i 天连向第 i+1 天，容量 inf（延后无限制），费用 0（等待不花钱） 有 copypasta/graph_flow.go:762
2400 CF911F 反例： 贪心 find-minimum-diameter-after-merging-two-trees 有 copypasta/graph_tree.go:530
2400 CF911F 从任意直径的两个端点出发跑 DFS，取最大值 有 copypasta/graph_tree.go:638
2400 CF914E 或者说，每个点至多被 O(log n) 个在重心拐弯的路径覆盖 有 copypasta/graph_tree.go:773
2400 CF914E 5. 去掉整个重心连通块的数据，处理下一个重心连通块 为例 有 copypasta/graph_tree.go:876
2400 CF916E 另见后面的 inOutTimestamp 有 copypasta/graph_tree.go:306
2400 CF916E 返回 [f 是 v 的祖先节点] 有 copypasta/graph_tree.go:420
2400 CF916E O(n) 有 copypasta/graph_tree.go:1161
2400 CF916E 如果 to 不是 v 的子孙，返回 -1 有 copypasta/graph_tree.go:1280
2400 CF1004E 反例： 直径的性质 find-minimum-diameter-after-merging-two-trees copypasta/graph_tree.go:531
2400 CF1038E 模板题（输出边） 删除边使得图存在欧拉路径 valid-arrangement-of-pairs
cracking-the-safe		 有 copypasta/graph.go:743
2400 CF1059E 如果求【至少】d 距离的目标节点，可以改成往上跳至多 d-1，然后再往上跳一个节点 find-weighted-median-node-in-tree 有 copypasta/graph_tree.go:1261
2400 CF1059E EXTRA: 倍增的时候维护其他属性，如边权最值等 有 copypasta/graph_tree.go:1369
2400 CF1082G 对于左部，不割表示选，割表示不选，要反过来思考 有 copypasta/graph_flow.go:59
2400 CF1139E 正则就是所有点的度数都一样 有 copypasta/graph.go:3255
2400 CF1139E 常见于棋盘放置 1x2 骨牌，或者一些排列型约束的题目 有 copypasta/graph.go:3297
2400 CF1174F 或者说，每个点至多被 O(log n) 个在重心拐弯的路径覆盖 有 copypasta/graph_tree.go:774
2400 CF1174F 也可以转换成子树所有点的 dis 都增加了 delta，用欧拉序+差分树状数组维护 好题 有 copypasta/graph_tree.go:1831
2400 CF1186F 模板题（输出边） cracking-the-safe copypasta/graph.go:744
2400 CF1210D 因此枚举的复杂度为 ∑in[w]*out[w] 满足点权 a > b > c 的长为 3 的路径个数 paths-in-maze-that-lead-to-same-room 有 copypasta/graph.go:4483
2400 CF1340C 0-1 最短路 / 0-1 BFS 建图技巧 有 copypasta/graph.go:1815
2400 CF1369E 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 安排吃菜顺序 有 copypasta/graph.go:3570
2400 CF1408E 完全图找个最小的 a[i] 和其余点连边 二分图无环 find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree 有 copypasta/graph.go:2334
2400 CF1442C st 也可以是一个点集，这相当于同时对多个点跑最短路 分层图最短路 空间压缩 modify-graph-edge-weights 有 copypasta/graph.go:1541
2400 CF1442C 0-1 最短路 / 0-1 BFS 有 copypasta/graph.go:1816
2400 CF1463E 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 缩点后的拓扑序 有 copypasta/graph.go:3571
2400 CF1473E st 也可以是一个点集，这相当于同时对多个点跑最短路 分层图最短路 转换 modify-graph-edge-weights 有 copypasta/graph.go:1542
2400 CF1491E 其它 有 copypasta/graph_tree.go:77
2400 CF1527D if nodes[v].l > nodes[w].l { v, w = w, v } minimum-score-after-removals-on-a-tree 有 copypasta/graph_tree.go:346
2400 CF1527D O(n) 分类讨论（思路同 CF1702G2，但不需要倍增） kth-ancestor-of-a-tree-node 有 copypasta/graph_tree.go:1156
2400 CF1578L 把边权信息转化成点权信息 有 copypasta/graph.go:2878
2400 CF1615E 树上贪心 有 copypasta/graph_tree.go:59
2400 CF1615E 具体实现时还有一些技巧，见后面的有关 DP 优化的 EXTRA 至多 k 条不相交链 有 copypasta/graph_tree.go:1951
2400 CF1633E 完全图找个最小的 a[i] 和其余点连边 绝对值 MST find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree copypasta/graph.go:2335
2400 CF1707C DFS 与 MST 结合 有 copypasta/graph.go:171
2400 CF1707C 完全图找个最小的 a[i] 和其余点连边 与 DFS 搜索树结合 find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree 有 copypasta/graph.go:2336
2400 CF1715E st 也可以是一个点集，这相当于同时对多个点跑最短路 斜率优化 modify-graph-edge-weights 有 copypasta/graph.go:1543
2400 CF1749E 平面图最小割转最短路 有 copypasta/graph.go:39
2400 CF1749E 0-1 最短路 / 0-1 BFS 建图技巧 有 copypasta/graph.go:1817
2400 CF1753D st 也可以是一个点集，这相当于同时对多个点跑最短路 建模+转换+多源最短路 有 copypasta/graph.go:1544
2400 CF1819C 反例： find-minimum-diameter-after-merging-two-trees 有 copypasta/graph_tree.go:532
2400 CF1860E BFS 中转点 Fast Travel Text Editor 有 copypasta/graph.go:427
2400 CF1874B BFS 有 copypasta/graph.go:428
2400 CF1902F O(n) 线性基 有 copypasta/graph_tree.go:1162
2400 CF1913E 注意这题用到了操纵超级源点的技巧：容量限制与解除容量限制 todo copypasta/graph_flow.go:123
2400 CF1936C 建图 宝可梦对战 有 copypasta/graph.go:23
2400 CF1981D 如果 n 是偶数，会去掉一些边 copypasta/graph.go:812
2500 CF152E 返回：连通 k 个关键节点的最小代价 输出方案 copypasta/graph.go:2240
2500 CF416E EXTRA: 打印负环 在最短路上的边 有 copypasta/graph.go:1954
2500 CF605D BFS 线段树二分优化 BFS 有 copypasta/graph.go:429
2500 CF628F 超级源点连左部，右部连超级汇点，所有边的容量均为 1，最大流即为最大匹配 建图设计 有 copypasta/graph_flow.go:84
2500 CF835F 更简单的做法是倍增 去掉（基环上的）一条边后的最小直径 前后缀分解 环形问题 形状设计 有 copypasta/graph.go:3975
2500 CF835F 求一个基环 有 copypasta/graph.go:4082
2500 CF875F 完全图找个最小的 a[i] 和其余点连边 基环树 find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree 有 copypasta/graph.go:2337
2500 CF875F 更简单的做法是倍增 最小生成基环树 有 copypasta/graph.go:3976
2500 CF1111E 但这样做还要再排序，并使用几个额外的数组，所以相比之下直接 DFS 更好 copypasta/graph_tree.go:1667
2500 CF1120D 完全图找个最小的 a[i] 和其余点连边 find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree copypasta/graph.go:2338
2500 CF1253F st 也可以是一个点集，这相当于同时对多个点跑最短路 多源到单源 + 巧妙转化 有 copypasta/graph.go:1546
2500 CF1361C 模板题（输出边） 转换 有 copypasta/graph.go:745
2500 CF1407E BFS 节点涂色 堵路 最大化最短路长度 有 copypasta/graph.go:430
2500 CF1467E 另见后面的 inOutTimestamp 有 copypasta/graph_tree.go:307
2500 CF1508C 反图的连通分量 O(n+m) MST 有 copypasta/graph.go:3032
2500 CF1528D st 也可以是一个点集，这相当于同时对多个点跑最短路 建模【好题】 有 copypasta/graph.go:1548
2500 CF1725E 但这样做还要再排序，并使用几个额外的数组，所以相比之下直接 DFS 更好 copypasta/graph_tree.go:1668
2500 CF1767E if !d { 最小点覆盖 = 所有点 - 最大独立集 有 copypasta/graph.go:4387
2500 CF1824C 树上启发式合并 DSU on tree / small to large 有 copypasta/graph_tree.go:2106
2500 CF1842F 树的重心是点分治中的一个划分步骤 结论 有 copypasta/graph_tree.go:725
2500 CF1994F 模板题（输出边） copypasta/graph.go:746
2500 CF2026E 对于左部，不割表示选，割表示不选，要反过来思考 有 copypasta/graph_flow.go:61
2500 CF2026E 超级源点连左部，右部连超级汇点，所有边的容量均为 1，最大流即为最大匹配 最大权闭合子图 / Hall 定理 有 copypasta/graph_flow.go:83
2500 CF2057E2 EXTRA: 打印负环 动态加边 wt = 0 有 copypasta/graph.go:1955
2500 CF2057E2 动态加边 wt = 0 有 copypasta/graph.go:2005
2600 CF36E 模板题（输出边） 两条欧拉路径的并 copypasta/graph.go:747
2600 CF85E 注：二分图也叫偶图 转换 有 copypasta/graph.go:3124
2600 CF196E st 也可以是一个点集，这相当于同时对多个点跑最短路 传送门 有 copypasta/graph.go:1547
2600 CF196E 完全图找个最小的 a[i] 和其余点连边 传送门 有 copypasta/graph.go:2339
2600 CF241E 这样，在无负环时会得到一组非正数解（先求一组解，然后再全部加上 Δ） minimum-time-to-complete-all-tasks
t3fKg1		 有 copypasta/graph.go:1883
2600 CF346D 0-1 最短路 / 0-1 BFS 结合拓扑排序 有 copypasta/graph.go:1818
2600 CF346D 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 结合 0-1 BFS 有 copypasta/graph.go:3572
2600 CF372D 另见后面的 inOutTimestamp 有 copypasta/graph_tree.go:308
2600 CF372D O(n) 有 copypasta/graph_tree.go:1164
2600 CF527E 模板题（输出边） 有 copypasta/graph.go:748
2600 CF547D 注：二分图也叫偶图 转换 有 copypasta/graph.go:3125
2600 CF568C A,B 同时或都不在 (¬(A^B)) A⇒B, B⇒A, ¬A⇒¬B, ¬B⇒¬A copypasta/graph.go:3879
2600 CF700C 技巧 2：给边权加上很大的数来约束删除次数 推荐 copypasta/graph_flow.go:194
2600 CF741C 注：二分图也叫偶图 转换 有 copypasta/graph.go:3126
2600 CF1107F 如果满流，则表示恰好选了 lim 个元素 maximum-and-sum-of-array
select-cells-in-grid-with-maximum-score		 有 copypasta/graph_flow.go:770
2600 CF1110F 另见后面的 inOutTimestamp 有 copypasta/graph_tree.go:310
2600 CF1209F 路径的点权序列的字典序最小（边权为 1） 有 copypasta/graph.go:554
2600 CF1301F 网格图 BFS BFS 进阶玩法 escape-the-spreading-fire 有 copypasta/graph_grid.go:38
2600 CF1344C 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 ∀ 与 ∃ 有 copypasta/graph.go:3573
2600 CF1416D 另见后面的 inOutTimestamp 有 copypasta/graph_tree.go:311
2600 CF1515F 数学归纳法 有 copypasta/graph.go:34
2600 CF1657F A,B 同时或都不在 (¬(A^B)) A⇒B, B⇒A, ¬A⇒¬B, ¬B⇒¬A copypasta/graph.go:3880
2600 CF1981E 完全图找个最小的 a[i] 和其余点连边 copypasta/graph.go:2340
2600 CF2236G O(n) 树上滑动窗口 有 copypasta/graph_tree.go:1166
2700 CF293E 或者说，每个点至多被 O(log n) 个在重心拐弯的路径覆盖 两个距离约束 copypasta/graph_tree.go:776
2700 CF715C 树上启发式合并 DSU on tree / small to large copypasta/graph_tree.go:2107
2700 CF827D 完全图找个最小的 a[i] 和其余点连边 对于图中每条边，边权至多是多少，能让这条边仍然在所有 MST 中 有 copypasta/graph.go:2341
2700 CF827D O(n) checking-existence-of-edge-length-limited-paths
checking-existence-of-edge-length-limited-paths-ii		 有 copypasta/graph_tree.go:1183
2700 CF827D EXTRA: 倍增的时候维护其他属性，如边权最值等 有 copypasta/graph_tree.go:1368
2700 CF839E 注：求最大独立集等价于求补图的最大团 maximal cliques (MC) 基本不等式 有 copypasta/graph.go:4432
2700 CF1270G 更简单的做法是倍增 构造 建图 有 copypasta/graph.go:3977
2700 CF1515G 强连通分量分解 Strongly Connected Component (SCC) 有 copypasta/graph.go:3647
2700 CF1519E DFS 无向图后向边定向 copypasta/graph.go:172
2700 CF1617E 反例： 转换成求部分直径 有 copypasta/graph_tree.go:533
2800 CF79D BFS 有 copypasta/graph.go:431
2800 CF163E 另见后面的 inOutTimestamp AC 自动机 有 copypasta/graph_tree.go:312
2800 CF516D 反例： copypasta/graph_tree.go:535
2800 CF600F 注：二分图也叫偶图 【边染色】 copypasta/graph.go:3127
2800 CF613D 但这样做还要再排序，并使用几个额外的数组，所以相比之下直接 DFS 更好 入门题 有 copypasta/graph_tree.go:1669
2800 CF776F 或者说，每个点至多被 O(log n) 个在重心拐弯的路径覆盖 copypasta/graph_tree.go:777
2800 CF842E 反例： 动态加点求直径端点个数 有 copypasta/graph_tree.go:536
2800 CF842E O(n) 动态加点求直径端点个数 有 copypasta/graph_tree.go:1167
2800 CF986E O(n) 有 copypasta/graph_tree.go:1168
2800 CF1375G 黑白染色 有 copypasta/graph_tree.go:42
2800 CF1827D 另见后面的 inOutTimestamp 重心性质 有 copypasta/graph_tree.go:313
2800 CF1827D 把两棵树通过一条边相连得到一棵新的树，新重心在旧重心的路径上 有 copypasta/graph_tree.go:705
2800 CF1827D 树的重心是点分治中的一个划分步骤 有 copypasta/graph_tree.go:726
2900 CF19E a(n) = C(n, 2)-n/2+1 n%2==1 有 copypasta/graph.go:61
2900 CF741D 树上启发式合并 DSU on tree / small to large copypasta/graph_tree.go:2108
2900 CF802O 如果满流，则表示恰好选了 lim 个元素 模拟费用流/反悔贪心 copypasta/graph_flow.go:763
2900 CF1062F 拓扑序是否唯一：任意时刻队列中不能有超过一个元素 关键点 次关键点 有 copypasta/graph.go:3574
2900 CF1455G 树上启发式合并 DSU on tree / small to large copypasta/graph_tree.go:2109
3000 CF235D 更简单的做法是倍增 期望 copypasta/graph.go:3978
3000 CF504E 也可以转换成子树所有点的 dis 都增加了 delta，用欧拉序+差分树状数组维护 copypasta/graph_tree.go:1832
3000 CF1149D 完全图找个最小的 a[i] 和其余点连边 只有两种边权的图的 MST 的性质 + 所有 MST 中的单源最短路的最小值 copypasta/graph.go:2342
3000 CF1163F st 也可以是一个点集，这相当于同时对多个点跑最短路 todo 动态最短路 copypasta/graph.go:1549
3000 CF1320E 但这样做还要再排序，并使用几个额外的数组，所以相比之下直接 DFS 更好 换根 DP 有 copypasta/graph_tree.go:1670
3000 CF1763F 注意：只有两个点的点双也要建方点 copypasta/graph.go:1331
3100 CF176E 另见后面的 inOutTimestamp 有 copypasta/graph_tree.go:314
3100 CF176E O(n) 有 copypasta/graph_tree.go:1169
3200 CF487E 注意：只有两个点的点双也要建方点 copypasta/graph.go:1332
3200 CF1666K 对于左部，不割表示选，割表示不选，要反过来思考 copypasta/graph_flow.go:62
3300 CF704E 也可以转换成子树所有点的 dis 都增加了 delta，用欧拉序+差分树状数组维护 copypasta/graph_tree.go:1833
CF25D vis[v] == 2：该顶点已经被访问，其子树已遍历完 find-eventual-safe-states 有 copypasta/graph.go:297
CF117C 拓扑序上，不同 SCC 的点的入度，越靠前的严格越小 copypasta/graph.go:81
CF118E 桥（割边） critical-connections-in-a-network 有 copypasta/graph.go:969
CF125E 点 root 的度数不超过 lim copypasta/graph.go:2525
CF154C a(n) = C(n, 2)-n/2+1 n%2==1 copypasta/graph.go:69
CF156D 普吕弗序列（Prufer 序列，Prüfer sequence） 有 copypasta/graph_tree.go:2356
CF160D 桥（割边） critical-connections-in-a-network 有 copypasta/graph.go:967
CF191C 边权时 diff[lca] -= 2 * val（定义 diff 为点到父亲的差分值） minimize-the-total-price-of-the-trips 有 copypasta/graph_tree.go:1617
CF231E 如果每个点至多在一个环中，则为仙人掌图 仙人掌图 copypasta/graph.go:1240
CF240E todo 另外还有 Tarjan 的 O(m+nlogn) 算法 copypasta/graph.go:2957
CF260D 对于无向树，BFS 序的逆序就是拓扑序 有 copypasta/graph_tree.go:54
CF263D 注：如果只有一个环（基环树），见 pseudotree 有 copypasta/graph.go:356
CF342E 与换根 DP 结合： 有 copypasta/graph_tree.go:128
CF342E 优点是查询的复杂度低，适用于查询量大的情形 有 copypasta/graph_tree.go:1452
CF362E 费用流·建模·转换 copypasta/graph_flow.go:245
CF375D 根节点到树上任意节点的轻边数不超过 O(logn) 条 有 copypasta/graph_tree.go:2190
CF375D 不用 map，而是像莫队那样添加和撤销，这样只需要数组，常数更小 有 copypasta/graph_tree.go:2242
CF427C 强连通分量分解 Strongly Connected Component (SCC) 有 copypasta/graph.go:3641
CF487E 每个点双的点数就是一个极大环的点数 s5kipK copypasta/graph.go:1033
CF487E TODO: 处理边权的情况 copypasta/graph_tree.go:1843
CF507E EXTRA: 从 st 到 end 的任意一条路径 有 copypasta/graph.go:1609
CF550D 桥（割边） copypasta/graph.go:971
CF567E 桥（割边） critical-connections-in-a-network 有 copypasta/graph.go:968
CF570D 重链剖分（见 tree.heavyLightDecomposition） 有 copypasta/graph_tree.go:263
CF592D 找出直径 dv-dw 后，对两个端点各自跑一次 DFS，即可找出全部直径端点 有 copypasta/graph_tree.go:563
CF618D _, _ = isAncestor, isAncestor2 有 copypasta/graph_tree.go:476
CF632F 有些题目需要在连通分量上求 MST，这时就需要用到 root min-cost-to-connect-all-points copypasta/graph.go:2398
CF698B vis[v] == 2：该顶点已经被访问，其子树已遍历完 find-eventual-safe-states 有 copypasta/graph.go:298
CF700B NOTE: 注意特判整棵树只有一条边的情况，此时两个叶结点对应同一条边 有 copypasta/graph_tree.go:22
CF723F a(n) = C(n, 2)-n/2+1 n%2==1 有 copypasta/graph.go:63
CF732F 如果每个点至多在一个环中，则为仙人掌图 有 copypasta/graph.go:1241
CF763D 与换根 DP 结合： copypasta/graph_tree.go:124
CF765E 对于无向树，BFS 序的逆序就是拓扑序 有 copypasta/graph_tree.go:55
CF766E 对于无向树，BFS 序的逆序就是拓扑序 有 copypasta/graph_tree.go:53
CF808F 对于最大点权独立集，其等价于点权之和减去最小点权覆盖集。 有 copypasta/graph_flow.go:227
CF888G 见 trie01.go 中的 xorMST 有 copypasta/graph.go:2519
CF894E 注意这样可能会产生重边，不能有重边时可以用 map 或对每个点排序去重 copypasta/graph.go:3731
CF901C 1 表示不在环上 有 copypasta/graph.go:4584
CF915F 建图 有 copypasta/graph.go:31
CF932D 如果求【至少】d 距离的目标节点，可以改成往上跳至多 d-1，然后再往上跳一个节点 find-weighted-median-node-in-tree copypasta/graph_tree.go:1260
CF936B 奇偶标记法 有 copypasta/graph.go:257
CF936B vis[v] == 2：该顶点已经被访问，其子树已遍历完 find-eventual-safe-states 有 copypasta/graph.go:299
CF959E 有些题目需要在连通分量上求 MST，这时就需要用到 root min-cost-to-connect-all-points copypasta/graph.go:2399
CF962F 每个点双的点数就是一个极大环的点数 有 copypasta/graph.go:1031
CF986F a[i] >= 0 有 copypasta/graph.go:2192
CF1000E 桥（割边） critical-connections-in-a-network 有 copypasta/graph.go:964
CF1000E 如果每个点至多在一个环中，则为仙人掌图 有 copypasta/graph.go:1239
CF1009F 这样带来的好处是在合并之后，我们可以将当前节点的信息直接添加在 DP 数组末尾 有 copypasta/graph_tree.go:2058
CF1198C a(n) = C(n, 2)-n/2+1 n%2==1 匹配与独立集 有 copypasta/graph.go:52
CF1198C 因此有：最大独立集=n-最大匹配 有 copypasta/graph.go:3215
CF1217D vis[v] == 2：该顶点已经被访问，其子树已遍历完 给一个有向图着色，使得没有一个环只有一个颜色，求使用的颜色数量的最小值 find-eventual-safe-states 有 copypasta/graph.go:300
CF1218D 1 表示不在环上 有 copypasta/graph.go:4585
CF1239D 强连通分量分解 Strongly Connected Component (SCC) 有 copypasta/graph.go:3643
CF1325E BFS 应用：求无向无权图最小环长度 有 copypasta/graph.go:668
CF1325F 注：如果只有一个环（基环树），见 pseudotree 有 copypasta/graph.go:357
CF1325F Topic - DFS 树 有 copypasta/graph.go:905
CF1364D a(n) = C(n, 2)-n/2+1 n%2==1 环与独立集 copypasta/graph.go:51
CF1385E 2 不在队列，已访问 有 copypasta/graph.go:533
CF1401D 重链剖分（见 tree.heavyLightDecomposition） 有 copypasta/graph_tree.go:261
CF1404E 正则就是所有点的度数都一样 copypasta/graph.go:3256
CF1439B 寻找一个子图，要么其是一个 k-团，要么其每个顶点都至少有 k 个邻居（度不小于 k） 有 copypasta/graph.go:4317
CF1455E 《算法导论》思考题 29-5 有 copypasta/graph_flow.go:285
CF1468M 四元环计数/判定 O(m√m) 有 copypasta/graph.go:4528
CF1470D 最大独立集见后面的「最大团」 有 copypasta/graph.go:3205
CF1498E 拓扑序上，不同 SCC 的点的入度，越靠前的严格越小 有 copypasta/graph.go:79
CF1508C 有些题目需要在连通分量上求 MST，这时就需要用到 root min-cost-to-connect-all-points 有 copypasta/graph.go:2397
CF1514E 拓扑序上，不同 SCC 的点的入度，越靠前的严格越小 有 copypasta/graph.go:80
CF1520G 其它 有 copypasta/graph_grid.go:57
CF1528D 适用于稠密图 O(n^2) minimum-cost-of-a-path-with-special-roads 有 copypasta/graph.go:1775
CF1547G 注意这样可能会产生重边，不能有重边时可以用 map 或对每个点排序去重 有 copypasta/graph.go:3732
CF1550F 见 trie01.go 中的 xorMST https://www.luogu.com.cn/blog/ETHANK/boruvka-xiao-ji copypasta/graph.go:2520
CF1630F 二分图最大匹配 Hopcroft–Karp 算法 O(m√n) copypasta/graph.go:3337
CF1650G EXTRA: 次短路·其一 http://poj.org/problem?id=3463 https://www.acwing.com/problem/content/385/ second-minimum-time-to-reach-destination 有 copypasta/graph.go:1706
CF1689E 定义连通性 有 copypasta/graph.go:84
CF1707C 边权时 diff[lca] -= 2 * val（定义 diff 为点到父亲的差分值） minimize-the-total-price-of-the-trips 有 copypasta/graph_tree.go:1619
CF1709E 写法一：按 map 的大小合并 有 copypasta/graph_tree.go:2120
CF1770D 无向图分类：无环/自环/一般环 有 copypasta/graph.go:329
CF1771D 定义 v 到 v 走一步的节点为 v 有 copypasta/graph_tree.go:183
CF1774E 对于无向树，BFS 序的逆序就是拓扑序 有 copypasta/graph_tree.go:52
CF1774E 树上移动 move on tree 有 copypasta/graph_tree.go:68
CF1777E EXTRA: 求有多少个点能被其他所有点访问到 有 copypasta/graph.go:3749
CF1778E NOTE: 注意特判整棵树只有一条边的情况，此时两个叶结点对应同一条边 有 copypasta/graph_tree.go:24
CF1790F NOTE: 注意特判整棵树只有一条边的情况，此时两个叶结点对应同一条边 有 copypasta/graph_tree.go:25
CF1800G O(nlogn) 有 copypasta/graph_tree.go:86
CF1806E NOTE: 注意特判整棵树只有一条边的情况，此时两个叶结点对应同一条边 有 copypasta/graph_tree.go:23
CF1817B 其它找环题目 有 copypasta/graph.go:388
CF1819C path[len(path)/2] 即为树的中心（之一） 有 copypasta/graph_tree.go:617
CF1839E a(n) = C(n, 2)-n/2+1 n%2==1 有 copypasta/graph.go:64
CF1839E 注：二分图也叫偶图 有 copypasta/graph.go:3112
CF1900E 强连通分量分解 Strongly Connected Component (SCC) 有 copypasta/graph.go:3640
CF1927F 例如 cycle=[1,2,3] 表示一个 1->2->3->1 的环 先用 tarjan 去掉所有割边 有 copypasta/graph.go:234
CF1927F 桥（割边） critical-connections-in-a-network 有 copypasta/graph.go:965
CF1971H 注：如果原命题及其逆否命题成对出现，那么只需要对原命题连边 有 copypasta/graph.go:3896
CF1971H 令 a=1，即 addEdge(x,0,x,1)，表示 x 恒为真 addClause(abs(a),a>0,abs(b),b>0) 有 copypasta/graph.go:3915
CF1985H1 网格图 DFS pacific-atlantic-water-flow
making-a-large-island		 有 copypasta/graph_grid.go:21
CF1985H2 网格图 DFS pacific-atlantic-water-flow
making-a-large-island		 有 copypasta/graph_grid.go:22
CF1986F 桥（割边） 可以在算割边的同时计算子树大小 有 copypasta/graph.go:970
CFEDU-E 边权 [0,1] 的随机完全图的 MST 权值和是 ζ(3) = 1.202… Codeforces EDU copypasta/graph.go:2319
CFEDU-F edges 中的节点编号从 0 开始，且无自环 Codeforces EDU copypasta/graph.go:2887
CF103960L 但这样做还要再排序，并使用几个额外的数组，所以相比之下直接 DFS 更好 进阶：对每条边分别计算 copypasta/graph_tree.go:1673
CF104270B 如果每个点至多在一个环中，则为仙人掌图 DSU copypasta/graph.go:1242
CF104270B 树上启发式合并 DSU on tree / small to large 点双 copypasta/graph_tree.go:2110
CF104821E 平面图最小割转最短路 copypasta/graph.go:40
CF105139L EXTRA: 打印负环 利用最短路简化分类讨论 minimum-cost-to-convert-string-ii copypasta/graph.go:1961

数学

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
1000 CF1916B 因子相关问题 有 copypasta/math.go:1531
1000 CF2002B 此时对手的状态为必胜状态——对手必定是胜利的，自己就输掉了游戏 如何严谨证明 有 copypasta/games.go:30
1000 CF2040B 位运算相关 有 copypasta/math.go:32
1100 CF841B 此时对手的状态为必胜状态——对手必定是胜利的，自己就输掉了游戏 有 copypasta/games.go:31
1100 CF2043B 数位 harshad-number copypasta/math_basic.go:8
1100 CF2125C 《挑战程序设计竞赛》P296 有 copypasta/math_comb.go:427
1128 CF27E a(p) = 2^(p-1) for primes p https://www.luogu.com.cn/problem/P 有 copypasta/math.go:1485
1200 CF1736B 基础题 有 copypasta/math.go:439
1200 CF2119B 其他 有 copypasta/geometry.go:139
1300 CF450B 矩阵快速幂优化 DP 也可以找规律 student-attendance-record-ii copypasta/math_matrix.go:37
1300 CF617B 排列组合问题 copypasta/math_comb.go:31
1300 CF1372B dfs(0, 1, tarD, math.MaxInt) 有 copypasta/math.go:1614
1300 CF1612C 可以用以下题目测试： 有 copypasta/geometry.go:177
1300 CF1612C ceilSqrt 返回 ceil(sqrt(x)) 有 copypasta/geometry.go:189
1300 CF1862D 可以用以下题目测试： 有 copypasta/geometry.go:178
1300 CF1879C 排列组合问题 有 copypasta/math_comb.go:34
1300 CF1881D 质因数分解（质数及其幂次）prime factorization smallest-value-after-replacing-with-sum-of-prime-factors
split-the-array-to-make-coprime-products		 有 copypasta/math.go:1326
1300 CF2091E pf[j] = append(pf[j], i) copypasta/math.go:2216
1300 CF2124C LCM 有 copypasta/math.go:491
1400 CF131C 排列组合问题 copypasta/math_comb.go:35
1400 CF284A 原根 copypasta/math.go:2469
1400 CF485A 数位 harshad-number 有 copypasta/math_basic.go:9
1400 CF757B 调和级数枚举（枚举倍数） 有 copypasta/math.go:128
1400 CF1263C ∑k%i 见下面的 floorLoopK 模板题 有 copypasta/math.go:3867
1400 CF1759D 数位 harshad-number 有 copypasta/math_basic.go:10
1400 CF1965A 此时对手的状态为必胜状态——对手必定是胜利的，自己就输掉了游戏 vowels-game-in-a-string 有 copypasta/games.go:33
1400 CF1967B1 整除与 GCD 有 copypasta/math.go:447
1400 CF2104D 该算法也说明了：前 n 个数的平均质因子数量是 O(loglogn) 级别的 有 copypasta/math.go:1128
1400 CF2126E 基础题 copypasta/math.go:440
1400 CF2126E 整除与 GCD 证明题 copypasta/math.go:448
1500 CF166E 矩阵快速幂优化 DP student-attendance-record-ii 有 copypasta/math_matrix.go:38
1500 CF264B GCD 套路：枚举倍数（调和级数复杂度） GCD 与质因子 有 copypasta/math.go:471
1500 CF576A 该算法也说明了：前 n 个数的平均质因子数量是 O(loglogn) 级别的 有 copypasta/math.go:1129
1500 CF630K 《挑战程序设计竞赛》P296 有 copypasta/math_comb.go:428
1500 CF677C 排列组合问题 copypasta/math_comb.go:36
1500 CF908C 圆与圆 copypasta/geometry.go:641
1500 CF1110C GCD 套路：枚举倍数（调和级数复杂度） GCD(x,x+y) = GCD(x,y) 有 copypasta/math.go:472
1500 CF1236B 排列组合问题 有 copypasta/math_comb.go:37
1500 CF1391C 排列组合问题 有 copypasta/math_comb.go:38
1500 CF1996D 调和级数枚举（枚举倍数） 有 copypasta/math.go:129
1500 CF1999F 排列组合问题 有 copypasta/math_comb.go:39
1500 CF2200E a(n) ~ n^2/(2 log n) gcd-sort-of-an-array
count-ways-to-make-array-with-product		 有 copypasta/math.go:1878
1600 CF197A 此时对手的状态为必胜状态——对手必定是胜利的，自己就输掉了游戏 vowels-game-in-a-string 有 copypasta/games.go:36
1600 CF678C LCM 有 copypasta/math.go:492
1600 CF678C 《挑战程序设计竞赛》P296 有 copypasta/math_comb.go:429
1600 CF1033C 此时对手的状态为必胜状态——对手必定是胜利的，自己就输掉了游戏 三定理的模板题 vowels-game-in-a-string 有 copypasta/games.go:37
1600 CF1288C 排列组合问题 有 copypasta/math_comb.go:40
1600 CF1458A GCD(x,y) = GCD(x,y-x) x<=y 有 copypasta/math.go:453
1600 CF1475E 排列组合问题 copypasta/math_comb.go:41
1600 CF1514C 原根 有 copypasta/math.go:2466
1600 CF1766D GCD(x,y) = GCD(x,y-x) x<=y 有 copypasta/math.go:454
1600 CF1766D a(n) ~ n^2/(2 log n) gcd-sort-of-an-array
count-ways-to-make-array-with-product		 有 copypasta/math.go:1879
1600 CF1771C 预处理 sqrt(mx) 以内的质数 有 copypasta/math.go:1148
1600 CF1883E p<<x ≤ q => TODO 分类讨论 有 copypasta/math.go:41
1600 CF1920C 基础题 有 copypasta/math.go:441
1600 CF2040C 排列组合问题 有 copypasta/math_comb.go:43
1700 CF385C a(n) ~ n^2/(2 log n) gcd-sort-of-an-array
count-ways-to-make-array-with-product		 有 copypasta/math.go:1880
1700 CF449A ∑k%i 见下面的 floorLoopK copypasta/math.go:3868
1700 CF498A NOTE: 若输入均为有理数，则输出也为有理数，对精度要求较高时可使用分数类 直线与线段 也可以判断线段端点是否在直线两侧 有 copypasta/geometry.go:519
1700 CF938C ∑k%i 见下面的 floorLoopK 有 copypasta/math.go:3869
1700 CF1073D 取模减半 有 copypasta/math_basic.go:17
1700 CF1194D 此时对手的状态为必胜状态——对手必定是胜利的，自己就输掉了游戏 1-2-K Game 我的题解 https://www.acwing.com/file_system/file/content/whole/index/content/3179098/ vowels-game-in-a-string 有 copypasta/games.go:38
1700 CF1228C 质因数分解（质数及其幂次）prime factorization smallest-value-after-replacing-with-sum-of-prime-factors
split-the-array-to-make-coprime-products		 有 copypasta/math.go:1327
1700 CF1301C 没有思路的话可以尝试： 有 copypasta/math_comb.go:25
1700 CF1485C ∑k%i 见下面的 floorLoopK copypasta/math.go:3870
1700 CF1485C ∑x/i, i in [low,up] copypasta/math.go:3913
1700 CF1777C 复杂度 O(NlogN) 有 copypasta/math.go:1707
1700 CF1950F 数位 harshad-number 有 copypasta/math_basic.go:11
1700 CF1982D 裴蜀定理 Bézout’s identity 有 copypasta/math.go:507
1700 CF2086D 排列组合问题 可重集排列 有 copypasta/math_comb.go:47
1700 CF2086D 可重集排列组合 有 copypasta/math_comb.go:163
1800 CF300C 排列组合问题 有 copypasta/math_comb.go:48
1800 CF869C 排列组合问题 有 copypasta/math_comb.go:49
1800 CF1034A 因子与 GCD 有 copypasta/math.go:444
1800 CF1295D GCD(x,y) = GCD(x,y-x) x<=y 有 copypasta/math.go:455
1800 CF1648B 调和级数枚举（枚举倍数） 有 copypasta/math.go:130
1800 CF1728D 此时对手的状态为必胜状态——对手必定是胜利的，自己就输掉了游戏 字符串两端取字母，字典序小的胜 有 copypasta/games.go:39
1800 CF1750D 《挑战程序设计竞赛》P296 有 copypasta/math_comb.go:430
1800 CF1995C 不断平方变成递增 有 copypasta/math.go:46
1800 CF2008G GCD(x,y) = GCD(x,y-x) x<=y copypasta/math.go:456
1800 CF2033F a(n) = (F(n)F(n+4)-3F(n)*F(n+1))/2 有 copypasta/math.go:4136
1800 CF2035D a < b<<k => a>>k < b 有 copypasta/math.go:38
1900 CF109C 排列组合问题 也可以换根 DP 有 copypasta/math_comb.go:50
1900 CF134B 如果 x = y，无解 有 copypasta/math.go:465
1900 CF213B 排列组合问题 有 copypasta/math_comb.go:51
1900 CF222E 矩阵快速幂优化 DP student-attendance-record-ii 有 copypasta/math_matrix.go:39
1900 CF691E 矩阵快速幂优化 DP 有 copypasta/math_matrix.go:40
1900 CF731F 调和级数枚举（枚举倍数） 有 copypasta/math.go:131
1900 CF1175D Abel 求和公式 / 离散分部积分公式 / 分部求和法 / Abel 变换 有 copypasta/math.go:112
1900 CF1470B 时间复杂度 O(mx)，因为每个数都会被它的 core 恰好标记一次（类似欧拉筛） 有 copypasta/math.go:1823
1900 CF1689D 顺时针旋转 45° (x,y) -> (x+y,y-x) 记作 (x’,y’) minimize-manhattan-distances 有 copypasta/geometry.go:110
1900 CF1878F 质因数分解（质数及其幂次）prime factorization smallest-value-after-replacing-with-sum-of-prime-factors
split-the-array-to-make-coprime-products		 有 copypasta/math.go:1328
1900 CF1878F = 见后文「数论分块/除法分块」 有 copypasta/math.go:1479
1900 CF1992F 因子相关问题 有 copypasta/math.go:1532
1900 CF2094H 复杂度 O(NlogN) 有 copypasta/math.go:1708
2000 CF15C 那么 a[i]^xorSum 必然比 a[i] 小，所以这个减少操作是存在的。 有 copypasta/games.go:156
2000 CF78C 此时对手的状态为必胜状态——对手必定是胜利的，自己就输掉了游戏 分类讨论 有 copypasta/games.go:40
2000 CF501D 3. 解码得到排列 copypasta/math.go:3361
2000 CF615D 否则，ei+1 中必有偶数，将其除二 有 copypasta/math.go:1518
2000 CF615D a^b ≡ a^(b mod φ(m)) (mod m), gcd(a,m)=1 例题 有 copypasta/math.go:2432
2000 CF621E 矩阵快速幂优化 DP 有 copypasta/math_matrix.go:41
2000 CF803F O(n + UlogU), U=max(a) 子序列 EDU20 sorted-gcd-pair-queries 有 copypasta/math.go:607
2000 CF803F todo 重新做一遍 https://ac.nowcoder.com/acm/problem/112055 有 copypasta/math.go:3841
2000 CF895C 只保留奇数次数质因子的写法 有 copypasta/math.go:869
2000 CF900D todo 重新做一遍 有 copypasta/math.go:3840
2000 CF900D 《挑战程序设计竞赛》P296 因子容斥 有 copypasta/math_comb.go:431
2000 CF1359E 排列组合问题 有 copypasta/math_comb.go:53
2000 CF1366D 构造 有 copypasta/math.go:480
2000 CF1900D 题目： 有 copypasta/math.go:3813
2000 CF1931G 排列组合问题 放球问题 构造 有 copypasta/math_comb.go:54
2000 CF1931G 变形：允许空盒 有 copypasta/math_comb.go:110
2000 CF2037G 调和级数枚举写法 因子容斥 有 copypasta/math.go:3723
2000 CF2037G 《挑战程序设计竞赛》P296 因子容斥 有 copypasta/math_comb.go:432
2000 CF2114F 枚举一个数的全部因子 有 copypasta/math.go:1617
2000 CF2171G 排列组合问题 有 copypasta/math_comb.go:55
2100 CF1C 浮点数 GCD 有 copypasta/geometry.go:257
2100 CF821E 矩阵快速幂优化 DP 分段 有 copypasta/math_matrix.go:42
2100 CF936B 此时对手的状态为必胜状态——对手必定是胜利的，自己就输掉了游戏 一道不错的有向图博弈 有 copypasta/games.go:41
2100 CF954F 矩阵快速幂优化 DP 3xM 的格子，其中有一些障碍物，求从第二行最左走到第二行最右的方案数，每次可以向右/右上/右下走一步 有 copypasta/math_matrix.go:43
2100 CF1117D 矩阵快速幂优化 DP f(n) = f(n-1) + f(n-m) 有 copypasta/math_matrix.go:44
2100 CF1117D 另见 math_ntt.go 的 Bostan-Mori 算法 有 copypasta/math_matrix.go:303
2100 CF1761D 排列组合问题 copypasta/math_comb.go:56
2100 CF2123G 复杂度 O(NlogN) 有 copypasta/math.go:1709
2200 CF514E 矩阵快速幂优化 DP 常数项 有 copypasta/math_matrix.go:45
2200 CF514E 结果是列向量 [f[n], f[n-1]]，取第一项 有 copypasta/math_matrix.go:202
2200 CF520E 排列组合问题 有 copypasta/math_comb.go:59
2200 CF559C 排列组合问题 有 copypasta/math_comb.go:60
2200 CF616E ∑k%i 见下面的 floorLoopK 有 copypasta/math.go:3871
2200 CF616E = n*k-∑(k/i)*i 有 copypasta/math.go:3933
2200 CF1154G GCD 套路：枚举倍数（调和级数复杂度） 数组中最小的 LCM(ai,aj) 有 copypasta/math.go:473
2200 CF1155E 时间复杂度 O(n^2) 交互 找零点 有 copypasta/math_numerical_analysis.go:58
2200 CF1559E todo 重新做一遍 copypasta/math.go:3842
2200 CF1646E 该算法也说明了：前 n 个数的平均质因子数量是 O(loglogn) 级别的 copypasta/math.go:1130
2200 CF1646E todo 更高效的算法 - Pollard’s Rho copypasta/math.go:1294
2200 CF1763D 排列组合问题 推荐 分类讨论 有 copypasta/math_comb.go:61
2200 CF1822G2 求 x 的所有平方因子的平方根 有 copypasta/math.go:2013
2200 CF1946E 排列组合问题 排列 copypasta/math_comb.go:62
2200 CF1967B2 整除与 GCD 有 copypasta/math.go:449
2200 CF1970E3 矩阵快速幂优化 DP 有 copypasta/math_matrix.go:46
2200 CF2060F 变形：允许空盒 copypasta/math_comb.go:111
2300 CF451E 适用于 n 巨大但 k 或 n-k 较小的情况（或者只计算一次组合数，O(1) 空间） 有 copypasta/math.go:3236
2300 CF451E 《挑战程序设计竞赛》P296 例题 有 copypasta/math_comb.go:433
2300 CF547C todo 重新做一遍 有 copypasta/math.go:3843
2300 CF785D ∑i=[0..k] C(n,i)*C(m,k-i) = C(n+m,k) 有 copypasta/math_comb.go:133
2300 CF812E 此时对手的状态为必胜状态——对手必定是胜利的，自己就输掉了游戏 阶梯博弈 有 copypasta/games.go:42
2300 CF845G 可以用来解决「子序列异或和」相关问题 异或最短路/最长路 copypasta/math_matrix.go:649
2300 CF1101G 可以用来解决「子序列异或和」相关问题 有 copypasta/math_matrix.go:651
2300 CF1182E 矩阵快速幂优化 DP 关注指数 有 copypasta/math_matrix.go:47
2300 CF1204E 排列组合问题 推荐 有 copypasta/math_comb.go:63
2300 CF1228E 《挑战程序设计竞赛》P296 如何将问题转化成可以容斥的结构 distribute-candies-among-children-ii 有 copypasta/math_comb.go:435
2300 CF1342E 排列组合问题 有 copypasta/math_comb.go:64
2300 CF1342E 《挑战程序设计竞赛》P296 distribute-candies-among-children-ii 有 copypasta/math_comb.go:436
2300 CF1550D 排列组合问题 构造 有 copypasta/math_comb.go:65
2300 CF1603C ∑k%i 见下面的 floorLoopK 数论分块优化 DP copypasta/math.go:3872
2300 CF1780F todo 重新做一遍 copypasta/math.go:3844
2300 CF1797E 前缀和见下面的「phi 求和相关」 copypasta/math.go:2296
2300 CF2077C 排列组合问题 copypasta/math_comb.go:66
2300 CF2077C 解得 A(x) = x / (1 - x - x^2) copypasta/math_gf.go:21
2400 CF17D a^b ≡ a^(b mod φ(m)) (mod m), gcd(a,m)=1 有 copypasta/math.go:2433
2400 CF24D 三对角矩阵算法 托马斯算法 copypasta/math_matrix.go:541
2400 CF26D 排列组合问题 类似卡特兰数的镜像反射技巧 有 copypasta/math_comb.go:67
2400 CF73E 该算法也说明了：前 n 个数的平均质因子数量是 O(loglogn) 级别的 转化 有 copypasta/math.go:1131
2400 CF107D 矩阵快速幂优化 DP 有 copypasta/math_matrix.go:48
2400 CF226C ∑k%i 见下面的 floorLoopK 有 copypasta/math.go:3873
2400 CF226C 矩阵快速幂优化 DP https://www.luogu.com.cn/problem/P1306 有 copypasta/math_matrix.go:49
2400 CF293C 式子变形 有 copypasta/math_basic.go:14
2400 CF446C a(n) = (F(n)F(n+4)-3F(n)*F(n+1))/2 有 copypasta/math.go:4147
2400 CF449D 《挑战程序设计竞赛》P296 与 SOS DP 结合 distribute-candies-among-children-ii 有 copypasta/math_comb.go:437
2400 CF593E 矩阵快速幂优化 DP 分段 有 copypasta/math_matrix.go:50
2400 CF605C 矩阵树定理 基尔霍夫定理 Kirchhoff‘s theorem 对偶 有 copypasta/math_matrix.go:879
2400 CF632E 解得 A(x) = x / (1 - x - x^2) copypasta/math_gf.go:22
2400 CF662A 那么 a[i]^xorSum 必然比 a[i] 小，所以这个减少操作是存在的。 有 copypasta/games.go:157
2400 CF662A 可以用来解决「子序列异或和」相关问题 博弈 有 copypasta/math_matrix.go:652
2400 CF665F 时间复杂度和 Min_25 筛是一样的 O(n^(3/4) / log n) 有 copypasta/math.go:4064
2400 CF932E 边界条件：S(n,0)=0, n>=1 S(n,n)=1, n>=0 count-ways-to-distribute-candies 有 copypasta/math.go:3423
2400 CF932E 只计算第 n 行 有 copypasta/math.go:3465
2400 CF959F 可以用来解决「子序列异或和」相关问题 有 copypasta/math_matrix.go:653
2400 CF990G O(n + UlogU), U=max(a) 树上路径 EDU45 sorted-gcd-pair-queries 有 copypasta/math.go:608
2400 CF1007B 《挑战程序设计竞赛》P296 不重不漏 distribute-candies-among-children-ii 有 copypasta/math_comb.go:438
2400 CF1017E NOTE: 坐标值范围不超过 M 的整点凸多边形的顶点数为 O(M^(2/3)) 个 erect-the-fence
find-the-minimum-amount-of-time-to-brew-potions		 有 copypasta/geometry.go:1042
2400 CF1017E 凸包哈希，用于判断两个凸包是否相等 有 copypasta/geometry.go:1093
2400 CF1036F 可以用以下题目测试： 有 copypasta/geometry.go:179
2400 CF1096G 解得 A(x) = x / (1 - x - x^2) copypasta/math_gf.go:23
2400 CF1109D 排列组合问题 Prufer 序列 有 copypasta/math_comb.go:68
2400 CF1142C NOTE: 坐标值范围不超过 M 的整点凸多边形的顶点数为 O(M^(2/3)) 个 erect-the-fence
find-the-minimum-amount-of-time-to-brew-potions		 有 copypasta/geometry.go:1043
2400 CF1163E 可以用来解决「子序列异或和」相关问题 copypasta/math_matrix.go:654
2400 CF1261D2 排列组合问题 推荐 有 copypasta/math_comb.go:69
2400 CF1526E 适用于 n 巨大但 k 或 n-k 较小的情况（或者只计算一次组合数，O(1) 空间） 有 copypasta/math.go:3237
2400 CF1526E 排列组合问题 后缀数组 有 copypasta/math_comb.go:70
2400 CF1542E1 O(nk) 插入法 + 前缀和优化 DP k-inverse-pairs-array
count-the-number-of-inversions		 有 copypasta/math.go:3612
2400 CF1591F 《挑战程序设计竞赛》P296 辅助思考 DP distribute-candies-among-children-ii copypasta/math_comb.go:439
2400 CF1608D 排列组合问题 有 copypasta/math_comb.go:71
2400 CF1726E 排列组合问题 满足 |p_i − p^{−1}_i| ≤ 1 的排列个数 有 copypasta/math_comb.go:72
2400 CF1780E ∑k%i 见下面的 floorLoopK GCD todo 有 copypasta/math.go:3874
2400 CF1902F 可以用来解决「子序列异或和」相关问题 LCA 有 copypasta/math_matrix.go:655
2400 CF1902F EXTRA: 从高到低，对于二进制长度相同的基，选更靠右的 有 copypasta/math_matrix.go:720
2400 CF1930E 排列组合问题 选长为 2k+1 的子序列，删除其中前 k 个和后 k 个 有 copypasta/math_comb.go:73
2400 CF1934D2 交互+博弈 有 copypasta/games.go:60
2400 CF1979E 顺时针旋转 45° (x,y) -> (x+y,y-x) 记作 (x’,y’) minimize-manhattan-distances copypasta/geometry.go:111
2400 CF2171H 调和级数枚举（枚举倍数） 有 copypasta/math.go:132
2400 CF2176F O(n + UlogU), U=max(a) sorted-gcd-pair-queries 有 copypasta/math.go:609
2500 CF60D 本原勾股数组 Primitive Pythagorean Triples count-square-sum-triples 有 copypasta/math.go:665
2500 CF93D 矩阵快速幂优化 DP 前 n 项之和 有 copypasta/math_matrix.go:51
2500 CF93D 注：一种理解角度是，基于汉克尔矩阵的在线高斯消元 有 copypasta/math_matrix.go:223
2500 CF156D 排列组合问题 Prufer 序列 n^(cc-2) 有 copypasta/math_comb.go:74
2500 CF314D 顺时针旋转 45° (x,y) -> (x+y,y-x) 记作 (x’,y’) minimize-manhattan-distances 有 copypasta/geometry.go:112
2500 CF348D 排列组合问题 不相交路径 有 copypasta/math_comb.go:75
2500 CF351C 矩阵快速幂优化 DP min + 也有 O(nlogn) 做法 有 copypasta/math_matrix.go:52
2500 CF528D 做法：把 b 反转后求卷积 copypasta/math_fft.go:151
2500 CF594D a(n) ~ n^2/(2 log n) gcd-sort-of-an-array
count-ways-to-make-array-with-product		 有 copypasta/math.go:1881
2500 CF594D 比较松的下界 φ(n) >= √(n/2) 有 copypasta/math.go:2292
2500 CF618E 逆时针旋转，传入旋转的弧度 有 copypasta/geometry.go:320
2500 CF757E 一个有用的性质：积性函数的和函数也是积性函数 有 copypasta/math.go:1248
2500 CF792E ∑k%i 见下面的 floorLoopK 有 copypasta/math.go:3875
2500 CF840C 排列组合问题 多重集排列，相邻元素不同 有 copypasta/math_comb.go:76
2500 CF908E B(n) = Sum_{k=1..n} S2(n,k) 有 copypasta/math.go:3515
2500 CF908E 排列组合问题 等价类 贝尔数 有 copypasta/math_comb.go:77
2500 CF995D 此时对手的状态为必胜状态——对手必定是胜利的，自己就输掉了游戏 有 copypasta/games.go:43
2500 CF997C 求 1^-1, 2^-1, …, (p−1)^-1 mod p 有 copypasta/math.go:2734
2500 CF997C 排列组合问题 有 copypasta/math_comb.go:78
2500 CF1043F O(n + UlogU), U=max(a) 统计 a 中所有大小为 k 的子序列的 GCD 的出现次数 sorted-gcd-pair-queries 有 copypasta/math.go:610
2500 CF1043F 调和级数枚举写法 有 copypasta/math.go:3724
2500 CF1043F 《挑战程序设计竞赛》P296 DP distribute-candies-among-children-ii 有 copypasta/math_comb.go:440
2500 CF1096E 排列组合问题 容斥 有 copypasta/math_comb.go:79
2500 CF1100F 可以用来解决「子序列异或和」相关问题 有 copypasta/math_matrix.go:657
2500 CF1100F EXTRA: 从高到低，对于二进制长度相同的基，选更靠右的 有 copypasta/math_matrix.go:721
2500 CF1251F 解得 A(x) = x / (1 - x - x^2) copypasta/math_gf.go:24
2500 CF1312F 此时对手的状态为必胜状态——对手必定是胜利的，自己就输掉了游戏 copypasta/games.go:44
2500 CF1423J 式子变形 给定正整数 n，计算 x+2y+4z=n 有多少个非负整数解 有 copypasta/math.go:107
2500 CF1427E 可以用来解决「子序列异或和」相关问题 构造 有 copypasta/math_matrix.go:658
2500 CF1516E 边界条件：s(n,0)=0, n>=1 s(n,n)=1, n>=0 number-of-ways-to-rearrange-sticks-with-k-sticks-visible 有 copypasta/math.go:3413
2500 CF1548C 解得 A(x) = x / (1 - x - x^2) https://chatgpt.com/c/682db19e-19a4-8011-908b-50e7a797d1df 有 copypasta/math_gf.go:25
2500 CF1716F 边界条件：S(n,0)=0, n>=1 S(n,n)=1, n>=0 把幂转成下降幂 https://chatgpt.com/c/6836d520-3efc-8011-ac52-a2207a5251d0 count-ways-to-distribute-candies 有 copypasta/math.go:3424
2500 CF1778E 可以用来解决「子序列异或和」相关问题 有 copypasta/math_matrix.go:659
2500 CF1778E EXTRA: 从高到低，对于二进制长度相同的基，选更靠右的 有 copypasta/math_matrix.go:722
2500 CF1789E ∑k%i 见下面的 floorLoopK 式子同时包含上取整和下取整 有 copypasta/math.go:3876
2500 CF1838E 排列组合问题 有 copypasta/math_comb.go:80
2500 CF1986G2 复杂度 O(NlogN) 有 copypasta/math.go:1710
2600 CF60E 矩阵快速幂优化 DP 有 copypasta/math_matrix.go:53
2600 CF140E 排列组合问题 推荐 find-all-good-strings 有 copypasta/math_comb.go:83
2600 CF285E 本质是容斥 有 copypasta/math_comb.go:480
2600 CF622F 时间复杂度 O(n^2) 等幂和 有 copypasta/math_numerical_analysis.go:59
2600 CF662C 然后枚举两元素异或和，在原数组的异或字典树上查询最大异或和 count-pairs-with-xor-in-a-range 有 copypasta/math_fwt.go:27
2600 CF724G 可以用来解决「子序列异或和」相关问题 图上线性基 有 copypasta/math_matrix.go:660
2600 CF914G 然后枚举两元素异或和，在原数组的异或字典树上查询最大异或和 count-pairs-with-xor-in-a-range copypasta/math_fwt.go:29
2600 CF982E 最简单的做法就是 min(x1+y1, x2+y2) 台球 有 copypasta/math.go:2656
2600 CF1278F 边界条件：S(n,0)=0, n>=1 S(n,n)=1, n>=0 把幂转成下降幂 https://chatgpt.com/c/68284f34-38cc-8011-9dd2-04beb3fbed53 count-ways-to-distribute-candies 有 copypasta/math.go:3425
2600 CF1400G 《挑战程序设计竞赛》P296 有 copypasta/math_comb.go:441
2600 CF1430G 矩阵树定理 基尔霍夫定理 Kirchhoff‘s theorem https://codeforces.com/blog/entry/83614?#comment-709868 有 copypasta/math_matrix.go:880
2600 CF1437F 排列组合问题 find-all-good-strings 有 copypasta/math_comb.go:84
2600 CF1656F 式子变形 完全图带参 MST 有 copypasta/math.go:108
2600 CF1778F x 的质因数分解中，每个质数的幂次 e 改成 ceil(e/2) = (e+1)/2 count-beautiful-substrings-ii 有 copypasta/math.go:1935
2600 CF1895F 矩阵快速幂优化 DP 如何容斥（正难则反） 有 copypasta/math_matrix.go:54
2700 CF70D 用平衡树加点 有 copypasta/geometry.go:1115
2700 CF98E 纳什均衡 有 copypasta/games.go:64
2700 CF251D 可以用来解决「子序列异或和」相关问题 输出具体方案 copypasta/math_matrix.go:661
2700 CF498E 矩阵快速幂优化 DP 分段 DP套DP 有 copypasta/math_matrix.go:55
2700 CF575A 矩阵快速幂优化 DP 分段 倍增 copypasta/math_matrix.go:56
2700 CF827E 做法：把 b 反转后求卷积 copypasta/math_fft.go:152
2700 CF906D a^b ≡ a^(b mod φ(m)) (mod m), gcd(a,m)=1 copypasta/math.go:2434
2700 CF932F 用平衡树加点 启发式合并 有 copypasta/geometry.go:1116
2700 CF995F 时间复杂度 O(n^2) copypasta/math_numerical_analysis.go:60
2700 CF1202F ∑k%i 见下面的 floorLoopK 有 copypasta/math.go:3877
2700 CF1511F 矩阵快速幂优化 DP 字典树 todo 什么情况下系数矩阵阶数最大？ 有 copypasta/math_matrix.go:57
2700 CF1511F 注：一种理解角度是，基于汉克尔矩阵的在线高斯消元 有 copypasta/math_matrix.go:224
2700 CF1515G bi 可以是负数 有 copypasta/math.go:2777
2700 CF1542E2 O(nk) 插入法 + 前缀和优化 DP k-inverse-pairs-array
count-the-number-of-inversions		 有 copypasta/math.go:3613
2700 CF1542E2 解得 A(x) = x / (1 - x - x^2) https://www.luogu.com.cn/article/k9ipc3ow 有 copypasta/math_gf.go:26
2700 CF1730E 复杂度 O(NlogN) 有 copypasta/math.go:1711
2700 CF1924D 排列组合问题 证明方式类似卡特兰数 find-all-good-strings 有 copypasta/math_comb.go:85
2800 CF1808E3 排列组合问题 做法不止一种，包括二项式反演 find-all-good-strings 有 copypasta/math_comb.go:86
2800 CF1845F 解得 A(x) = x / (1 - x - x^2) copypasta/math_gf.go:27
2900 CF19E 可以用来解决「子序列异或和」相关问题 图上线性基 有 copypasta/math_matrix.go:663
2900 CF497E 矩阵快速幂优化 DP 数位 DP copypasta/math_matrix.go:58
2900 CF585E O(n + UlogU), U=max(a) 有 copypasta/math.go:611
2900 CF587E 可以用来解决「子序列异或和」相关问题 copypasta/math_matrix.go:664
2900 CF725F 此时对手的状态为必胜状态——对手必定是胜利的，自己就输掉了游戏 拿照片，最大化幸福总和之差 有 copypasta/games.go:45
2900 CF917C 矩阵快速幂优化 DP 分段 min + 有 copypasta/math_matrix.go:59
2900 CF960G 边界条件：s(n,0)=0, n>=1 s(n,n)=1, n>=0 number-of-ways-to-rearrange-sticks-with-k-sticks-visible copypasta/math.go:3414
2900 CF1028H a(n) ~ n^2/(2 log n) gcd-sort-of-an-array
count-ways-to-make-array-with-product		 有 copypasta/math.go:1882
2900 CF1028H log a(n) ~ n log 2 有 copypasta/math.go:2067
2900 CF1264D2 ∑i=[0..k] C(n,i)*C(m,k-i) = C(n+m,k) 有 copypasta/math_comb.go:134
3000 CF375E 矩阵树定理 基尔霍夫定理 Kirchhoff‘s theorem copypasta/math_matrix.go:881
3000 CF506E 注：一种理解角度是，基于汉克尔矩阵的在线高斯消元 copypasta/math_matrix.go:225
3000 CF891E 指数生成函数 EGF Exponential generating function 有 copypasta/math_ntt.go:69
3000 CF1152F2 矩阵快速幂优化 DP 状态设计 有 copypasta/math_matrix.go:60
3000 CF1299D 可以用来解决「子序列异或和」相关问题 copypasta/math_matrix.go:666
3300 CF618G 矩阵快速幂优化 DP 期望 DP copypasta/math_matrix.go:61
3500 CF1336E2 可以用来解决「子序列异或和」相关问题 copypasta/math_matrix.go:667
CF1C 另一种写法是求两中垂线交点 有 copypasta/geometry.go:380
CF11A 数位 900 上取整 harshad-number 有 copypasta/math_basic.go:7
CF21B 求解 Ax=B，A 为方阵，返回解（无解或有无穷多组解） 有 copypasta/math_matrix.go:535
CF24D 矩阵 copypasta/math_matrix.go:27
CF45G 2e9 内最大的为 a(1847133842) = 1861 有 copypasta/math.go:1008
CF87C 只能取 p^i 个（p 为奇素数）：SG(n) = n%2 subtree-removal-game-with-fibonacci-tree 有 copypasta/games.go:188
CF87E todo 闵可夫斯基和 Minkowski sum copypasta/geometry.go:1221
CF138D 此时对手的状态为必胜状态——对手必定是胜利的，自己就输掉了游戏 (注：这是挑战上推荐的题目) stone-game-vi copypasta/games.go:47
CF226C a(n) = (F(n)F(n+4)-3F(n)*F(n+1))/2 有 copypasta/math.go:4146
CF235B 例如，在该页面搜索 permutation 可以找到一些有趣的计数问题 时找到的序列） 有 copypasta/math.go:194
CF274C 下面交换了一下乘除的顺序，减小精度的丢失 copypasta/geometry.go:393
CF281B a, b = b, r copypasta/math_continued_fraction.go:42
CF340B todo 点集的最大四边形 copypasta/geometry.go:1226
CF340C = 2*∑(i*ai-preSum(i-1)), i=[0,n-1], a 需要排序 有 copypasta/math.go:210
CF425E 排列组合问题 更快的做法 https://chatgpt.com/c/684b7418-ff80-8011-bd87-3a664dfcbb97 find-all-good-strings copypasta/math_comb.go:87
CF429D 返回最近点对距离的平方 有 copypasta/geometry.go:967
CF438E 分治 FFT copypasta/math_ntt.go:123
CF451E 可重集排列组合 有 copypasta/math_comb.go:164
CF491B 顺时针旋转 45° (x,y) -> (x+y,y-x) 记作 (x’,y’) minimize-manhattan-distances
minimum-time-for-k-virus-variants-to-spread		 copypasta/geometry.go:115
CF543D 加法运算见下面的 add1 有 copypasta/math.go:2542
CF543D 计算 (k,x) + (0,1) 有 copypasta/math.go:2566
CF600D 两圆面积交 = 面积和 - 面积并 copypasta/geometry.go:744
CF618F 鸽巢原理（抽屉原理） pigeonhole principle 有 copypasta/math_comb.go:22
CF633B 阶乘的质因数分解中 p 的幂次 有 copypasta/math.go:1373
CF679B 贪心分拆 有 copypasta/math_comb.go:248
CF696C 其他相关序列 有 copypasta/math.go:4154
CF735D 2e9 内最大的为 a(1847133842) = 1861 有 copypasta/math.go:1007
CF762A 求 x 的所有因子 简单的质因数分解 有 copypasta/math.go:1989
CF772C n/φ(n) = 3 iff n = 2^w * 3^u, w >= 1, u >= 1 有 copypasta/math.go:2314
CF772C 返回最小正整数解 有 copypasta/math.go:2610
CF803F 构造 https://ac.nowcoder.com/acm/problem/112055 有 copypasta/math.go:484
CF814D 圆与扫描线 有 copypasta/geometry.go:898
CF850C 取石子变形 有 copypasta/games.go:190
CF893E 变形：允许空盒 count-ways-to-make-array-with-product 有 copypasta/math_comb.go:113
CF895C 可以用来解决「子序列异或和」相关问题 有 copypasta/math_matrix.go:673
CF920G = Sum_{d|n} d*μ(m/d) 用 n 的因子来容斥 有 copypasta/math.go:3691
CF954I 贝尔数 EXTRA：如何搜索所有集合划分 有 copypasta/math.go:3570
CF958F3 入参出参都是次项从低到高的系数 可重集大小为 k 的不同子集个数 有 copypasta/math_fft.go:164
CF958F3 分治 FFT 有 copypasta/math_ntt.go:122
CF993E 有关快速数论变换（NTT）以及多项式运算的内容见 math_ntt.go multiply-two-polynomials copypasta/math_fft.go:43
CF1009D phi 求和相关 有 copypasta/math.go:2330
CF1036E 直线 a b 交点 - 两点式 有 copypasta/geometry.go:531
CF1070A 0’s and d’s (2~9): A096681-A096688 有 copypasta/math.go:256
CF1076B a(n) ~ n^2/(2 log n) 有 copypasta/math.go:1855
CF1081E divisors[j] = append(divisors[j], i) 有 copypasta/math.go:1724
CF1093G 顺时针旋转 45° (x,y) -> (x+y,y-x) 记作 (x’,y’) minimum-time-for-k-virus-variants-to-spread 有 copypasta/geometry.go:116
CF1098E ∑⌊(ai+b)/m⌋, i in [0,n-1] copypasta/math.go:741
CF1114C 阶乘的质因数分解中 p 的幂次 有 copypasta/math.go:1374
CF1163C2 梯形个数 count-number-of-trapezoids-ii 有 copypasta/geometry.go:143
CF1178D 这题需要用到 a(n) ~ O(√n) 有 copypasta/math.go:1020
CF1178E 鸽巢原理 抽屉原理 有 copypasta/math.go:79
CF1182F ∑⌊(ai+b)/m⌋, i in [0,n-1] copypasta/math.go:740
CF1210C GCD 性质统计相关 有 copypasta/math.go:557
CF1218D 然后枚举两元素异或和，在原数组的异或字典树上查询最大异或和 count-pairs-with-xor-in-a-range 有 copypasta/math_fwt.go:26
CF1244C 可以改成非负整数解（见代码注释） 使非负解 x+y 尽量小 有 copypasta/math.go:2650
CF1278F 对 1~n 的每个排列，计算其后缀最小值数组去重后的元素之和 洛谷有艹标算的题解 有 copypasta/math.go:3434
CF1342E 将 n 个元素拆分为 k 个非空集的方法数 有 copypasta/math.go:3418
CF1359F 交点为 a.point(ta) 或 b.point(tb) 有 copypasta/geometry.go:547
CF1359F todo 扫描线：线段求交 O(nlogn) 有 copypasta/geometry.go:937
CF1368B a(n) = phi(n)/2 for n >= 3 有 copypasta/math_comb.go:282
CF1462D LCM 的 O(nlogn) 解法 copypasta/math.go:495
CF1468F 最简分数 有 copypasta/math.go:688
CF1470B log a(n) ~ n log 2 有 copypasta/math.go:2065
CF1485D a, b = b%a, a copypasta/math.go:531
CF1497E2 log a(n) ~ n log 2 copypasta/math.go:2066
CF1499D 所以相当于是在求 a(LCM/GCD) = 1<<omega[LCM/GCD] copypasta/math.go:2269
CF1500B 注意乘法溢出的可能 有 copypasta/math.go:2802
CF1512G 一个典型的例子见下面 σ(n) 的线性筛求法 copypasta/math.go:1243
CF1512G 线性筛求 n 的因子之和 σ(n) copypasta/math.go:1761
CF1515E 例如，在该页面搜索 permutation 可以找到一些有趣的计数问题 有 copypasta/math.go:188
CF1526B 两种硬币面额为 a 和 b，互质，数量无限，所不能凑出的数值的最大值为 a*b-a-b copypasta/math.go:502
CF1538D 单个数的 Omega copypasta/math.go:1431
CF1542C a, b = b%a, a 有 copypasta/math.go:532
CF1548D1 利用该定理可以证明：不存在坐标均为整数的正三角形、正六边形等 copypasta/geometry.go:100
CF1548D2 利用该定理可以证明：不存在坐标均为整数的正三角形、正六边形等 copypasta/geometry.go:101
CF1583F 注：log(81) / log(3) = 4.000000000000001 有 copypasta/math.go:406
CF1603A a, b = b%a, a 有 copypasta/math.go:533
CF1614D2 求 x 的所有因子 copypasta/math.go:1988
CF1696E 递推式 C(n, k) = C(n-1, k-1) + C(n-1, k) copypasta/math_comb.go:124
CF1737B 见进阶指南 pp.140-141 copypasta/math.go:1557
CF1748D 最简单的做法就是 min(x1+y1, x2+y2) 有 copypasta/math.go:2655
CF1770C a 中任意两数互质 <=> 每个质数至多整除一个 a[i] 有 copypasta/math.go:488
CF1823E 取石子变形 copypasta/games.go:191
CF1826F 见下面这两份代码的区别 有 copypasta/geometry.go:43
CF1826F 点 a 在直线 l 上的投影 有 copypasta/geometry.go:495
CF1830C 所有在 n×n 格点中不越过对角线的单调路径的个数 handshakes-that-dont-cross 有 copypasta/math.go:3172
CF1832E 差分、前缀和与组合数 copypasta/math_comb.go:98
CF1833F x^-1 ≡ a^(p-2) (mod p) copypasta/math.go:2712
CF1841F 双指针维护 copypasta/geometry.go:355
CF1841F todo 闵可夫斯基和 Minkowski sum copypasta/geometry.go:1222
CF1848E 加法运算见下面的 add1 有 copypasta/math.go:2541
CF1853B 最简单的做法就是 min(x1+y1, x2+y2) 非暴力做法 copypasta/math.go:2652
CF1857F 一元二次方程/不等式 有 copypasta/math.go:121
CF1884D GCD 卷积（GCD Convolution） 有 copypasta/math.go:516
CF1898D = max(a-b, b-a) + max(c-d, d-c) reverse-subarray-to-maximize-array-value
reverse-subarray-to-maximize-array-value		 有 copypasta/geometry.go:132
CF1902F panic(“todo”) 有 copypasta/math_matrix.go:849
CF1903E 交互+博弈 copypasta/games.go:61
CF1916H2 Gaussian binomial coefficient 有 copypasta/math_comb.go:192
CF1955G 不需要排序的写法 有 copypasta/math.go:1632
CF1967C 递推式 C(n, k) = C(n-1, k-1) + C(n-1, k) copypasta/math_comb.go:125
CF2026D 如果 sqrt 前面是负号，那么下取整要变成上取整 stone-removal-game 有 copypasta/math.go:65
CF2065G for i>=2, pf[i][0] == i means i is prime 有 copypasta/math.go:2199
CF2167D a, b = b%a, a 估算时间复杂度 有 copypasta/math.go:534
CFEDU-A NOTE: 坐标值范围不超过 M 的整点凸多边形的顶点数为 O(M^(2/3)) 个 Codeforces EDU copypasta/geometry.go:1044
CF102331E 可以用来解决「子序列异或和」相关问题 copypasta/math_matrix.go:668
CF103107F 一个典型的例子见下面 σ(n) 的线性筛求法 copypasta/math.go:1244
CF103107F a(n) ~ n^2/(2 log n) 另一种做法是欧拉筛 count-ways-to-make-array-with-product copypasta/math.go:1883
CF103688E GCD 卷积（GCD Convolution） copypasta/math.go:515
CF104081K 有关快速数论变换（NTT）以及多项式运算的内容见 math_ntt.go multiply-two-polynomials copypasta/math_fft.go:44
CF105139B = 0：a 和 b 平行或重合（共基线） copypasta/geometry.go:63
CF105139L LCM 分类讨论 copypasta/math.go:493
CF105385F Abel 求和公式 / 离散分部积分公式 / 分部求和法 / Abel 变换 copypasta/math.go:113
CF106215L N*N 的乘法表中有多少个不同数字？ count-square-sum-triples copypasta/math.go:169
CF106215L 本原勾股数组 Primitive Pythagorean Triples count-square-sum-triples copypasta/math.go:664

字符串

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
1200 CF1989B 返回 t 最长前缀的长度，满足该前缀是 s 的子序列 subsequence-with-the-minimum-score
find-the-lexicographically-smallest-valid-sequence		 有 copypasta/strings.go:555
1300 CF1194C 返回 t 最长前缀的长度，满足该前缀是 s 的子序列 subsequence-with-the-minimum-score
find-the-lexicographically-smallest-valid-sequence		 有 copypasta/strings.go:556
1400 CF182D 如果没有循环节，那么返回原串和 1 有 copypasta/strings.go:333
1400 CF1845C 子序列自动机 is-subsequence
shortest-impossible-sequence-of-rolls		 有 copypasta/strings.go:581
1400 CF1847C 一棵（所有叶节点深度都相同的）二叉树 count-pairs-with-xor-in-a-range
maximum-xor-of-two-non-overlapping-subtrees		 copypasta/trie01.go:15
1400 CF1847C 返回 v 与 trie 上所有数的最大异或值，trie 不能是空的 maximum-strong-pair-xor-ii
maximum-xor-with-an-element-from-array		 copypasta/trie01.go:158
1500 CF91A 子序列自动机 is-subsequence
shortest-impossible-sequence-of-rolls		 有 copypasta/strings.go:583
1600 CF600A 库函数应用题 有 copypasta/strings.go:16
1600 CF1137B a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 构造 shortest-palindrome
distinct-echo-substrings		 有 copypasta/strings.go:252
1700 CF126B a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 shortest-palindrome
distinct-echo-substrings		 有 copypasta/strings.go:253
1700 CF778A 返回 t 最长前缀的长度，满足该前缀是 s 的子序列 subsequence-with-the-minimum-score
find-the-lexicographically-smallest-valid-sequence		 有 copypasta/strings.go:557
1700 CF1690F 如果没有循环节，那么返回原串和 1 copypasta/strings.go:334
1700 CF1948D O(n^2) 计算 LCP —— 如果你不想用后缀数组的话 也有更简单的做法 有 copypasta/strings.go:1325
1700 CF2010C2 模板题 有 copypasta/strings.go:398
1700 CF2104E 子序列自动机 is-subsequence
shortest-impossible-sequence-of-rolls		 有 copypasta/strings.go:582
1800 CF271D 把 (s[i], s[n-1-i]) 插入字典树 满足一些条件的本质不同子串个数 palindrome-pairs
re-space-lcci		 有 copypasta/trie.go:25
1800 CF471D a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 shortest-palindrome
distinct-echo-substrings		 有 copypasta/strings.go:254
1800 CF706D 一棵（所有叶节点深度都相同的）二叉树 count-pairs-with-xor-in-a-range
maximum-xor-of-two-non-overlapping-subtrees		 有 copypasta/trie01.go:16
1800 CF923C 一棵（所有叶节点深度都相同的）二叉树 字典序最小 count-pairs-with-xor-in-a-range
maximum-xor-of-two-non-overlapping-subtrees		 copypasta/trie01.go:17
1800 CF1326D2 最长回文子串 Manacher（马拉车算法） 去掉子串后，剩余部分是回文串 longest-palindromic-substring 有 copypasta/strings.go:694
1900 CF223B 返回 t 最长前缀的长度，满足该前缀是 s 的子序列 记录 s 的每个字母匹配到 t 中的第几个 subsequence-with-the-minimum-score
find-the-lexicographically-smallest-valid-sequence		 有 copypasta/strings.go:558
1900 CF455B 把 (s[i], s[n-1-i]) 插入字典树 palindrome-pairs
re-space-lcci		 copypasta/trie.go:26
1900 CF535D 模板题 copypasta/strings.go:399
1900 CF835D 最长回文子串 Manacher（马拉车算法） longest-palindromic-substring 有 copypasta/strings.go:696
1900 CF2093G 一棵（所有叶节点深度都相同的）二叉树 count-pairs-with-xor-in-a-range
maximum-xor-of-two-non-overlapping-subtrees		 有 copypasta/trie01.go:18
1900 CF2093G 返回 v 与 trie 上所有数的最大异或值，trie 不能是空的 maximum-strong-pair-xor-ii
maximum-xor-with-an-element-from-array		 有 copypasta/trie01.go:159
2000 CF113B 把 (s[i], s[n-1-i]) 插入字典树 满足一些条件的本质不同子串个数 palindrome-pairs
re-space-lcci		 有 copypasta/trie.go:27
2000 CF346B a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 与 LCS 结合 shortest-palindrome
distinct-echo-substrings		 有 copypasta/strings.go:256
2000 CF494B a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 与计数 DP 结合 distinct-echo-substrings 有 copypasta/strings.go:257
2000 CF514C 把 (s[i], s[n-1-i]) 插入字典树 palindrome-pairs
re-space-lcci		 有 copypasta/trie.go:28
2000 CF615C a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 最大匹配个数 有 copypasta/strings.go:259
2000 CF817E 一棵（所有叶节点深度都相同的）二叉树 count-pairs-with-xor-in-a-range
maximum-xor-of-two-non-overlapping-subtrees		 有 copypasta/trie01.go:19
2000 CF817E b ^= 1 count-pairs-with-xor-in-a-range 有 copypasta/trie01.go:247
2000 CF842D 一棵（所有叶节点深度都相同的）二叉树 maximum-xor-of-two-non-overlapping-subtrees 有 copypasta/trie01.go:20
2000 CF842D ！需要保证 trie 中没有重复元素 有 copypasta/trie01.go:369
2000 CF1200E a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 有 copypasta/strings.go:258
2019 CF102511G 包含 s[k] 的状态节点一定位于 s[k] 末尾节点的子树内 ICPC Final G copypasta/acam.go:87
2100 CF128B 第 k 小子串 todo copypasta/strings.go:1028
2100 CF665E 一棵（所有叶节点深度都相同的）二叉树 有 copypasta/trie01.go:21
2100 CF665E b ^= 1 count-pairs-with-xor-in-a-range 有 copypasta/trie01.go:248
2100 CF1163D a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 与 DP 结合 有 copypasta/strings.go:260
2100 CF1446C 一棵（所有叶节点深度都相同的）二叉树 subarrays-with-xor-at-least-k copypasta/trie01.go:23
2200 CF7D 最长回文子串 Manacher（马拉车算法） longest-palindromic-substring 有 copypasta/strings.go:695
2200 CF25E a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 构造 t+”#”+s 有 copypasta/strings.go:264
2200 CF282E 一棵（所有叶节点深度都相同的）二叉树 数组前缀异或数组后缀的最大值（前后缀不重叠，但这要求可以无视） subarrays-with-xor-at-least-k 有 copypasta/trie01.go:24
2200 CF282E o.val = v 有 copypasta/trie01.go:93
2200 CF526D a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 有 copypasta/strings.go:261
2200 CF526D 如果没有循环节，那么返回原串和 1 有 copypasta/strings.go:335
2200 CF954I a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 有 copypasta/strings.go:262
2200 CF965E 把 (s[i], s[n-1-i]) 插入字典树 与贪心堆结合 palindrome-pairs
re-space-lcci		 有 copypasta/trie.go:29
2200 CF979D 一棵（所有叶节点深度都相同的）二叉树 subarrays-with-xor-at-least-k 有 copypasta/trie01.go:25
2200 CF979D 不存在时返回 -1 有 copypasta/trie01.go:223
2200 CF1003F a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 有 copypasta/strings.go:263
2200 CF1968G2 模板题 有 copypasta/strings.go:400
2200 CF2045H O(n^2) 计算 LCP —— 如果你不想用后缀数组的话 有 copypasta/strings.go:1326
2200 CF2209F 模板题 copypasta/strings.go:401
2300 CF123D 子串统计类题目 注：这是《挑战》上推荐的题目 有 copypasta/strings.go:1016
2300 CF557E 把 (s[i], s[n-1-i]) 插入字典树 re-space-lcci 有 copypasta/trie.go:30
2300 CF802I 子串统计类题目 稍作改动 有 copypasta/strings.go:1018
2300 CF808G a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 与 DP 结合 shortest-string-that-contains-three-strings 有 copypasta/strings.go:267
2300 CF888G 一棵（所有叶节点深度都相同的）二叉树 subarrays-with-xor-at-least-k 有 copypasta/trie01.go:26
2300 CF888G 返回 v 与 trie 上所有数的最小异或值，trie 不能是空的 有 copypasta/trie01.go:106
2300 CF888G O(nlognlogU) 有 copypasta/trie01.go:123
2400 CF316G3 子串统计类题目 copypasta/strings.go:1019
2400 CF452E 《后缀自动机及其应用》，张天扬 find-the-longest-semi-repetitive-substring copypasta/sam.go:49
2400 CF601D 把 (s[i], s[n-1-i]) 插入字典树 trie 合并 有 copypasta/trie.go:31
2400 CF710F 判环可以用 DFS + 三色标记法，见 graph.go 的「有向图的环」 copypasta/acam.go:49
2400 CF710F 包含 s[k] 的状态节点一定位于 s[k] 末尾节点的子树内 copypasta/acam.go:76
2400 CF822E 其他 有 copypasta/strings.go:1051
2400 CF825F 如果没有循环节，那么返回原串和 1 有 copypasta/strings.go:336
2400 CF1017E a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 在循环同构字符串 s 中查找 t，等价于在 s+(s[:n-1]) 中查找 t shortest-string-that-contains-three-strings 有 copypasta/strings.go:268
2400 CF1017E 都转成最小表示，看是否一样 有 copypasta/strings.go:504
2400 CF1080E 最长回文子串 Manacher（马拉车算法） longest-palindromic-substring 有 copypasta/strings.go:697
2400 CF1202E 包含 s[k] 的状态节点一定位于 s[k] 末尾节点的子树内 copypasta/acam.go:77
2400 CF1526E 反向问题 有 copypasta/strings.go:1066
2400 CF1720D2 一棵（所有叶节点深度都相同的）二叉树 转换 subarrays-with-xor-at-least-k 有 copypasta/trie01.go:27
2400 CF1777F 一棵（所有叶节点深度都相同的）二叉树 启发式合并 subarrays-with-xor-at-least-k copypasta/trie01.go:28
2400 CF1777F roots[i+1] = roots[i].put(v, trieBitLen-1) todo copypasta/trie01.go:392
2500 CF86C 包含 s[k] 的状态节点一定位于 s[k] 末尾节点的子树内 copypasta/acam.go:78
2500 CF580E 见 segment_tree.go 中的「区间加等比数列」 copypasta/strings.go:111
2500 CF607C 特别地，如果要判断两个字符串是否循环同构，可以用最小表示法，做到 O(1) 额外空间 string-transformation 有 copypasta/strings.go:271
2500 CF696D 包含 s[k] 的状态节点一定位于 s[k] 末尾节点的子树内 copypasta/acam.go:79
2500 CF778C 把 (s[i], s[n-1-i]) 插入字典树 copypasta/trie.go:32
2500 CF963D 包含 s[k] 的状态节点一定位于 s[k] 末尾节点的子树内 有 copypasta/acam.go:80
2500 CF1562E O(n^2) 计算 LCP —— 如果你不想用后缀数组的话 LIS 有 copypasta/strings.go:1327
2500 CF1665E roots[i+1] = roots[i].put(v, trieBitLen-1) todo 有 copypasta/trie01.go:393
2500 CF1983F 一棵（所有叶节点深度都相同的）二叉树 有 copypasta/trie01.go:29
2500 CF1983F b ^= 1 count-pairs-with-xor-in-a-range
subarrays-with-xor-at-least-k		 有 copypasta/trie01.go:250
2600 CF653F 子串统计类题目 copypasta/strings.go:1020
2600 CF1051E 模板题 DP 有 copypasta/strings.go:402
2600 CF1051E if l == len(pattern) { 有 copypasta/strings.go:465
2600 CF1312G 把 (s[i], s[n-1-i]) 插入字典树 注：输入就是一个 trie 有 copypasta/trie.go:33
2600 CF1437G 包含 s[k] 的状态节点一定位于 s[k] 末尾节点的子树内 copypasta/acam.go:81
2600 CF1739F 包含 s[k] 的状态节点一定位于 s[k] 末尾节点的子树内 copypasta/acam.go:82
2600 CF1827C 最长回文子串 Manacher（马拉车算法） longest-palindromic-substring 有 copypasta/strings.go:698
2600 CF1827C 只考虑偶回文串 单调栈 有 copypasta/strings.go:932
2700 CF235C 《后缀自动机及其应用》，张天扬 循环同构（也可以用后缀数组做） longest-common-subpath copypasta/sam.go:47
2700 CF241B 一棵（所有叶节点深度都相同的）二叉树 求个数以及和 copypasta/trie01.go:30
2700 CF241B b ^= 1 求个数以及和 count-pairs-with-xor-in-a-range
subarrays-with-xor-at-least-k		 copypasta/trie01.go:251
2700 CF1207G 包含 s[k] 的状态节点一定位于 s[k] 末尾节点的子树内 copypasta/acam.go:83
2700 CF1511F 把 (s[i], s[n-1-i]) 插入字典树 矩阵快速幂优化 DP 有 copypasta/trie.go:34
2700 CF1789F 子序列自动机 shortest-impossible-sequence-of-rolls
repeated-string-match		 有 copypasta/strings.go:586
2700 CF1849F 一棵（所有叶节点深度都相同的）二叉树 copypasta/trie01.go:31
2800 CF30E 最长回文子串 Manacher（马拉车算法） 有 copypasta/strings.go:699
2800 CF30E 只考虑奇回文串 maximum-product-of-the-length-of-two-palindromic-substrings 有 copypasta/strings.go:908
2800 CF163E 判环可以用 DFS + 三色标记法，见 graph.go 的「有向图的环」 有 copypasta/acam.go:46
2800 CF163E 包含 s[k] 的状态节点一定位于 s[k] 末尾节点的子树内 有 copypasta/acam.go:84
2800 CF196D 可以用随机 base 避免被 hack longest-duplicate-substring
strings-differ-by-one-character		 copypasta/strings.go:102
2800 CF547E 判环可以用 DFS + 三色标记法，见 graph.go 的「有向图的环」 string-matching-in-an-array
string-matching-in-an-array		 有 copypasta/acam.go:62
2800 CF1400F 包含 s[k] 的状态节点一定位于 s[k] 末尾节点的子树内 copypasta/acam.go:85
2800 CF1654F 注：这是《挑战》上的实现方案，复杂度 O(nlog^2(n)) copypasta/strings.go:1281
2900 CF17E 最长回文子串 Manacher（马拉车算法） 相交的回文子串对数 有 copypasta/strings.go:701
2900 CF932G 《字符串算法选讲》-金策 copypasta/pam.go:27
2900 CF1055F 一棵（所有叶节点深度都相同的）二叉树 copypasta/trie01.go:32
3000 CF1616H 一棵（所有叶节点深度都相同的）二叉树 有 copypasta/trie01.go:33
3400 CF1801G 包含 s[k] 的状态节点一定位于 s[k] 末尾节点的子树内 copypasta/acam.go:86
3500 CF1081H 最长回文子串 Manacher（马拉车算法） copypasta/strings.go:702
CF7D 根据下标转换关系得到子串 s[l:r+1] 在 t 中对应的回文中心下标为 l+r+2 有 copypasta/strings.go:765
CF17E 回文中心越来越大 正难则反，变成 CF159D 有 copypasta/strings.go:837
CF113B 注：这题还可以用后缀数组+前缀和二分来做到 O(nlogn) 有 copypasta/trie.go:239
CF114D cnt++ 用到的 node 个数尽量多 copypasta/trie.go:255
CF159D 最长回文子串 Manacher（马拉车算法） 同 17E 思考：改成选 k 个怎么做 有 copypasta/strings.go:700
CF159D 回文中心越来越大 有 copypasta/strings.go:836
CF271D 带限制的不同子串个数 有 copypasta/strings.go:1005
CF271D 做法是插入每个后缀，统计节点数。但题目往往会带上额外的条件 有 copypasta/trie.go:237
CF427D 单调栈 有 copypasta/strings.go:1043
CF432D 注：字符串倒过来就是每个后缀的出现次数 有 copypasta/strings.go:410
CF496B 看代码，如果 s[i+k] < s[j+k]，那么我们排除 非暴力做法 有 copypasta/strings.go:501
CF514C 可以用随机 base 避免被 hack construct-string-with-minimum-cost 有 copypasta/strings.go:92
CF547E 如果我们既知道前缀信息（trie），又知道后缀信息（fail），就可以做字符串匹配： 来理解 有 copypasta/acam.go:18
CF557E 回文串：中心扩展法 palindromic-substrings
maximum-number-of-non-overlapping-palindrome-substrings		 有 copypasta/strings.go:656
CF557E ！需要保证 trie 中至少有 k+1 个字符串 有 copypasta/trie.go:176
CF611D rj+1 是因为 query 是左闭右开 有 copypasta/strings.go:1148
CF822E 注：若允许离线可以用 Trie+Tarjan 做到线性 有 copypasta/strings.go:1131
CF835D 根据下标转换关系得到子串 s[l:r+1] 在 t 中对应的回文中心下标为 l+r+2 有 copypasta/strings.go:766
CF873F LCP 性质及其证明 longest-common-prefix-of-k-strings-after-removal 有 copypasta/strings.go:29
CF873F 由于 height 数组的性质，可以和二分/单调栈/单调队列结合 有 copypasta/strings.go:1105
CF1200E 可以用随机 base 避免被 hack construct-string-with-minimum-cost 有 copypasta/strings.go:93
CF1269B a 复制 k 或 k+1 份，k=(len(b)-1)/len(a)+1 ~1800 做到 O(nlogn) shortest-palindrome
distinct-echo-substrings		 有 copypasta/strings.go:255
CF1326D2 根据下标转换关系得到子串 s[l:r+1] 在 t 中对应的回文中心下标为 l+r+2 有 copypasta/strings.go:764
CF1418G 可以用随机 base 避免被 hack 有 copypasta/strings.go:87
CF1437G 广义 SAM copypasta/sam.go:290
CF1800D 可以用随机 base 避免被 hack construct-string-with-minimum-cost
count-prefix-and-suffix-pairs-ii		 有 copypasta/strings.go:95
CF1823D 本质不同回文串 https://codeforces.com/blog/entry/115465 copypasta/strings.go:32
CF1827C 回文中心越来越大 有 copypasta/strings.go:830
CFEDU-A 模板题 Codeforces EDU copypasta/strings.go:394
CFEDU-A 本质不同子串个数 Codeforces EDU copypasta/strings.go:997
CFEDU-B 模板题 Codeforces EDU copypasta/strings.go:404
CFEDU-B 两个字符串 Codeforces EDU copypasta/strings.go:1038
CFEDU-C 即 strings.Index(s+s, t) Codeforces EDU copypasta/strings.go:406
CFEDU-C rj+1 是因为 query 是左闭右开 Codeforces EDU copypasta/strings.go:1147
CFEDU-D 时间复杂度 O(n)。 Codeforces EDU copypasta/strings.go:426
CFEDU-D 子串统计类题目 Codeforces EDU copypasta/strings.go:1017
CFEDU-D 由于 height 数组的性质，可以和二分/单调栈/单调队列结合 Codeforces EDU copypasta/strings.go:1103
CFEDU-E 构造 s+reverse(s) Codeforces EDU copypasta/strings.go:428
CFEDU-E 由于 height 数组的性质，可以和二分/单调栈/单调队列结合 Codeforces EDU copypasta/strings.go:1104
CFEDU-F 构造 t+s Codeforces EDU copypasta/strings.go:430
CFEDU-F 重复次数最多的连续重复子串 Codeforces EDU copypasta/strings.go:1008
CFEDU-H 不同子串长度之和 Codeforces EDU copypasta/strings.go:1002
CF101628K 见 bst.go 中的 prev 和 next 有 copypasta/trie.go:206
CF101628K 此时 o.endCnt 保存子树字符串个数 有 copypasta/trie.go:222
CF103409J 所有子串排序拼起来的第 k 个字母 todo 子串去重后再拼接，先按照长度排序再按照字典序 copypasta/strings.go:1033
CF103585K 看代码，如果 s[i+k] < s[j+k]，那么我们排除 copypasta/strings.go:500
CF104787C 《字符串算法选讲》-金策 palindrome-partitioning-iv copypasta/pam.go:30

搜索

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
1400 CF550B 子集（也可以用二进制枚举做） copypasta/search.go:12
1400 CF962C 子集（也可以用二进制枚举做） 有 copypasta/search.go:13
1600 CF1778C 组合 也可以二进制枚举子集 有 copypasta/search.go:16
2100 CF525E 折半枚举/双向搜索 Meet in the middle 有 copypasta/search.go:763
2100 CF1006F 折半枚举/双向搜索 Meet in the middle 有 copypasta/search.go:764
2200 CF954I 见下面的 partitionSet 有 copypasta/search.go:26
2200 CF954I 写法二：记录每个下标所属集合（的编号） 有 copypasta/search.go:739
2300 CF327E 折半枚举/双向搜索 Meet in the middle 有 copypasta/search.go:765
2300 CF429C 暴搜 combination-sum copypasta/search.go:32
2300 CF628E 第一排在左上，最后一排在右下 diagonal-traverse
longest-line-of-consecutive-one-in-matrix		 有 copypasta/search.go:1227
2300 CF1132E 暴搜 背包 combination-sum copypasta/search.go:33
2400 CF31E 折半枚举/双向搜索 Meet in the middle 也可以 DP 有 copypasta/search.go:766
2400 CF58E 暴搜 combination-sum copypasta/search.go:34
2400 CF534F 折半枚举/双向搜索 Meet in the middle 打印方案 copypasta/search.go:767
2400 CF912E 折半枚举/双向搜索 Meet in the middle 有 copypasta/search.go:768
2400 CF1443E 返回 [1,2,…,n] 的字典序第 k 小的排列，k 从 1 开始 permutation-sequence 有 copypasta/search.go:670
2500 CF68D 最优性剪枝 有 copypasta/search.go:42
CF120H 生成字符串 s 的所有长度至多为 m 的非空子串（去重，按字典序返回） 有 copypasta/search.go:402
CF459C 指数型，即 n 层循环 有 copypasta/search.go:100
CF910C Permute the values at index i to len(arr)-1. 有 copypasta/search.go:583
CF954F 一些结论 有 copypasta/search.go:95
CF1276C 例如 有 copypasta/search.go:1246
CF1443E 结合康托展开和逆康托展开，可以求出一个排列的下 k 个排列 find-the-index-of-permutation
minimum-number-of-operations-to-make-string-sorted		 有 copypasta/search.go:632

位运算

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
1100 CF1682B a - b <= a XOR b <= a + b 交换 排序 有 copypasta/bits.go:72
1100 CF1957B & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 有 copypasta/bits.go:45
1100 CF1991B & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 有 copypasta/bits.go:46
1100 CF2074C 基础题 有 copypasta/bits.go:38
1100 CF2162C a - b <= a XOR b <= a + b 有 copypasta/bits.go:73
1200 CF1420B & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） XOR 有 copypasta/bits.go:47
1200 CF1420B XOR with AND 有 copypasta/bits.go:97
1200 CF1909B 基础题 有 copypasta/bits.go:40
1200 CF2039C1 a - b <= a XOR b <= a + b 有 copypasta/bits.go:74
1200 CF2094E 这里 ^2 表示子数组中任意两个数的异或 bitwise-or-of-all-subsequence-sums 有 copypasta/bits.go:128
1300 CF1601A 这里 ^2 表示子数组中任意两个数的异或 bitwise-or-of-all-subsequence-sums 有 copypasta/bits.go:129
1300 CF1775B & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 有 copypasta/bits.go:48
1300 CF1973B & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 有 copypasta/bits.go:50
1300 CF1981B [l, r] 的区间 OR copypasta/bits.go:466
1300 CF1988C & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 严格递增序列，满足 a[i] | a[i+1] = n 有 copypasta/bits.go:51
1300 CF2108B a - b <= a XOR b <= a + b 构造 异或和为 x 有 copypasta/bits.go:75
1300 CF2118C 这里 ^2 表示子数组中任意两个数的异或 bitwise-or-of-all-subsequence-sums 有 copypasta/bits.go:130
1300 CF2179D & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 构造排列，使 AND 前缀的 popcount 之和最大 有 copypasta/bits.go:49
1400 CF1362C 这里 ^2 表示子数组中任意两个数的异或 有 copypasta/bits.go:131
1400 CF1513B 这里 ^2 表示子数组中任意两个数的异或 有 copypasta/bits.go:132
1400 CF1790E ones(x^y) % 2 = (ones(x) + ones(y)) % 2 有 copypasta/bits.go:188
1400 CF1878E logTrick 的简单版本 · 其一 （难度分低是因为有其他做法） shortest-subarray-with-or-at-least-k-ii 有 copypasta/bits.go:553
1400 CF1878E 做法见下面的 logTrickCnt (见下面的 logTrickCnt) 也有其他做法 minimum-sum-of-values-by-dividing-array
number-of-subarrays-with-and-value-of-k		 有 copypasta/bits.go:690
1400 CF1878E 甚至还可以做到把每个运算结果对应的每个区间长度的出现次数求出来（需要差分） shortest-subarray-with-or-at-least-k-ii
minimum-sum-of-values-by-dividing-array		 有 copypasta/bits.go:729
1400 CF1918C 试填法 有 copypasta/bits.go:160
1400 CF2020C & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 有 copypasta/bits.go:52
1400 CF2035C & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 排列 &|&|&|… 结果最大 有 copypasta/bits.go:53
1400 CF2171C2 a - b <= a XOR b <= a + b 有 copypasta/bits.go:76
1500 CF891A 做法见下面的 logTrickCnt minimum-number-of-operations-to-make-all-array-elements-equal-to-1
maximum-gcd-sum-of-a-subarray		 有 copypasta/bits.go:697
1500 CF1299A & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 有 copypasta/bits.go:54
1500 CF1362C a(n) = a(floor(n/2)) + n 有 copypasta/bits.go:264
1500 CF1614C ^ 表示异或和 sum-of-all-subset-xor-totals 有 copypasta/bits.go:119
1500 CF1722G 构造 copypasta/bits.go:229
1500 CF2053C 基础题 做到 O(1) 时间 有 copypasta/bits.go:41
1500 CF2057C a - b <= a XOR b <= a + b 构造 可以做到 O(1) 有 copypasta/bits.go:77
1500 CF2146D1 & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 有 copypasta/bits.go:55
1500 CF2225D 支持 n = -1 的情况，此时返回 0 xor-operation-in-an-array
xor-operation-in-an-array		 有 copypasta/bits.go:475
1600 CF243A 空间复杂度：O(logU)，返回值不计入 bitwise-ors-of-subarrays 有 copypasta/bits.go:678
1600 CF1775C & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 连续数字 AND 等于目标值 有 copypasta/bits.go:56
1600 CF2036E & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） copypasta/bits.go:57
1600 CF2085C & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 构造 k，使得 (x+k) AND (y+k) = 0 有 copypasta/bits.go:58
1700 CF76D ones(x^y) % 2 = (ones(x) + ones(y)) % 2 有 copypasta/bits.go:189
1700 CF627A ones(x^y) % 2 = (ones(x) + ones(y)) % 2 有 copypasta/bits.go:190
1700 CF1325D ones(x^y) % 2 = (ones(x) + ones(y)) % 2 有 copypasta/bits.go:191
1700 CF1368D ones(x^y) % 2 = (ones(x) + ones(y)) % 2 有 copypasta/bits.go:192
1700 CF1879D 这里 ^2 表示子数组中任意两个数的异或 sum(子数组异或和*子数组长度) 有 copypasta/bits.go:133
1700 CF1903D1 试填法 这题抄袭 arc146_b 题 有 copypasta/bits.go:161
1800 CF1556D ones(x^y) % 2 = (ones(x) + ones(y)) % 2 有 copypasta/bits.go:193
1800 CF1955F a - b <= a XOR b <= a + b 有 copypasta/bits.go:78
1800 CF1968F a - b <= a XOR b <= a + b 有 copypasta/bits.go:79
1800 CF2039C2 a - b <= a XOR b <= a + b 有 copypasta/bits.go:80
1900 CF309C 思维题（贪心、脑筋急转弯等） minimum-operations-to-form-subsequence-with-target-sum 有 copypasta/bits.go:205
1900 CF894C 做法见下面的 logTrickCnt 已知所有 GCD 还原数组 a maximum-gcd-sum-of-a-subarray 有 copypasta/bits.go:700
1900 CF981D 这里 ^2 表示子数组中任意两个数的异或 有 copypasta/bits.go:134
1900 CF1895D a - b <= a XOR b <= a + b 有 copypasta/bits.go:81
1900 CF1895D 这里 ^2 表示子数组中任意两个数的异或 有 copypasta/bits.go:135
1900 CF1946D XOR with OR copypasta/bits.go:101
1900 CF1991D a - b <= a XOR b <= a + b 有 copypasta/bits.go:82
1900 CF2036F a - b <= a XOR b <= a + b copypasta/bits.go:83
1900 CF2180C a - b <= a XOR b <= a + b 构造 XOR(a) = n 且 sum(a) 尽量大 有 copypasta/bits.go:84
2000 CF15C 支持 n = -1 的情况，此时返回 0 xor-operation-in-an-array
xor-operation-in-an-array		 有 copypasta/bits.go:476
2000 CF475D 注：效率不如 logTrickCnt 有 copypasta/bits.go:646
2000 CF475D 做法见下面的 logTrickCnt (见下面的 logTrickCnt) minimum-number-of-operations-to-make-all-array-elements-equal-to-1
maximum-gcd-sum-of-a-subarray		 有 copypasta/bits.go:698
2000 CF475D 甚至还可以做到把每个运算结果对应的每个区间长度的出现次数求出来（需要差分） shortest-subarray-with-or-at-least-k-ii
minimum-sum-of-values-by-dividing-array		 有 copypasta/bits.go:730
2000 CF1088D a - b <= a XOR b <= a + b 交互 有 copypasta/bits.go:85
2000 CF1416C 试填法 有 copypasta/bits.go:162
2000 CF1632D cnt[opRes] += c () 用 logTrickCnt 写起来更简单 有 copypasta/bits.go:669
2000 CF1632D 做法见下面的 logTrickCnt (见下面的 logTrickCnt) minimum-number-of-operations-to-make-all-array-elements-equal-to-1
maximum-gcd-sum-of-a-subarray		 有 copypasta/bits.go:699
2000 CF1632D 甚至还可以做到把每个运算结果对应的每个区间长度的出现次数求出来（需要差分） shortest-subarray-with-or-at-least-k-ii
minimum-sum-of-values-by-dividing-array		 有 copypasta/bits.go:732
2000 CF1872G 注：根据以上推导过程，我们还可以得出总的答案个数至多为 O(nlog(sum(a))) 有 copypasta/bits.go:797
2000 CF1994E & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 有 copypasta/bits.go:59
2000 CF2075D max(x,y) 的二进制长度 - x^y 的二进制长度 有 copypasta/bits.go:447
2000 CF2146D2 & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 有 copypasta/bits.go:60
2000 CF2165C 思维题（贪心、脑筋急转弯等） minimum-operations-to-form-subsequence-with-target-sum 有 copypasta/bits.go:206
2100 CF703D a - b <= a XOR b <= a + b 有 copypasta/bits.go:86
2100 CF1322B 加法拆位（进位拆位）：涉及到加法进位的题目，可以按照 mod 2^k 拆位 有 copypasta/bits.go:153
2100 CF1732C2 ones(x^y) % 2 = (ones(x) + ones(y)) % 2 + 与 ^ 有 copypasta/bits.go:194
2100 CF1934D1 在此基础上 XOR 区间去重后的元素异或和 = 区间中出现次数为【偶数】的元素异或和 有 copypasta/bits.go:89
2200 CF875D 甚至还可以做到把每个运算结果对应的每个区间长度的出现次数求出来（需要差分） 与单调栈结合 shortest-subarray-with-or-at-least-k-ii
minimum-sum-of-values-by-dividing-array		 有 copypasta/bits.go:733
2200 CF1615D 在此基础上 XOR 区间去重后的元素异或和 = 区间中出现次数为【偶数】的元素异或和 copypasta/bits.go:90
2200 CF2013E 做法见下面的 logTrickCnt 巧妙转换 有 copypasta/bits.go:702
2300 CF1614D2 做法见下面的 logTrickCnt maximum-gcd-sum-of-a-subarray copypasta/bits.go:701
2300 CF1834E 做法见下面的 logTrickCnt number-of-subarrays-with-lcm-equal-to-k 有 copypasta/bits.go:706
2400 CF835E 在此基础上 XOR 区间去重后的元素异或和 = 区间中出现次数为【偶数】的元素异或和 交互 有 copypasta/bits.go:91
2400 CF1592E XOR with AND 子数组 AND > 子数组 XOR 的最长子数组 有 copypasta/bits.go:98
2400 CF1777F 这里 ^2 表示子数组中任意两个数的异或 copypasta/bits.go:136
2400 CF1874B 加法拆位（进位拆位）：涉及到加法进位的题目，可以按照 mod 2^k 拆位 有 copypasta/bits.go:155
2400 CF1935E & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 从高到低 有 copypasta/bits.go:61
2400 CF2005D 甚至还可以做到把每个运算结果对应的每个区间长度的出现次数求出来（需要差分） 双序列 前后缀分解 minimum-sum-of-values-by-dividing-array 有 copypasta/bits.go:734
2500 CF1665E & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 两数 OR 的最小值：只需要知道区间内最小的 bits.Len(U) + 1 个数 有 copypasta/bits.go:62
2500 CF1710C 在此基础上 XOR 区间去重后的元素异或和 = 区间中出现次数为【偶数】的元素异或和 三角形三边 有 copypasta/bits.go:92
2500 CF1779F 在此基础上 XOR 区间去重后的元素异或和 = 区间中出现次数为【偶数】的元素异或和 操作至多 2n 次：把一棵子树的所有点权都置为 S，其中 S 是子树点权异或和 有 copypasta/bits.go:93
2600 CF1004F & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 有 copypasta/bits.go:63
2600 CF1004F 空间复杂度：O(logU)，返回值不计入 线段树 merge shortest-subarray-with-or-at-least-k-ii
find-subarray-with-bitwise-or-closest-to-k		 有 copypasta/bits.go:682
2600 CF1815D ones(x^y) % 2 = (ones(x) + ones(y)) % 2 有 copypasta/bits.go:196
2600 CF1945H & 和 | 在区间求和上具有单调性（本页面搜索 logTrickCnt） 分类暴力 有 copypasta/bits.go:64
CF276D 复杂度 O(log(high)) 有 copypasta/bits.go:862
CF460D 异或和相关 有 copypasta/bits.go:271
CF460D 找三个不同的在 [l,r] 范围内的数，其异或和为 0 有 copypasta/bits.go:845
CF691B 位运算与字符串 number-of-changing-keys
lexicographically-minimum-string-after-removing-stars		 有 copypasta/bits.go:213
CF817C 十进制 digsum 有 copypasta/bits.go:333
CF925C 二进制字符串 有 copypasta/bits.go:394
CF1027E 构造 2^n-1，即 n 个 1 的另一种方法: ^(-1<<n) 有 copypasta/bits.go:240
CF1373E (n%9+1) * int(math.Pow10(n/9)) - 1 有 copypasta/bits.go:348
CF1415D 二进制字符串 有 copypasta/bits.go:393
CF1469E 二进制字符串 有 copypasta/bits.go:391
CF1493E 异或和相关 有 copypasta/bits.go:270
CF1554C 异或与 mex 有 copypasta/bits.go:283
CF1554C 返回最小的非负 x，其满足 n^x >= m 有 copypasta/bits.go:532
CF1617E 构造 2^n-1，即 n 个 1 的另一种方法: ^(-1<<n) concatenation-of-consecutive-binary-numbers 有 copypasta/bits.go:249
CF1689E 利用 lowbit 有 copypasta/bits.go:104
CF1709E 人为地创造出「相等」这个条件 有 copypasta/bits.go:291
CF1720D2 人为地创造出「相等」这个条件 有 copypasta/bits.go:289
CF1761D 集合论公式的二进制等价形式： number-of-excellent-pairs copypasta/bits.go:173
CF1780D 利用 lowbit 有 copypasta/bits.go:105
CF1901C max(x,y) 的二进制长度 - x^y 的二进制长度 有 copypasta/bits.go:442
CF1907B 位运算与字符串 number-of-changing-keys
lexicographically-minimum-string-after-removing-stars		 有 copypasta/bits.go:214
CF1918C 思维题（贪心、脑筋急转弯等） minimum-operations-to-form-subsequence-with-target-sum 有 copypasta/bits.go:204
CFEDU-G 做法见下面的 logTrickCnt Codeforces EDU copypasta/bits.go:696

基础算法

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
1300 CF600B ### 二分查找 有 copypasta/sort.go:30
1300 CF1003C 有长度限制的连续子段的（最大/最小）算数平均值 有 copypasta/sort.go:618
1300 CF1538C ### 二分查找 有 copypasta/sort.go:31
1400 CF604B ### 二分答案：求最小 也有 O(n) 做法 有 copypasta/sort.go:40
1400 CF1201C ### 最大化中位数 也可以贪心做 有 copypasta/sort.go:101
1400 CF1701C ### 二分答案：求最小 有 copypasta/sort.go:41
1400 CF1840D 好比用一个盖子去压住最大值，让最大值尽量小 有 copypasta/sort.go:76
1500 CF165B ### 二分查找 有 copypasta/sort.go:32
1500 CF670D2 ### 二分答案：求最大 有 copypasta/sort.go:53
1500 CF760B ### 二分答案：求最大 有 copypasta/sort.go:54
1500 CF812C ### 二分答案：求最大 同时记录一个副产物 有 copypasta/sort.go:55
1500 CF991C ### 二分答案：求最小 有 copypasta/sort.go:42
1500 CF1208B ### 二分答案：求最小 有 copypasta/sort.go:43
1500 CF1301B 比较两个三分点值的大小，每次去掉 1/3 的区间 不用三分也可以 有 copypasta/sort.go:568
1500 CF1971E ### 二分查找 有 copypasta/sort.go:33
1500 CF2070C 好比用一个盖子去压住最大值，让最大值尽量小 有 copypasta/sort.go:77
1600 CF1610C ### 二分答案：求最大 有 copypasta/sort.go:56
1600 CF1623C 好比用一个盖子去压住最大值，让最大值尽量小 有 copypasta/sort.go:87
1600 CF1665C ### 二分答案：求最小 有 copypasta/sort.go:44
1600 CF1707A ### 不好想到的二分（这也能二分？！） 有 copypasta/sort.go:118
1600 CF1843E ### 二分答案：求最小 有 copypasta/sort.go:45
1600 CF1856C ### 二分答案：求最大 也可以不用二分 有 copypasta/sort.go:57
1600 CF1946C ### 二分答案：求最大 有 copypasta/sort.go:58
1600 CF2167E 好比用一个盖子去压住最大值，让最大值尽量小 有 copypasta/sort.go:88
1700 CF460C 好比用一个盖子去压住最大值，让最大值尽量小 有 copypasta/sort.go:89
1700 CF1118D2 ### 二分答案：求最小 有 copypasta/sort.go:46
1700 CF1792D ### 二分查找 有 copypasta/sort.go:34
1700 CF1945E 测试一下，你有没有学到二分的本质？ copypasta/sort.go:22
1700 CF1983D 做法：离散化后求置换环 minimum-number-of-operations-to-sort-a-binary-tree-by-level 有 copypasta/sort.go:269
1700 CF1999G2 测试一下，你有没有学到二分的本质？ 有 copypasta/sort.go:23
1700 CF2110D ### 二分答案：求最小 也有 O(n+m) 做法 有 copypasta/sort.go:47
1800 CF645D ### 二分答案：求最小 也有 O(n) 做法 有 copypasta/sort.go:48
1800 CF799C ### 二分查找 有 copypasta/sort.go:35
1800 CF1073C ### 二分答案：求最小 有 copypasta/sort.go:49
1900 CF883I 好比用一个盖子去压住最大值，让最大值尽量小 DP 有 copypasta/sort.go:78
1900 CF1260D ### 二分答案：求最大 区间合并 有 copypasta/sort.go:59
1900 CF1354D 算法一：排序后二分中位数，copy 数组两侧搞 nthElement 隐藏的二分 有 copypasta/sort.go:138
1900 CF1697D 算法一：排序后二分中位数，copy 数组两侧搞 nthElement 有 copypasta/sort.go:136
1900 CF1918D 好比用一个盖子去压住最大值，让最大值尽量小 有 copypasta/sort.go:79
1900 CF1996F ### 二分答案：求最大 二分间接值 有 copypasta/sort.go:60
2000 CF1624F 测试一下，你有没有学到二分的本质？ 有 copypasta/sort.go:24
2000 CF1744F ## 性质 有 copypasta/mex.go:8
2100 CF1355E 比较两个三分点值的大小，每次去掉 1/3 的区间 有 copypasta/sort.go:569
2100 CF2008H ### 最小化中位数 有 copypasta/sort.go:98
2100 CF2037F ### 二分答案：求最小 有 copypasta/sort.go:50
2100 CF2038B 为了保证任意情况都能更新答案，需要把上界加一 copypasta/sort.go:69
2100 CF2046C 好比用一个盖子去压住最大值，让最大值尽量小 有 copypasta/sort.go:90
2200 CF1181D 算法一：排序后二分中位数，copy 数组两侧搞 nthElement 转换的好题 有 copypasta/sort.go:139
2200 CF1993D ### 最大化中位数 copypasta/sort.go:102
2300 CF489E 其他题目 与 DP 结合 有 copypasta/sort.go:651
2400 CF605C NOTE: 多个下凸函数的乘积仍然是下凸函数；上凸同理 ABC130F 有 copypasta/sort.go:538
2400 CF626E 比较两个三分点值的大小，每次去掉 1/3 的区间 最大化平均值减中位数 有 copypasta/sort.go:570
2400 CF912E 第 k 大等价于：求最大的 x，满足 >= x 的数至少有 k 个（k 从 1 开始） 有 copypasta/sort.go:107
2400 CF1436E ## 性质 有 copypasta/mex.go:9
2400 CF1527D ## 性质 有 copypasta/mex.go:10
2400 CF1837F 好比用一个盖子去压住最大值，让最大值尽量小 有 copypasta/sort.go:80
2500 CF314D 好比用一个盖子去压住最大值，让最大值尽量小 有 copypasta/sort.go:81
2500 CF993D 其他题目 copypasta/sort.go:652
2500 CF1550E 好比用一个盖子去压住最大值，让最大值尽量小 有 copypasta/sort.go:91
2500 CF1983F 第 k 大等价于：求最大的 x，满足 >= x 的数至少有 k 个（k 从 1 开始） 有 copypasta/sort.go:108
2600 CF627D 好比用一个盖子去压住最大值，让最大值尽量小 有 copypasta/sort.go:92
2600 CF875E 好比用一个盖子去压住最大值，让最大值尽量小 copypasta/sort.go:82
2900 CF505E 好比用一个盖子去压住最大值，让最大值尽量小 todo 回顾思路 有 copypasta/sort.go:83
3200 CF1446F 第 k 大等价于：求最大的 x，满足 >= x 的数至少有 k 个（k 从 1 开始） copypasta/sort.go:109
CF266C sort.Sort(r) 有 copypasta/sort.go:168
CF578C 如果返回结果不是答案的话，注意误差对答案的影响 有 copypasta/sort.go:506
CF653D 如果返回结果不是答案的话，注意误差对答案的影响 有 copypasta/sort.go:507
CF1100E 为了保证能至少触发一次 true，某些情况下需要将二分上界 +1 有 copypasta/sort.go:359
CF1817A 在多个左闭右开区间中，查找与 [l,r) 有交集的所有区间 有 copypasta/sort.go:246
CFEDU-A 实数二分 Codeforces EDU copypasta/sort.go:514
CFEDU-A 有长度限制的连续子段的（最大/最小）算数平均值 Codeforces EDU copypasta/sort.go:617
CFEDU-B 最优比率路径 Codeforces EDU copypasta/sort.go:647
CFEDU-C 分数规划 Codeforces EDU copypasta/sort.go:612
CFEDU-D NOTE: l 和 r 最好稍微往左右取宽点，从而保证触发相关逻辑 Codeforces EDU copypasta/sort.go:510
CF101234G 算法一：排序后二分中位数，copy 数组两侧搞 nthElement https://leetcode.cn/problems/find-the-k-sum-of-an-array/ find-the-k-sum-of-an-array copypasta/sort.go:141
CF101234G 除了二分，另一种求法是使用最小堆 copypasta/sort.go:481

离线算法

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
2200 CF1906F 点评：不错的题目，也有在线做法（线段树二分、单调栈+倍增等），可以把很多算法串起来 minimum-interval-to-include-each-query
checking-existence-of-edge-length-limited-paths		 有 copypasta/offline.go:14
2900 CF1028H 点评：不错的题目，也有在线做法（线段树二分、单调栈+倍增等），可以把很多算法串起来 思路类似 HH 的项链，但更加复杂 minimum-interval-to-include-each-query
checking-existence-of-edge-length-limited-paths		 有 copypasta/offline.go:15

模拟与构造

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
1400 CF799B 小模拟 有序集合/最小堆 design-video-sharing-platform
candy-crush		 copypasta/implementation.go:10
1600 CF1774D 小模拟 交换 0 1 使得每行 1 的个数都一样 design-video-sharing-platform
candy-crush		 有 copypasta/implementation.go:11
1900 CF1974F 小模拟 design-video-sharing-platform
candy-crush		 有 copypasta/implementation.go:12
1900 CF2064D 小模拟 design-video-sharing-platform
candy-crush		 有 copypasta/implementation.go:13
2000 CF899E 小模拟 三种数据结构（做法不止一种） design-video-sharing-platform
candy-crush		 有 copypasta/implementation.go:14
2200 CF2009G2 有较多下标参与运算的题目 有 copypasta/implementation.go:20

通用思维与技巧

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
1000 CF688B 按顺序从小到大生成所有回文数 find-the-count-of-good-integers
find-the-closest-palindrome		 有 copypasta/common.go:1205
1000 CF862A 分类讨论（部分题是易错题） 有 copypasta/common.go:726
1000 CF1174A 构造 constructive algorithms 有 copypasta/common.go:583
1000 CF1333A 思维：脑筋急转弯 有 copypasta/common.go:526
1000 CF1333A 构造 constructive algorithms 脑筋急转弯 有 copypasta/common.go:584
1000 CF1469A 合法括号字符串（Regular Bracket Sequence, RBS） 有 copypasta/common.go:910
1000 CF1550B 贪心（证明算法的正确性比算法难） split-array-into-consecutive-subsequences
minimum-number-of-moves-to-make-palindrome		 有 copypasta/common.go:322
1000 CF1550B 分类讨论（部分题是易错题） 有 copypasta/common.go:727
1000 CF1632B 思维：脑筋急转弯 位运算 XOR 有 copypasta/common.go:527
1000 CF1772C 构造 constructive algorithms 差分数组不同元素个数尽量多 有 copypasta/common.go:585
1000 CF1931C 分类讨论（部分题是易错题） 有 copypasta/common.go:728
1000 CF1998B 构造 constructive algorithms 有 copypasta/common.go:586
1000 CF2037C 构造 constructive algorithms 有 copypasta/common.go:587
1000 CF2039B 构造 constructive algorithms 分析性质 有 copypasta/common.go:588
1000 CF2039B 分类讨论（部分题是易错题） 有 copypasta/common.go:729
1000 CF2040B 构造 constructive algorithms 有 copypasta/common.go:589
1100 CF296A 或者说，每次删除两个不同元素，最多能删多少次？ 有 copypasta/common.go:438
1100 CF1574B 或者说，每次删除两个不同元素，最多能删多少次？ 有 copypasta/common.go:439
1100 CF1637B 思维：脑筋急转弯 copypasta/common.go:528
1100 CF1638B 邻项交换法（最小代价排序/字典序最小） Exchange Arguments minimum-initial-energy-to-finish-tasks copypasta/common.go:460
1100 CF1682B 非邻项交换（最小代价排序/字典序最小） AND 有 copypasta/common.go:469
1100 CF1708B 思维：脑筋急转弯 有 copypasta/common.go:529
1100 CF1739B 思维：观察、结论 有 copypasta/common.go:488
1100 CF1743C 内层循环负责遍历组，找出这一组最远在哪结束。 count-unguarded-cells-in-the-grid
number-of-subarrays-having-even-product		 有 copypasta/common.go:274
1100 CF1793B 构造 constructive algorithms 思路好猜，证明更有意思 有 copypasta/common.go:590
1100 CF1811C 思维：观察、结论 有 copypasta/common.go:489
1100 CF1920B 贪心（证明算法的正确性比算法难） split-array-into-consecutive-subsequences
minimum-number-of-moves-to-make-palindrome		 有 copypasta/common.go:323
1100 CF1921D 部分题目也可以用状态机 DP 解决 flip-string-to-monotone-increasing 有 copypasta/common.go:127
1100 CF1957B 构造 constructive algorithms 有 copypasta/common.go:591
1100 CF1993B 贪心（证明算法的正确性比算法难） split-array-into-consecutive-subsequences
minimum-number-of-moves-to-make-palindrome		 有 copypasta/common.go:324
1100 CF1997B 思维：观察、结论 有 copypasta/common.go:490
1100 CF2043B 分类讨论（部分题是易错题） copypasta/common.go:730
1100 CF2044D 思维：脑筋急转弯 有 copypasta/common.go:530
1100 CF2044D 构造 constructive algorithms 脑筋急转弯 有 copypasta/common.go:592
1100 CF2071B 构造 constructive algorithms 排列 前缀和没有完全平方数 有 copypasta/common.go:594
1100 CF2094D 内层循环负责遍历组，找出这一组最远在哪结束。 count-unguarded-cells-in-the-grid
number-of-subarrays-having-even-product		 copypasta/common.go:275
1100 CF2111C 内层循环负责遍历组，找出这一组最远在哪结束。 count-unguarded-cells-in-the-grid
number-of-subarrays-having-even-product		 有 copypasta/common.go:276
1100 CF2162C 构造 constructive algorithms 分类讨论 XOR a -> b 有 copypasta/common.go:593
1100 CF2162C 分类讨论（部分题是易错题） 有 copypasta/common.go:731
1100 CF2241D 贪心（证明算法的正确性比算法难） 从左到右贪心 split-array-into-consecutive-subsequences
minimum-number-of-moves-to-make-palindrome		 有 copypasta/common.go:325
1200 CF4B 构造 constructive algorithms copypasta/common.go:595
1200 CF262B 分类讨论（部分题是易错题） 有 copypasta/common.go:732
1200 CF385B 更多贡献法题目，见 monotone_stack.go 做到 O(n) 有 copypasta/common.go:842
1200 CF482A 构造 constructive algorithms 有 copypasta/common.go:596
1200 CF489B 双序列双指针 有 copypasta/common.go:241
1200 CF651B 构造 constructive algorithms 有 copypasta/common.go:597
1200 CF1006C 部分题目也可以用状态机 DP 解决 也可以相向双指针 flip-string-to-monotone-increasing 有 copypasta/common.go:128
1200 CF1006C 相向双指针 同向双指针 有 copypasta/common.go:228
1200 CF1028B 构造 constructive algorithms 有 copypasta/common.go:598
1200 CF1174B 非邻项交换（最小代价排序/字典序最小） 有 copypasta/common.go:470
1200 CF1257C 思维：脑筋急转弯 有 copypasta/common.go:531
1200 CF1270B 枚举右，维护左 式子变形 或者 脑筋急转弯 number-of-good-pairs
sum-of-digit-differences-of-all-pairs		 有 copypasta/common.go:51
1200 CF1270B 思维：脑筋急转弯 有 copypasta/common.go:532
1200 CF1272C 内层循环负责遍历组，找出这一组最远在哪结束。 count-unguarded-cells-in-the-grid
number-of-subarrays-having-even-product		 有 copypasta/common.go:277
1200 CF1343C 内层循环负责遍历组，找出这一组最远在哪结束。 number-of-subarrays-having-even-product 有 copypasta/common.go:278
1200 CF1354B 不定长滑动窗口：求最短/最小 有 copypasta/common.go:181
1200 CF1364A 分类讨论（部分题是易错题） 有 copypasta/common.go:733
1200 CF1384A 构造 constructive algorithms copypasta/common.go:599
1200 CF1406B 乘法贪心 5 个数的最大乘积 有 copypasta/common.go:410
1200 CF1420B 枚举右，维护左 number-of-good-pairs
sum-of-digit-differences-of-all-pairs		 有 copypasta/common.go:52
1200 CF1635C 构造 constructive algorithms 有 copypasta/common.go:600
1200 CF1692E 不定长滑动窗口：求最长/最大 copypasta/common.go:172
1200 CF1713C 构造 constructive algorithms copypasta/common.go:601
1200 CF1793C 相向双指针 同向双指针 有 copypasta/common.go:229
1200 CF1793C 构造 constructive algorithms 有 copypasta/common.go:602
1200 CF1822D 思维：观察、结论 有 copypasta/common.go:491
1200 CF1860B 分类讨论（部分题是易错题） 有 copypasta/common.go:734
1200 CF1954B 思维：观察、结论 有 copypasta/common.go:492
1200 CF1982C 前缀和与有序集合 也可以滑窗 有 copypasta/common.go:100
1200 CF1982C 不定长滑动窗口：上下界 有 copypasta/common.go:190
1200 CF1990B 构造 constructive algorithms copypasta/common.go:603
1200 CF2019B 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:843
1200 CF2047B 贪心（证明算法的正确性比算法难） O(n) 做法约 split-array-into-consecutive-subsequences
minimum-number-of-moves-to-make-palindrome		 有 copypasta/common.go:326
1200 CF2053B 前缀和 range-sum-query-immutable 有 copypasta/common.go:1419
1200 CF2053B 分类讨论（部分题是易错题） 有 copypasta/common.go:735
1200 CF2056C 构造 constructive algorithms 有 copypasta/common.go:604
1200 CF2065D 排序不等式 有 copypasta/common.go:425
1200 CF2072C 构造 constructive algorithms 有 copypasta/common.go:605
1200 CF2092C 不变量（想一想，操作不会改变什么） 有 copypasta/common.go:710
1200 CF2117C 贪心（证明算法的正确性比算法难） minimum-number-of-moves-to-make-palindrome 有 copypasta/common.go:327
1200 CF2118B 构造 constructive algorithms 有 copypasta/common.go:606
1200 CF2126D 贪心（证明算法的正确性比算法难） 区间贪心 有 copypasta/common.go:328
1200 CF2134B 构造 constructive algorithms 操作至多 k 次：把 a 的一个子序列的元素都增加 k，最终让 gcd(a) > 1（提示：从特殊到一般） 有 copypasta/common.go:607
1200 CF2202B 思维：观察、结论 有 copypasta/common.go:493
1300 CF234C 部分题目也可以用状态机 DP 解决 flip-string-to-monotone-increasing 有 copypasta/common.go:129
1300 CF318B 枚举右，维护左 子串 sum-of-digit-differences-of-all-pairs 有 copypasta/common.go:54
1300 CF545D 贪心（证明算法的正确性比算法难） 有 copypasta/common.go:329
1300 CF681B 暴力枚举 copypasta/common.go:38
1300 CF716B 定长滑动窗口 有 copypasta/common.go:160
1300 CF870C 分类讨论（部分题是易错题） 有 copypasta/common.go:736
1300 CF897B 按顺序从小到大生成所有回文数 find-the-count-of-good-integers
find-the-closest-palindrome		 有 copypasta/common.go:1206
1300 CF932B 前缀和 range-sum-query-immutable copypasta/common.go:1420
1300 CF1077C 思维：观察、结论 有 copypasta/common.go:494
1300 CF1178B 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:130
1300 CF1279B 贪心（证明算法的正确性比算法难） 有 copypasta/common.go:330
1300 CF1364B 思维：观察、结论 有 copypasta/common.go:495
1300 CF1373C 合法括号字符串（Regular Bracket Sequence, RBS） 有 copypasta/common.go:911
1300 CF1443B 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:131
1300 CF1443B 贪心（证明算法的正确性比算法难） 有 copypasta/common.go:331
1300 CF1498B 贪心（证明算法的正确性比算法难） 从大到小贪心 有 copypasta/common.go:332
1300 CF1538C 相向双指针 a[i] + b[j] = < > target 有 copypasta/common.go:247
1300 CF1555B 贪心（证明算法的正确性比算法难） 有 copypasta/common.go:333
1300 CF1585C 贪心（证明算法的正确性比算法难） 有 copypasta/common.go:334
1300 CF1693A 合法括号字符串（Regular Bracket Sequence, RBS） 类似思想 有 copypasta/common.go:912
1300 CF1698C 分类讨论（部分题是易错题） 有 copypasta/common.go:737
1300 CF1717C 构造 constructive algorithms 有 copypasta/common.go:608
1300 CF1733C 构造 constructive algorithms 有 copypasta/common.go:609
1300 CF1788C 构造 constructive algorithms 有 copypasta/common.go:610
1300 CF1794C 不定长滑动窗口：求最长/最大 式子变形 minimum-operations-to-reduce-x-to-zero 有 copypasta/common.go:175
1300 CF1815A 构造 constructive algorithms 有 copypasta/common.go:611
1300 CF1821C 内层循环负责遍历组，找出这一组最远在哪结束。 枚举答案 number-of-subarrays-having-even-product copypasta/common.go:279
1300 CF1844C 思维：观察、结论 假设答案是某些数之和，经过什么样的操作可以得到这些数？ 有 copypasta/common.go:496
1300 CF1873F 不定长滑动窗口：求最长/最大 minimum-operations-to-reduce-x-to-zero 有 copypasta/common.go:174
1300 CF1873F 内层循环负责遍历组，找出这一组最远在哪结束。 有 copypasta/common.go:280
1300 CF1881D 不变量（想一想，操作不会改变什么） 有 copypasta/common.go:711
1300 CF1889A 不变量（想一想，操作不会改变什么） 有 copypasta/common.go:712
1300 CF1902C 贪心（证明算法的正确性比算法难） 有 copypasta/common.go:335
1300 CF1915E 前缀和与哈希表 交错前缀和 copypasta/common.go:83
1300 CF1922C 前缀和 range-sum-query-immutable 有 copypasta/common.go:1421
1300 CF1926D 枚举右，维护左 有 copypasta/common.go:56
1300 CF1931D 枚举右，维护左 pair 有 copypasta/common.go:55
1300 CF1978C 构造 constructive algorithms copypasta/common.go:612
1300 CF1980C 构造 constructive algorithms 有 copypasta/common.go:613
1300 CF1988C 构造 constructive algorithms 严格递增序列，满足 a[i] | a[i+1] = n 有 copypasta/common.go:614
1300 CF1991C 思维：观察、结论 有 copypasta/common.go:497
1300 CF1999E 贪心（证明算法的正确性比算法难） 有 copypasta/common.go:336
1300 CF2026B 部分题目也可以用状态机 DP 解决 做到 O(n) 有 copypasta/common.go:132
1300 CF2031C 构造 constructive algorithms 本格构造 有 copypasta/common.go:615
1300 CF2033D 前缀和 range-sum-query-immutable 有 copypasta/common.go:1422
1300 CF2064C 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:133
1300 CF2065C2 分类讨论（部分题是易错题） 有 copypasta/common.go:738
1300 CF2075B 分类讨论（部分题是易错题） 有 copypasta/common.go:739
1300 CF2108B 构造 constructive algorithms 构造 异或和为 x 有 copypasta/common.go:616
1300 CF2108B 大量分类讨论 构造 异或和为 x 有 copypasta/common.go:815
1300 CF2112C 相向双指针 a[i] + b[j] = < > target 有 copypasta/common.go:248
1300 CF2145C 前缀和与哈希表 有 copypasta/common.go:84
1300 CF2146C 内层循环负责遍历组，找出这一组最远在哪结束。 有 copypasta/common.go:281
1300 CF2146C 构造 constructive algorithms 有 copypasta/common.go:617
1300 CF2169C 枚举右，维护左 有 copypasta/common.go:57
1300 CF2169C 前缀和 range-sum-query-immutable 有 copypasta/common.go:1423
1300 CF2175B 前缀和 range-sum-query-immutable 有 copypasta/common.go:1424
1300 CF2179D 构造 constructive algorithms 构造排列，使 AND 前缀的 popcount 之和最大 有 copypasta/common.go:618
1400 CF30A 分类讨论（部分题是易错题） 有 copypasta/common.go:740
1400 CF45I 乘法贪心 有 copypasta/common.go:411
1400 CF45I 分类讨论（部分题是易错题） 有 copypasta/common.go:741
1400 CF180C 部分题目也可以用状态机 DP 解决 trapping-rain-water
flip-string-to-monotone-increasing		 有 copypasta/common.go:124
1400 CF363C 内层循环负责遍历组，找出这一组最远在哪结束。 分组循环 + 分组循环 有 copypasta/common.go:282
1400 CF388A 贪心（证明算法的正确性比算法难） 有 copypasta/common.go:337
1400 CF435B 邻项交换法（最小代价排序/字典序最小） Exchange Arguments minimum-initial-energy-to-finish-tasks 有 copypasta/common.go:462
1400 CF437C 贪心（证明算法的正确性比算法难） 排序不等式/交换论证法 有 copypasta/common.go:338
1400 CF437C 交换论证法 排序不等式 有 copypasta/common.go:401
1400 CF437C 排序不等式 有 copypasta/common.go:426
1400 CF489C 分类讨论（部分题是易错题） 有 copypasta/common.go:742
1400 CF492C 贪心（证明算法的正确性比算法难） copypasta/common.go:339
1400 CF550B 不定长滑动窗口：求子数组个数 变形：改成子数组 copypasta/common.go:194
1400 CF604B 贪心（证明算法的正确性比算法难） boats-to-save-people 有 copypasta/common.go:312
1400 CF710B 【思考题】插入一个数再选定一个 x，每次操作 +x/-x，计算最小操作次数 有 copypasta/common.go:419
1400 CF803A 构造 constructive algorithms 有 copypasta/common.go:619
1400 CF816B 差分数组 有 copypasta/common.go:2050
1400 CF920C 邻项交换法（最小代价排序/字典序最小） Exchange Arguments minimum-initial-energy-to-finish-tasks 有 copypasta/common.go:461
1400 CF934A 乘法贪心 有 copypasta/common.go:412
1400 CF934A 分类讨论（部分题是易错题） 有 copypasta/common.go:743
1400 CF1009B 思维：脑筋急转弯 有 copypasta/common.go:533
1400 CF1009B 分类讨论（部分题是易错题） 脑筋急转弯 有 copypasta/common.go:744
1400 CF1097C 合法括号字符串（Regular Bracket Sequence, RBS） 有 copypasta/common.go:913
1400 CF1102B 构造 constructive algorithms 有 copypasta/common.go:620
1400 CF1251B 分类讨论（部分题是易错题） 有 copypasta/common.go:745
1400 CF1292A 分类讨论（部分题是易错题） 也有简单写法 有 copypasta/common.go:746
1400 CF1369C 贪心（证明算法的正确性比算法难） 有 copypasta/common.go:340
1400 CF1380C 内层循环负责遍历组，找出这一组最远在哪结束。 有 copypasta/common.go:283
1400 CF1443C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:349
1400 CF1579D 或者说，每次删除两个不同元素，最多能删多少次？ 有 copypasta/common.go:440
1400 CF1605C 分类讨论（部分题是易错题） 有 copypasta/common.go:747
1400 CF1628A 内层循环负责遍历组，找出这一组最远在哪结束。 注：这题被力扣抄去当周赛题了 https://leetcode.cn/problems/lexicographically-maximum-mex-array/ lexicographically-maximum-mex-array 有 copypasta/common.go:284
1400 CF1648A 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:844
1400 CF1691C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:350
1400 CF1691C 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:845
1400 CF1706C 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:134
1400 CF1735C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 字典序最小 copypasta/common.go:351
1400 CF1837D 合法括号字符串（Regular Bracket Sequence, RBS） 有 copypasta/common.go:914
1400 CF1838C 构造 constructive algorithms 有 copypasta/common.go:621
1400 CF1844D 构造 constructive algorithms copypasta/common.go:622
1400 CF1863D 构造 constructive algorithms 棋盘+多米诺染色 copypasta/common.go:623
1400 CF1883F 思维：脑筋急转弯 有 copypasta/common.go:534
1400 CF1895C 任意下标 i 和 j 有 copypasta/common.go:76
1400 CF1895C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:352
1400 CF1896C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:353
1400 CF1896C 构造 constructive algorithms 有 copypasta/common.go:624
1400 CF1904C 思维：脑筋急转弯 有 copypasta/common.go:535
1400 CF1914E2 贪心（证明算法的正确性比算法难） shortest-impossible-sequence-of-rolls
stone-game-vi		 有 copypasta/common.go:319
1400 CF1923C 前缀和 构造 有 copypasta/common.go:1425
1400 CF1932C 离线 有 copypasta/common.go:986
1400 CF1955D 定长滑动窗口 有 copypasta/common.go:161
1400 CF1974C 枚举右，维护左 有 copypasta/common.go:58
1400 CF1974D 构造 constructive algorithms 有 copypasta/common.go:625
1400 CF1980D 部分题目也可以用状态机 DP 解决 pairwise 的前后缀分解 有 copypasta/common.go:135
1400 CF1983C 方向 有 copypasta/common.go:1142
1400 CF1989C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:354
1400 CF1989C 分类讨论（部分题是易错题） 有 copypasta/common.go:748
1400 CF2000E 排序不等式 有 copypasta/common.go:427
1400 CF2000E 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:846
1400 CF2014D 定长滑动窗口 有些另类，也可以用差分做 有 copypasta/common.go:162
1400 CF2014D 差分数组 也可以用定长滑窗做 有 copypasta/common.go:2051
1400 CF2032C 单序列双指针 count-the-number-of-incremovable-subarrays-ii 有 copypasta/common.go:223
1400 CF2034C 思维：脑筋急转弯 有 copypasta/common.go:536
1400 CF2034C 构造 constructive algorithms 网格图 有 copypasta/common.go:626
1400 CF2035C 构造 constructive algorithms 排列 &|&|&|… 结果最大 有 copypasta/common.go:627
1400 CF2098B 【思考题】插入一个数再选定一个 x，每次操作 +x/-x，计算最小操作次数 有 copypasta/common.go:420
1400 CF2110C 分类讨论（部分题是易错题） 有 copypasta/common.go:749
1400 CF2120C 构造 constructive algorithms copypasta/common.go:628
1400 CF2126E 构造 constructive algorithms 前后缀 GCD copypasta/common.go:629
1400 CF2131E 思维：脑筋急转弯 有 copypasta/common.go:537
1400 CF2152C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 copypasta/common.go:355
1400 CF2171C2 不变量（想一想，操作不会改变什么） 有 copypasta/common.go:713
1500 CF115B 分类讨论（部分题是易错题） 有 copypasta/common.go:751
1500 CF159D 枚举右，维护左 回文子串 有 copypasta/common.go:59
1500 CF166C 【思考题】插入一个数再选定一个 x，每次操作 +x/-x，计算最小操作次数 中位数相关 *可以做到对不同的 x 用 O(log n) 时间回答 有 copypasta/common.go:421
1500 CF224B 不定长滑动窗口：求最短/最小 和最小 有 copypasta/common.go:182
1500 CF276C 排序不等式 有 copypasta/common.go:428
1500 CF276C 差分数组 有 copypasta/common.go:2052
1500 CF608B 定长滑动窗口 有 copypasta/common.go:163
1500 CF611C 二维前缀和 range-sum-query-2d-immutable 有 copypasta/common.go:1645
1500 CF620C 内层循环负责遍历组，找出这一组最远在哪结束。 lexicographically-maximum-mex-array 有 copypasta/common.go:285
1500 CF701C 不定长滑动窗口：求最短/最小 有 copypasta/common.go:183
1500 CF846A 部分题目也可以用状态机 DP 解决 trapping-rain-water
flip-string-to-monotone-increasing		 有 copypasta/common.go:125
1500 CF858C 内层循环负责遍历组，找出这一组最远在哪结束。 lexicographically-maximum-mex-array 有 copypasta/common.go:286
1500 CF864D 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:356
1500 CF873B 枚举右，维护左 copypasta/common.go:60
1500 CF960B 分类讨论（部分题是易错题） 有 copypasta/common.go:752
1500 CF985C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:357
1500 CF990C 合法括号字符串（Regular Bracket Sequence, RBS） 有 copypasta/common.go:915
1500 CF1012A 思维：脑筋急转弯 有 copypasta/common.go:538
1500 CF1051C 分类讨论（部分题是易错题） 有 copypasta/common.go:753
1500 CF1141C 前缀和 有 copypasta/common.go:1426
1500 CF1166C 单序列双指针 count-the-number-of-incremovable-subarrays-ii 有 copypasta/common.go:224
1500 CF1169B 思维：脑筋急转弯 有 copypasta/common.go:539
1500 CF1180B 分类讨论（部分题是易错题） 有 copypasta/common.go:754
1500 CF1250L 分类讨论（部分题是易错题） copypasta/common.go:755
1500 CF1492C 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:136
1500 CF1630A 构造 constructive algorithms copypasta/common.go:630
1500 CF1659C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:358
1500 CF1690E 贪心（证明算法的正确性比算法难） boats-to-save-people 有 copypasta/common.go:313
1500 CF1710A 构造 constructive algorithms copypasta/common.go:631
1500 CF1722G 构造 constructive algorithms copypasta/common.go:632
1500 CF1753A2 内层循环负责遍历组，找出这一组最远在哪结束。 lexicographically-maximum-mex-array 有 copypasta/common.go:287
1500 CF1753A2 思维：观察、结论 有 copypasta/common.go:498
1500 CF1759E 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:359
1500 CF1765K 思维：观察、结论 有 copypasta/common.go:499
1500 CF1789C 更多贡献法题目，见 monotone_stack.go 好题！ 有 copypasta/common.go:847
1500 CF1792C 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 有 copypasta/common.go:991
1500 CF1809C 构造 constructive algorithms 有 copypasta/common.go:633
1500 CF1857E 反向贡献法 有 copypasta/common.go:879
1500 CF1873G 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 copypasta/common.go:360
1500 CF1924A 贪心（证明算法的正确性比算法难） 输出方案 boats-to-save-people
shortest-impossible-sequence-of-rolls		 有 copypasta/common.go:317
1500 CF1924A 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:361
1500 CF1990C 思维：观察、结论 有 copypasta/common.go:500
1500 CF1996D 暴力枚举 maximize-number-of-subsequences-in-a-string 有 copypasta/common.go:40
1500 CF2008E 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:137
1500 CF2057C 构造 constructive algorithms XOR 可以做到 O(1) 有 copypasta/common.go:634
1500 CF2072E 构造 constructive algorithms 有 copypasta/common.go:635
1500 CF2075C 相向双指针 同向双指针 a[i] + a[j] <= target 有 copypasta/common.go:230
1500 CF2077A 构造 constructive algorithms copypasta/common.go:636
1500 CF2093E 内层循环负责遍历组，找出这一组最远在哪结束。 lexicographically-maximum-mex-array 有 copypasta/common.go:288
1500 CF2106D 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:138
1500 CF2107C 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:139
1500 CF2107C 构造 constructive algorithms 经典 DP 的构造版本 有 copypasta/common.go:637
1500 CF2121E 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:362
1500 CF2137E 分类讨论（部分题是易错题） 有 copypasta/common.go:756
1500 CF2140C 枚举右，维护左 有 copypasta/common.go:61
1500 CF2140C 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:140
1500 CF2140C 思维：脑筋急转弯 有 copypasta/common.go:540
1500 CF2146D1 构造 constructive algorithms 重排使得 sum(p[i] | q[i]) 最大 有 copypasta/common.go:638
1500 CF2149E 不定长滑动窗口：求子数组个数 恰好型 有 copypasta/common.go:195
1500 CF2163C 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:141
1500 CF2200E 分类讨论（部分题是易错题） 有 copypasta/common.go:757
1600 CF150B 分类讨论（部分题是易错题） 有 copypasta/common.go:758
1600 CF383A 更多贡献法题目，见 monotone_stack.go 好题 有 copypasta/common.go:848
1600 CF500C 思维：脑筋急转弯 有 copypasta/common.go:541
1600 CF525C 内层循环负责遍历组，找出这一组最远在哪结束。 lexicographically-maximum-mex-array 有 copypasta/common.go:289
1600 CF601A 思维：脑筋急转弯 有 copypasta/common.go:542
1600 CF712C 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 有 copypasta/common.go:994
1600 CF750C 分类讨论（部分题是易错题） *也有偏数学的做法 有 copypasta/common.go:759
1600 CF777C 横看成岭侧成峰 maximum-number-of-ones
minimum-number-of-increments-on-subarrays-to-form-a-target-array		 有 copypasta/common.go:973
1600 CF835C 二维前缀和 range-sum-query-2d-immutable 有 copypasta/common.go:1646
1600 CF877C 思维：观察、结论 有 copypasta/common.go:501
1600 CF898D 滑窗的同时维护数据 有 copypasta/common.go:201
1600 CF898E 分类讨论（部分题是易错题） copypasta/common.go:760
1600 CF913C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:363
1600 CF1029C 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:142
1600 CF1065C ！需要保证 a 是有序的 sum-of-mutated-array-closest-to-target 有 copypasta/common.go:1532
1600 CF1082C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:364
1600 CF1165E 排序不等式 有 copypasta/common.go:429
1600 CF1165E 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:849
1600 CF1687A 定长滑动窗口 有 copypasta/common.go:164
1600 CF1707A 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 倒序思维 有 copypasta/common.go:365
1600 CF1748C 内层循环负责遍历组，找出这一组最远在哪结束。 lexicographically-maximum-mex-array 有 copypasta/common.go:290
1600 CF1822E 或者说，每次删除两个不同元素，最多能删多少次？ maximum-number-of-weeks-for-which-you-can-work 有 copypasta/common.go:442
1600 CF1822E 分类讨论（部分题是易错题） 样例给的挺良心的 有 copypasta/common.go:761
1600 CF1856C 暴力枚举 maximize-number-of-subsequences-in-a-string 有 copypasta/common.go:41
1600 CF1861C 分类讨论（部分题是易错题） 好题！ 有 copypasta/common.go:762
1600 CF1968E 构造 constructive algorithms 有 copypasta/common.go:639
1600 CF1971F 多指针 有 copypasta/common.go:206
1600 CF1976C 分类讨论（部分题是易错题） copypasta/common.go:763
1600 CF1978D 分类讨论（部分题是易错题） copypasta/common.go:764
1600 CF1980E 思维：观察、结论 交换行列把矩阵 A 变成矩阵 B 有 copypasta/common.go:502
1600 CF1994C 不定长滑动窗口：求子数组个数 结合 DP 有 copypasta/common.go:196
1600 CF1996E 前缀和与哈希表 子数组中的和为 k 的子数组的个数之和 有 copypasta/common.go:85
1600 CF2028C 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:143
1600 CF2051E 常与树状数组、线段树、平衡树等数据结构结合 the-skyline-problem
rectangle-area-ii		 有 copypasta/common.go:2576
1600 CF2082B 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:366
1600 CF2084D 构造 constructive algorithms copypasta/common.go:640
1600 CF2085C 构造 constructive algorithms 构造 k，使得 (x+k) AND (y+k) = 0 有 copypasta/common.go:641
1600 CF2094F 构造 constructive algorithms 棋盘 k-染色 (i+j)%2 彩带染色法 有 copypasta/common.go:642
1600 CF2117E 分类讨论（部分题是易错题） 有 copypasta/common.go:765
1600 CF2128D 思维：观察、结论 copypasta/common.go:503
1600 CF2167F 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:850
1600 CF2171F 构造 constructive algorithms 给定排列 p，构造一棵树，满足每条边的 pos[小端] < pos[大端] 有 copypasta/common.go:643
1700 CF66D 构造 constructive algorithms 有 copypasta/common.go:644
1700 CF193A 分类讨论（部分题是易错题） 有 copypasta/common.go:766
1700 CF201A 构造 constructive algorithms copypasta/common.go:645
1700 CF295B 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 有 copypasta/common.go:995
1700 CF382C 分类讨论（部分题是易错题） 有 copypasta/common.go:767
1700 CF411C 分类讨论（部分题是易错题） copypasta/common.go:768
1700 CF466C 前缀和 有 copypasta/common.go:79
1700 CF584C 构造 constructive algorithms 分类讨论 有 copypasta/common.go:646
1700 CF621C 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 有 copypasta/common.go:996
1700 CF1000C 常与树状数组、线段树、平衡树等数据结构结合 经典题 the-skyline-problem
rectangle-area-ii		 有 copypasta/common.go:2577
1700 CF1157C2 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:367
1700 CF1301C 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 有 copypasta/common.go:997
1700 CF1332D 构造 constructive algorithms 给你一个错误代码，构造 hack 数据 有 copypasta/common.go:647
1700 CF1516C 分类讨论（部分题是易错题） 有 copypasta/common.go:769
1700 CF1608C 思维：观察、结论 有 copypasta/common.go:504
1700 CF1644D 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 有 copypasta/common.go:998
1700 CF1661C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 奇数天+1 偶数天 +2 有 copypasta/common.go:368
1700 CF1672D 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 有 copypasta/common.go:999
1700 CF1700C 横看成岭侧成峰 有 copypasta/common.go:957
1700 CF1700C 差分数组 有 copypasta/common.go:2053
1700 CF1715C 更多贡献法题目，见 monotone_stack.go 也可以用增量法 有 copypasta/common.go:851
1700 CF1715C 增量法 也可以用贡献法 count-unique-characters-of-all-substrings-of-a-given-string
subarrays-distinct-element-sum-of-squares-ii		 有 copypasta/common.go:888
1700 CF1731D 二维前缀和 range-sum-query-2d-immutable copypasta/common.go:1647
1700 CF1765D 贪心（证明算法的正确性比算法难） boats-to-save-people 有 copypasta/common.go:314
1700 CF1777C 不定长滑动窗口：求最短/最小 有 copypasta/common.go:184
1700 CF1799C 分类讨论（部分题是易错题） 有 copypasta/common.go:770
1700 CF1849D 内层循环负责遍历组，找出这一组最远在哪结束。 有 copypasta/common.go:291
1700 CF1879D 枚举右，维护左 子数组长度 有 copypasta/common.go:62
1700 CF1884C 差分数组 结论 有 copypasta/common.go:2054
1700 CF1884C 离散差分，传入闭区间列表 a，不要求有序 count-days-without-meetings 有 copypasta/common.go:2153
1700 CF1893B 构造 constructive algorithms 有 copypasta/common.go:648
1700 CF1930C 思维：观察、结论 有 copypasta/common.go:505
1700 CF1955E 差分数组 有 copypasta/common.go:2055
1700 CF1983D 思维：脑筋急转弯 操作多次：交换 a 中两个相距 d 的元素，b 中两个相距 d 的元素，使得 a = b 有 copypasta/common.go:543
1700 CF1995B2 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:369
1700 CF2009F 前缀和 有 copypasta/common.go:1427
1700 CF2031D 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:144
1700 CF2031D 内层循环负责遍历组，找出这一组最远在哪结束。 有 copypasta/common.go:292
1700 CF2045A 大量分类讨论 做到 O(n) 有 copypasta/common.go:816
1700 CF2065F 思维：脑筋急转弯 有 copypasta/common.go:544
1700 CF2065G 枚举右，维护左 质因子 分类讨论 有 copypasta/common.go:63
1700 CF2065G 大量分类讨论 有 copypasta/common.go:817
1700 CF2071C 构造 constructive algorithms 树 排列 有 copypasta/common.go:649
1700 CF2112D 思维：脑筋急转弯 树 边定向 有 copypasta/common.go:545
1700 CF2112D 构造 constructive algorithms 树 定向 有 copypasta/common.go:650
1700 CF2113C 思维：脑筋急转弯 Minecraft TNT 炸金矿 有 copypasta/common.go:546
1700 CF2113C 二维前缀和 Minecraft TNT 炸金矿 脑筋急转弯 range-sum-query-2d-immutable 有 copypasta/common.go:1648
1700 CF2124D 思维：观察、结论 copypasta/common.go:506
1800 CF69E 定长滑动窗口 有 copypasta/common.go:165
1800 CF142B 构造 constructive algorithms 棋盘放最多的马 copypasta/common.go:651
1800 CF252B 非邻项交换（最小代价排序/字典序最小） copypasta/common.go:471
1800 CF799C 背向双指针 也可以二分查找 有 copypasta/common.go:238
1800 CF846C 巧妙枚举 number-of-ways-where-square-of-number-is-equal-to-product-of-two-numbers
count-the-number-of-substrings-with-dominant-ones		 有 copypasta/common.go:305
1800 CF846F 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:852
1800 CF846F 增量法 一样的题目 也可以用贡献法 total-appeal-of-a-string 有 copypasta/common.go:883
1800 CF847C 构造 constructive algorithms copypasta/common.go:652
1800 CF847C 合法括号字符串（Regular Bracket Sequence, RBS） 构造 copypasta/common.go:916
1800 CF911D 思维：观察、结论 逆序对 有 copypasta/common.go:507
1800 CF911D 思维：脑筋急转弯 有 copypasta/common.go:547
1800 CF989C 构造 constructive algorithms 网格图 每种字符构成的联通块个数恰好等于 a,b,c,d 有 copypasta/common.go:653
1800 CF1005E1 前缀和与哈希表 subarray-sum-equals-k copypasta/common.go:87
1800 CF1016C 带权前缀和，权重是等差数列 有 copypasta/common.go:1591
1800 CF1107D 二维前缀和 range-sum-query-2d-immutable 有 copypasta/common.go:1649
1800 CF1156B 构造 constructive algorithms 相邻字母在字母表中不相邻 有 copypasta/common.go:654
1800 CF1267L 构造 constructive algorithms 有 copypasta/common.go:655
1800 CF1304D 构造 constructive algorithms 最短/最长 LIS 有 copypasta/common.go:656
1800 CF1420D 离散差分，传入闭区间列表 a，不要求有序 count-days-without-meetings 有 copypasta/common.go:2154
1800 CF1442A 思维：观察、结论 有 copypasta/common.go:508
1800 CF1442A 横看成岭侧成峰 有 copypasta/common.go:956
1800 CF1468J 分类讨论（部分题是易错题） MST 有 copypasta/common.go:772
1800 CF1554D 构造 constructive algorithms 有 copypasta/common.go:657
1800 CF1709C 合法括号字符串（Regular Bracket Sequence, RBS） 方案数 有 copypasta/common.go:917
1800 CF1768D 非邻项交换（最小代价排序/字典序最小） 有 copypasta/common.go:472
1800 CF1793D MEX 有 copypasta/common.go:563
1800 CF1833G 分类讨论（部分题是易错题） 样例给得挺良心的 copypasta/common.go:773
1800 CF1907F 非邻项交换（最小代价排序/字典序最小） shift+reverse 有 copypasta/common.go:473
1800 CF1954D 或者说，每次删除两个不同元素，最多能删多少次？ maximum-number-of-weeks-for-which-you-can-work 有 copypasta/common.go:443
1800 CF1955F 分类讨论（部分题是易错题） 有 copypasta/common.go:774
1800 CF1965B 构造 constructive algorithms 二进制分解 有 copypasta/common.go:658
1800 CF2035D 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:370
1800 CF2042C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:371
1800 CF2069D 分类讨论（部分题是易错题） 有 copypasta/common.go:798
1800 CF2117F 分类讨论（部分题是易错题） 有 copypasta/common.go:775
1800 CF2145D 构造 constructive algorithms 排列 子问题 有 copypasta/common.go:659
1800 CF2187B 分类讨论（部分题是易错题） 构造不相交的 p 和 q，使得 |p-x| + |q-y| 最小 有 copypasta/common.go:776
1800 CF2209D 或者说，每次删除两个不同元素，最多能删多少次？ maximum-number-of-weeks-for-which-you-can-work copypasta/common.go:444
1900 CF3B 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:372
1900 CF118C 构造 constructive algorithms 贪心 有 copypasta/common.go:660
1900 CF327D 构造 constructive algorithms copypasta/common.go:661
1900 CF388B 构造 constructive algorithms 两点间恰好 k 条最短路径 有 copypasta/common.go:662
1900 CF550D 构造 constructive algorithms 度数均为 k 且至少（恰好）有一条割边 copypasta/common.go:663
1900 CF558C 思维：观察、结论 有 copypasta/common.go:509
1900 CF708B 构造 constructive algorithms 分类讨论 有 copypasta/common.go:664
1900 CF796C 分类讨论（部分题是易错题） 有 copypasta/common.go:777
1900 CF796C 大量分类讨论 有 copypasta/common.go:818
1900 CF1095E 分类讨论（部分题是易错题） 有 copypasta/common.go:778
1900 CF1181C 巧妙枚举 number-of-ways-where-square-of-number-is-equal-to-product-of-two-numbers
count-the-number-of-substrings-with-dominant-ones		 有 copypasta/common.go:306
1900 CF1479B1 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:373
1900 CF1644E 思维：观察、结论 有 copypasta/common.go:510
1900 CF1647D 大量分类讨论 有 copypasta/common.go:819
1900 CF1659D 构造 constructive algorithms 有 copypasta/common.go:665
1900 CF1661D 金字塔式更新 +1 +2 +3 +4 +3 +2 +1 简化 有 copypasta/common.go:2099
1900 CF1707B 差分数组 复杂度分析 有 copypasta/common.go:2056
1900 CF1714F 分类讨论（部分题是易错题） 锻炼代码实现技巧的好题 有 copypasta/common.go:779
1900 CF1747D 思维：观察、结论 不变量 有 copypasta/common.go:511
1900 CF1747D 分类讨论（部分题是易错题） 结论 不变量 有 copypasta/common.go:780
1900 CF1759G 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 求字典序最小，通常可以从大往小思考 有 copypasta/common.go:1000
1900 CF1777D 更多贡献法题目，见 monotone_stack.go 树 有 copypasta/common.go:853
1900 CF1800F 枚举右，维护左 异或 有 copypasta/common.go:64
1900 CF1823D 构造 constructive algorithms copypasta/common.go:666
1900 CF1854A2 构造 constructive algorithms 分类讨论 有 copypasta/common.go:667
1900 CF1898D 大量分类讨论 绝对值交换 有 copypasta/common.go:820
1900 CF1914F 分类讨论（部分题是易错题） 有 copypasta/common.go:781
1900 CF1921F 带权前缀和，权重是等差数列 +分块 有 copypasta/common.go:1592
1900 CF1957D 枚举中间 前后缀分解 从高到低思考 有 copypasta/common.go:71
1900 CF1957D 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:145
1900 CF1969D 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:146
1900 CF1991D 思维：脑筋急转弯 图染色 x^y 是质数则有 x-y 边 有 copypasta/common.go:548
1900 CF1992F 划分型贪心 划分区间，每个区间无法选一些数，乘积恰好等于 x 有 copypasta/common.go:397
1900 CF2026D 带权前缀和，权重是等差数列 有 copypasta/common.go:1593
1900 CF2040D 构造 constructive algorithms 树 相邻点权绝对差是非质数 有 copypasta/common.go:668
1900 CF2093G 不定长滑动窗口：求最短/最小 有 copypasta/common.go:185
1900 CF2180C 构造 constructive algorithms 构造 XOR(a) = n 且 sum(a) 尽量大 有 copypasta/common.go:669
1900 CF2233D 分类讨论（部分题是易错题） 有简单做法，见我的代码 https://codeforces.com/problemset/submission/2233/385743570 有 copypasta/common.go:782
2000 CF109D 非邻项交换（最小代价排序/字典序最小） copypasta/common.go:474
2000 CF371E 定长滑动窗口 有 copypasta/common.go:166
2000 CF515D 构造 constructive algorithms copypasta/common.go:670
2000 CF555B 区间与点的最大匹配/覆盖问题 有 copypasta/common.go:480
2000 CF863E 区间与点的最大匹配/覆盖问题 有 copypasta/common.go:481
2000 CF1088D 分类讨论（部分题是易错题） 有 copypasta/common.go:783
2000 CF1426F 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:874
2000 CF1558C 构造 constructive algorithms 有 copypasta/common.go:671
2000 CF1638D 逆向思维 / 正难则反（不可行方案通常比可行方案好求） copypasta/common.go:1001
2000 CF1744F 思维：观察、结论 有 copypasta/common.go:512
2000 CF1763C 思维：脑筋急转弯 有 copypasta/common.go:549
2000 CF1763C 分类讨论（部分题是易错题） 有 copypasta/common.go:784
2000 CF1788D 更多贡献法题目，见 monotone_stack.go 好题！ 有 copypasta/common.go:854
2000 CF1804D 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:374
2000 CF1951D 思维：观察、结论 构造一个商店价格序列，贪心购买，花费至多 n 元恰好买 k 个物品 有 copypasta/common.go:513
2000 CF1951D 思维：脑筋急转弯 有 copypasta/common.go:550
2000 CF1951E 分类讨论（部分题是易错题） 把 s 划分成若干段，使得每一段都不是回文串 有 copypasta/common.go:785
2000 CF1978E 分类讨论（部分题是易错题） copypasta/common.go:786
2000 CF2051F 分类讨论（部分题是易错题） 有 copypasta/common.go:787
2000 CF2146D2 构造 constructive algorithms 重排使得 sum(p[i] | q[i]) 最大 有 copypasta/common.go:672
2000 CF2171E 构造 constructive algorithms 排列 相邻三数两两互质的情况 <= 6 有 copypasta/common.go:673
2100 CF356C 大量分类讨论 reverse-subarray-to-maximize-array-value 有 copypasta/common.go:822
2100 CF571A 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 有 copypasta/common.go:1002
2100 CF912D 更多贡献法题目，见 monotone_stack.go copypasta/common.go:855
2100 CF1029E 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 树 有 copypasta/common.go:375
2100 CF1167E 单序列双指针 count-the-number-of-incremovable-subarrays-ii 有 copypasta/common.go:222
2100 CF1278D 常与树状数组、线段树、平衡树等数据结构结合 线段相交统计（栈） the-skyline-problem
rectangle-area-ii		 有 copypasta/common.go:2578
2100 CF1365F 不变量（想一想，操作不会改变什么） 仍然对称 有 copypasta/common.go:714
2100 CF1367F1 逆向思维 / 正难则反（不可行方案通常比可行方案好求） copypasta/common.go:992
2100 CF1393D ◣ 等腰直角三角形区域和 / ▲ 金字塔区域和 / ⯁ 菱形区域和 / 风车区域和 count-fertile-pyramids-in-a-land 有 copypasta/common.go:1824
2100 CF1479B2 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 https://www.luogu.com.cn/blog/wsyhb/post-ti-xie-cf1479b1-painting-the-array-i 有 copypasta/common.go:376
2100 CF1626D 巧妙枚举 number-of-ways-where-square-of-number-is-equal-to-product-of-two-numbers
count-the-number-of-substrings-with-dominant-ones		 有 copypasta/common.go:307
2100 CF1710B 金字塔式更新 +1 +2 +3 +4 +3 +2 +1 copypasta/common.go:2101
2100 CF1775E 不变量（想一想，操作不会改变什么） 有点差分的味道，想想前缀和 有 copypasta/common.go:715
2100 CF1787E 构造 constructive algorithms 有 copypasta/common.go:674
2100 CF1808D 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:856
2100 CF1811F 分类讨论（部分题是易错题） 有 copypasta/common.go:788
2100 CF1821E 合法括号字符串（Regular Bracket Sequence, RBS） check-if-a-parentheses-string-can-be-valid 有 copypasta/common.go:919
2100 CF1919D 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 有 copypasta/common.go:1003
2100 CF2037F 差分数组 有 copypasta/common.go:2057
2100 CF2044H 二维前缀和 二维带权前缀和 有 copypasta/common.go:1650
2200 CF369E 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 有 copypasta/common.go:1004
2200 CF520E 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:857
2200 CF833B 增量法 结合线段树优化 DP total-appeal-of-a-string 有 copypasta/common.go:885
2200 CF1110E 横看成岭侧成峰 有 copypasta/common.go:955
2200 CF1208E 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:858
2200 CF1234F 不定长滑动窗口：求最长/最大 翻转至多一个任意子串后的无重复字符的最长子串 minimum-operations-to-reduce-x-to-zero 有 copypasta/common.go:176
2200 CF1789D 构造 constructive algorithms 推荐 位运算 把 X 变成 Y 不断靠近答案 有 copypasta/common.go:675
2200 CF1985H2 二维差分 stamping-the-grid 有 copypasta/common.go:2209
2200 CF2009G2 这里是定长滑窗，也支持不定长滑窗 有 copypasta/common.go:2796
2200 CF2101C 部分题目也可以用状态机 DP 解决 式子变形可知，只需知道前缀所选数的下标，和后缀所选数的下标 有 copypasta/common.go:147
2200 CF2101C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 式子变形 有 copypasta/common.go:377
2300 CF294E 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:859
2300 CF460D 大量分类讨论 reverse-subarray-to-maximize-array-value 有 copypasta/common.go:823
2300 CF610D 常与树状数组、线段树、平衡树等数据结构结合 统计水平方向的线段与垂直方向的线段的交点个数 the-skyline-problem
rectangle-area-ii		 有 copypasta/common.go:2579
2300 CF901C 前缀和 有 copypasta/common.go:1429
2300 CF1285E 常与树状数组、线段树、平衡树等数据结构结合 转换求解目标 the-skyline-problem
rectangle-area-ii		 有 copypasta/common.go:2580
2300 CF1379D 常与树状数组、线段树、平衡树等数据结构结合 rectangle-area-ii 有 copypasta/common.go:2581
2300 CF1550D 构造 constructive algorithms 组合数学 有 copypasta/common.go:676
2300 CF1610E 思维：观察、结论 有 copypasta/common.go:514
2300 CF1798E 分类讨论（部分题是易错题） 有 copypasta/common.go:789
2300 CF2063E 更多贡献法题目，见 monotone_stack.go copypasta/common.go:860
2400 CF209C 分类讨论（部分题是易错题） 有 copypasta/common.go:790
2400 CF220E 单序列双指针 同向双指针 前缀+后缀 逆序对 count-the-number-of-incremovable-subarrays-ii 有 copypasta/common.go:225
2400 CF416D 内层循环负责遍历组，找出这一组最远在哪结束。 推荐 有 copypasta/common.go:293
2400 CF416D 分类讨论（部分题是易错题） 推荐 有 copypasta/common.go:791
2400 CF679C 定长滑动窗口 有 copypasta/common.go:167
2400 CF749E 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:861
2400 CF798D 数学思维 有 copypasta/common.go:407
2400 CF853D 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:378
2400 CF908F 分类讨论（部分题是易错题） 红绿蓝连边，使得删除所有红或者所有蓝后，仍然连通 copypasta/common.go:792
2400 CF915F 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:862
2400 CF1028E 构造 constructive algorithms 推荐 找特殊位置 有 copypasta/common.go:677
2400 CF1098C 构造 constructive algorithms 树 copypasta/common.go:678
2400 CF1237E 思维：观察、结论 todo 回顾 有 copypasta/common.go:515
2400 CF1244G 构造 constructive algorithms 有 copypasta/common.go:679
2400 CF1333E 构造 constructive algorithms 棋盘周游，车传送次数小于皇后（提示：把问题规模缩小为 n=3） 有 copypasta/common.go:680
2400 CF1392F 思维：观察、结论 todo 回顾 有 copypasta/common.go:516
2400 CF1392F 物理模拟 山体滑坡 有 copypasta/common.go:899
2400 CF1428F 增量法 count-unique-characters-of-all-substrings-of-a-given-string
subarrays-distinct-element-sum-of-squares-ii		 有 copypasta/common.go:889
2400 CF1443E 思维：脑筋急转弯 唬人 有 copypasta/common.go:551
2400 CF1450F 或者说，每次删除两个不同元素，最多能删多少次？ maximum-number-of-weeks-for-which-you-can-work 有 copypasta/common.go:445
2400 CF1527D 大量分类讨论 reverse-subarray-to-maximize-array-value 有 copypasta/common.go:824
2400 CF1592E 枚举右，维护左 子数组 AND > 子数组 XOR 的最长子数组 有 copypasta/common.go:65
2400 CF1592E 前缀和与哈希表 子数组 AND > 子数组 XOR 的最长子数组 subarray-sum-equals-k 有 copypasta/common.go:88
2400 CF1592E 思维：观察、结论 子数组 AND > 子数组 XOR 的最长子数组 有 copypasta/common.go:517
2400 CF1594F 分类讨论（部分题是易错题） 有 copypasta/common.go:793
2400 CF1667C 构造 constructive algorithms 有 copypasta/common.go:681
2400 CF1736C2 分类讨论（部分题是易错题） 有 copypasta/common.go:794
2400 CF1761E 构造 constructive algorithms 有 copypasta/common.go:682
2400 CF1761E 分类讨论（部分题是易错题） 有 copypasta/common.go:795
2400 CF1830C 合法括号字符串（Regular Bracket Sequence, RBS） check-if-a-parentheses-string-can-be-valid 有 copypasta/common.go:920
2400 CF1832D2 分类讨论（部分题是易错题） 有 copypasta/common.go:796
2400 CF1837F 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:148
2400 CF1852C 差分数组 差分思想 有 copypasta/common.go:2058
2400 CF1887C 差分数组 差分思想 有 copypasta/common.go:2060
2400 CF1969E 划分型贪心 有 copypasta/common.go:398
2400 CF2005D 部分题目也可以用状态机 DP 解决 GCD logTrick 有 copypasta/common.go:149
2400 CF2096E 思维：观察、结论 通过操作 3 个连续位置，使逆序对为 0 有 copypasta/common.go:518
2400 CF2110F 思维：观察、结论 有 copypasta/common.go:519
2400 CF2111F 构造 constructive algorithms 有 copypasta/common.go:683
2400 CF2118E 构造 constructive algorithms 网格染色，每次染色切比雪夫最远已染色点会惩罚一次，要求每个点的惩罚次数 <= 3 有 copypasta/common.go:684
2500 CF23C 数学思维 有 copypasta/common.go:406
2500 CF297D 构造 constructive algorithms copypasta/common.go:685
2500 CF314D 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:150
2500 CF407C 差分数组 k 阶差分 有 copypasta/common.go:2061
2500 CF442C 无论如何，这样交换都不会使答案变小，因此前 k 大的数一定可以作为最大值。 有 copypasta/common.go:379
2500 CF501E 分类讨论（部分题是易错题） 有 copypasta/common.go:797
2500 CF613C 构造 constructive algorithms 构造环形字符串，使得断开后是回文串的断点位置尽量多（提示：旋转对称性，周期） 有 copypasta/common.go:686
2500 CF825G 思维：脑筋急转弯 树 有 copypasta/common.go:552
2500 CF835F 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:151
2500 CF884F 或者说，每次删除两个不同元素，最多能删多少次？ maximum-number-of-weeks-for-which-you-can-work 有 copypasta/common.go:446
2500 CF946G 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:152
2500 CF976D 构造 constructive algorithms copypasta/common.go:687
2500 CF989D 双序列双指针 黑盒装着两朵云，风吹着盒子移动 有 copypasta/common.go:242
2500 CF1030F 【思考题】插入一个数再选定一个 x，每次操作 +x/-x，计算最小操作次数 带权中位数 + 单点修改 + 区间查询 有 copypasta/common.go:422
2500 CF1301E 二维前缀和 扩展思考：如果是菱形怎么做 有 copypasta/common.go:1651
2500 CF1374E2 大量分类讨论 reverse-subarray-to-maximize-array-value 有 copypasta/common.go:825
2500 CF1375E 构造 constructive algorithms 交换所有逆序对完成排序 提示：借鉴冒泡排序 有 copypasta/common.go:688
2500 CF1407E 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 节点涂色 堵路 最大化最短路长度 有 copypasta/common.go:1005
2500 CF1418G 状态压缩前缀和（异或） 有 copypasta/common.go:110
2500 CF1474E 构造 constructive algorithms 有 copypasta/common.go:689
2500 CF1559D2 构造 constructive algorithms 有 copypasta/common.go:690
2500 CF1612G 排序不等式 有 copypasta/common.go:430
2500 CF1673E 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:863
2500 CF1677D 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 有 copypasta/common.go:1006
2500 CF1689E 构造 constructive algorithms 脑筋急转弯 有 copypasta/common.go:691
2500 CF1701E 部分题目也可以用状态机 DP 解决 DP / 也可以用状态机 DP，那样无需前后缀分解 有 copypasta/common.go:153
2500 CF2117H 前缀和 copypasta/common.go:80
2500 CF2140E2 更多贡献法题目，见 monotone_stack.go minmax 状压 DP x = sum_{i=1}^m [x >= i] 有 copypasta/common.go:864
2600 CF3D 合法括号字符串（Regular Bracket Sequence, RBS） 反悔贪心（反悔堆） check-if-a-parentheses-string-can-be-valid 有 copypasta/common.go:921
2600 CF10E 构造 constructive algorithms Greedy Change todo 有 copypasta/common.go:692
2600 CF599E 分类讨论（部分题是易错题） 有 copypasta/common.go:799
2600 CF622F 部分题目也可以用状态机 DP 解决 有 copypasta/common.go:154
2600 CF1016F 分类讨论（部分题是易错题） copypasta/common.go:800
2600 CF1227G 构造 constructive algorithms 证明是亮点 有 copypasta/common.go:693
2600 CF1380G 排序不等式 放 k 个宝箱怪 有 copypasta/common.go:431
2600 CF1446D1 前缀和与哈希表 转换 subarray-sum-equals-k 有 copypasta/common.go:89
2600 CF1592F1 EXTRA: 计算矩阵 a 的二维差分矩阵 d 有 copypasta/common.go:2237
2600 CF1835C 枚举右，维护左 四数异或为 0 有 copypasta/common.go:66
2600 CF2004F 思维：观察、结论 有 copypasta/common.go:520
2600 CF2004F 更多贡献法题目，见 monotone_stack.go 有 copypasta/common.go:865
2700 CF339E 巧妙枚举 number-of-ways-where-square-of-number-is-equal-to-product-of-two-numbers
count-the-number-of-substrings-with-dominant-ones		 有 copypasta/common.go:308
2700 CF780G 物理模拟 小球下落 有 copypasta/common.go:900
2700 CF1422E 分类讨论（部分题是易错题） LCS 有 copypasta/common.go:801
2700 CF1521E 或者说，每次删除两个不同元素，最多能删多少次？ 二维+对角不同 maximum-number-of-weeks-for-which-you-can-work 有 copypasta/common.go:447
2700 CF1521E 构造 constructive algorithms 二维相邻不同 有 copypasta/common.go:694
2700 CF1601D 如果 x>=y<=z，那么删除 y 最优 有 copypasta/common.go:382
2700 CF1601D 交换论证法 有 copypasta/common.go:402
2700 CF1634F 差分数组 差分思想 有 copypasta/common.go:2062
2700 CF1730E 分类讨论（部分题是易错题） 有 copypasta/common.go:802
2800 CF79D 差分数组 差分思想 有 copypasta/common.go:2063
2900 CF505E 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 有 copypasta/common.go:1007
3000 CF1838F 构造 constructive algorithms 交互 二分 有 copypasta/common.go:695
CF163E 在特殊情况下，改为手动模拟栈可以减少 > 100MB 的内存 有 copypasta/common.go:1086
CF165C 多指针 copypasta/common.go:216
CF190D 多指针 计算有多少子数组，其中有至少 k 个相同的数 有 copypasta/common.go:215
CF243B a b 必须是有序的（可以为空） 有 copypasta/common.go:2306
CF246A 邻项交换法（最小代价排序/字典序最小） Exchange Arguments 900 minimum-initial-energy-to-finish-tasks 有 copypasta/common.go:459
CF266C 相邻 传递性 有 copypasta/common.go:1021
CF279B 多指针 入门题 copypasta/common.go:205
CF301D 这样可以将复杂度从 O(n^2) 降低到 O(n) 或 O(nlogn) 有 copypasta/common.go:941
CF351E 横看成岭侧成峰 maximum-number-of-ones
minimum-number-of-increments-on-subarrays-to-form-a-target-array		 有 copypasta/common.go:972
CF412D 相邻 传递性 有 copypasta/common.go:1020
CF448C 每次取数组中大于 0 的连续一段同时减 1，求使数组全为 0 的最少操作次数 minimum-number-of-increments-on-subarrays-to-form-a-target-array 有 copypasta/common.go:451
CF486D 异类双变量：固定某变量统计另一变量的 [0,n) 有 copypasta/common.go:932
CF521D 其他 copypasta/common.go:904
CF587C 合并有序数组，保留至多 k 个元素 有 copypasta/common.go:1312
CF602B 多指针 入门题 有 copypasta/common.go:204
CF702B 枚举右，维护左 two-sum 有 copypasta/common.go:46
CF707D 和莫队类似，通过改变查询的顺序来优化复杂度 有 copypasta/common.go:1045
CF763B 奇偶性 有 copypasta/common.go:1010
CF895B 多指针 copypasta/common.go:213
CF977C 算法的平均比较次数为 ~2n+2kln(n/k)+2(n-k)ln(n/(n-k)) kth-largest-element-in-an-array
k-closest-points-to-origin		 有 copypasta/common.go:2538
CF1009E 横看成岭侧成峰 有 copypasta/common.go:961
CF1045G 如果不要求下标连续，也可以不去重 有 copypasta/common.go:2419
CF1101B 字符串基础 有 copypasta/common.go:34
CF1141E EXTRA: 青蛙跳井 有 copypasta/common.go:1544
CF1151E 横看成岭侧成峰 有 copypasta/common.go:963
CF1188C 「恰好」转换成「至少/至多」 有 copypasta/common.go:1028
CF1194E 这样可以将复杂度从 O(n^2) 降低到 O(n) 或 O(nlogn) 有 copypasta/common.go:938
CF1208B 多指针 有 copypasta/common.go:211
CF1209E2 复杂度为 O(1+2+4+…+2^(n-1)) = O(2^n) 有 copypasta/common.go:1341
CF1254B2 双变量+下取整：枚举分母，然后枚举分子的范围，使得在该范围内的分子/分母是一个定值 https://ac.nowcoder.com/acm/contest/7612/C sum-of-floored-pairs 有 copypasta/common.go:949
CF1270E 奇偶性 有 copypasta/common.go:1011
CF1284C 横看成岭侧成峰 copypasta/common.go:965
CF1296C 状态压缩前缀和（异或） find-longest-subarray-lcci 有 copypasta/common.go:115
CF1311F 利用每个数产生的贡献计算 ∑|ai-aj|, i!=j 有 copypasta/common.go:2039
CF1332E 奇偶性 配对法：将合法局面与非法局面配对 有 copypasta/common.go:1012
CF1365C 横看成岭侧成峰 有 copypasta/common.go:954
CF1367F2 横看成岭侧成峰 maximum-number-of-ones
minimum-number-of-increments-on-subarrays-to-form-a-target-array		 有 copypasta/common.go:970
CF1381B 横看成岭侧成峰 有 copypasta/common.go:966
CF1394B 集合哈希 有 copypasta/common.go:1040
CF1430D 其他 有 copypasta/common.go:903
CF1483D 这样可以将复杂度从 O(n^2) 降低到 O(n) 或 O(nlogn) copypasta/common.go:939
CF1490G EXTRA: 青蛙跳井 有 copypasta/common.go:1545
CF1510K 见微知著：考察单个点的规律，从而推出全局规律 copypasta/common.go:1024
CF1517C 相邻 传递性 有 copypasta/common.go:1019
CF1582E 相邻 传递性 有 copypasta/common.go:1016
CF1665E 合并有序数组，保留至多 k 个元素 有 copypasta/common.go:1313
CF1695C 连续性 + 上下界 有 copypasta/common.go:929
CF1706D2 双变量+下取整：枚举分母，然后枚举分子的范围，使得在该范围内的分子/分母是一个定值 sum-of-floored-pairs 有 copypasta/common.go:946
CF1748C 前缀和与有序集合 count-odd-numbers-in-an-interval-range 有 copypasta/common.go:103
CF1765D 多指针 有 copypasta/common.go:212
CF1779D 横看成岭侧成峰 改成修改长为 x 的数组？ copypasta/common.go:958
CF1830A 横看成岭侧成峰 maximum-number-of-ones
minimum-number-of-increments-on-subarrays-to-form-a-target-array		 有 copypasta/common.go:971
CF1830B 这样可以将复杂度从 O(n^2) 降低到 O(n) 或 O(nlogn) 有 copypasta/common.go:942
CF1833F 多指针 copypasta/common.go:214
CF1848A 横看成岭侧成峰 minimum-time-to-visit-a-cell-in-a-grid copypasta/common.go:976
CF1864D 原理见上面的 rhombusSum 也有更简单的做法 有 copypasta/common.go:2265
CF1882B 逆向思维 / 正难则反（不可行方案通常比可行方案好求） 有 copypasta/common.go:993
CF1927B 枚举右，维护左 900 number-of-good-pairs
sum-of-digit-differences-of-all-pairs		 copypasta/common.go:49
CF1927B 构造 constructive algorithms 900 copypasta/common.go:582
CF1977C 枚举答案 有 copypasta/common.go:579
CF2044H 带权前缀和，权重是等差数列 有 copypasta/common.go:1594
CF2049A 思维：脑筋急转弯 800 copypasta/common.go:525
CF2093D 分治思维 有 copypasta/common.go:979
CF104821M 部分题目也可以用状态机 DP 解决 trapping-rain-water copypasta/common.go:120
CF105139L 分类讨论（部分题是易错题） copypasta/common.go:803

交互题

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
1300 CF1807E ## 二分 数组 copypasta/interactive.go:14
1400 CF679A ## 数论 判断质数 有 copypasta/interactive.go:93
1400 CF727C ## 数组/字符串 思维 构造 有 copypasta/interactive.go:46
1400 CF1167B ## 基础 有 copypasta/interactive.go:9
1400 CF2013C ## 数组/字符串 思维 构造 有 copypasta/interactive.go:47
1500 CF1999G1 ## 二分 有 copypasta/interactive.go:15
1500 CF2001C ## 树 二分 有 copypasta/interactive.go:77
1600 CF1407C ## 数组/字符串 思维 构造 有 copypasta/interactive.go:48
1600 CF1698D ## 二分 有 copypasta/interactive.go:16
1600 CF2037E ## 数组/字符串 思维 构造 有 copypasta/interactive.go:49
1600 CF2074E ## 随机 copypasta/interactive.go:65
1700 CF1146C ## 树 二分 直径 有 copypasta/interactive.go:78
1700 CF1479A ## 二分 数组（同 LC162） 有 copypasta/interactive.go:17
1700 CF1503B ## 其他 构造、棋盘染色 有 copypasta/interactive.go:99
1700 CF1934C ## 数组/字符串 思维 构造 网格图 有 copypasta/interactive.go:50
1700 CF1999G2 ## 二分 三分 有 copypasta/interactive.go:18
1800 CF730B ## 数组/字符串 思维 构造 C++ std::minmax 源码 有 copypasta/interactive.go:51
1800 CF1010B ## 二分 有 copypasta/interactive.go:19
1800 CF1534D ## 树 奇偶 有 copypasta/interactive.go:79
1800 CF1556D ## 位运算 有 copypasta/interactive.go:34
1800 CF1729E ## 随机 进阶问题：保证 q(a,b) = q(b,a) 有 copypasta/interactive.go:66
1800 CF1780D ## 位运算 有 copypasta/interactive.go:35
1900 CF1044B ## 树 copypasta/interactive.go:80
1900 CF1063C ## 二分 有 copypasta/interactive.go:21
1900 CF1207E ## 位运算 脑筋急转弯 有 copypasta/interactive.go:36
1900 CF1305D ## 树 LCA 排除法 拓扑排序 有 copypasta/interactive.go:81
1900 CF1486C2 ## 二分 数组 有 copypasta/interactive.go:22
1900 CF1697D ## 二分 有 copypasta/interactive.go:23
1900 CF2038G ## 数组/字符串 思维 构造 有 copypasta/interactive.go:52
2000 CF843B ## 随机 数组 链表 有 copypasta/interactive.go:67
2000 CF896B ## 数组/字符串 思维 构造 有 copypasta/interactive.go:53
2000 CF1088D ## 位运算 有 copypasta/interactive.go:37
2000 CF1103B ## 二分 倍增 + 二分 有 copypasta/interactive.go:24
2000 CF1521C ## 数组/字符串 思维 构造 copypasta/interactive.go:54
2000 CF1624F ## 二分 动态二分 有 copypasta/interactive.go:25
2000 CF1634D ## 数组/字符串 思维 构造 有 copypasta/interactive.go:55
2000 CF1815B ## 图 copypasta/interactive.go:87
2100 CF1023E ## 数组/字符串 思维 构造 网格图 有 copypasta/interactive.go:56
2100 CF1363D ## 二分 有 copypasta/interactive.go:26
2200 CF713B ## 二分 分类讨论 有 copypasta/interactive.go:27
2200 CF1114E ## 随机 数论 有 copypasta/interactive.go:68
2200 CF1155E ## 数论 拉格朗日插值 有 copypasta/interactive.go:94
2200 CF1498E ## 图 竞赛图 SCC 有 copypasta/interactive.go:88
2200 CF1520F2 ## 二分 copypasta/interactive.go:28
2200 CF1918E ## 其他 快排 copypasta/interactive.go:100
2300 CF1451E2 ## 位运算 copypasta/interactive.go:38
2300 CF1534E ## 位运算 有 copypasta/interactive.go:39
2400 CF835E ## 位运算 有 copypasta/interactive.go:40
2400 CF1137D ## 其他 快慢指针 有 copypasta/interactive.go:101
2400 CF1174F ## 树 有 copypasta/interactive.go:82
2400 CF1205C ## 数组/字符串 思维 构造 网格图 有 copypasta/interactive.go:57
2400 CF1617D2 ## 数组/字符串 思维 构造 copypasta/interactive.go:58
2400 CF1839E ## DP 有 copypasta/interactive.go:73
2400 CF1934D2 ## 位运算 有 copypasta/interactive.go:41
2500 CF1470C ## 其他 打表找规律 linked-list-cycle-ii 有 copypasta/interactive.go:103
2500 CF1840G2 ## 随机 有 copypasta/interactive.go:69
2500 CF2163D2 ## 二分 copypasta/interactive.go:29
2600 CF1355F ## 数论 有 copypasta/interactive.go:95
2600 CF2109C3 ## 数组/字符串 思维 构造 数学 加减乘除数位和 从 X 到 Y 有 copypasta/interactive.go:59
2700 CF1370F2 ## 树 copypasta/interactive.go:83
2700 CF1514E ## 图 竞赛图 SCC 有 copypasta/interactive.go:89
2800 CF1365G ## 位运算 有 copypasta/interactive.go:42
2800 CF1826F ## 其他 数学 linked-list-cycle-ii 有 copypasta/interactive.go:104
3000 CF1838F ## 二分 有 copypasta/interactive.go:30
CF2168B ## 二分 ~1800 通信题 有 copypasta/interactive.go:20

测试与随机化

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
1900 CF1689D 随机 https://www.luogu.com.cn/blog/wangxiwen/solution-cf1689d 有 copypasta/rand.go:13
2000 CF843B 交互 有 copypasta/rand.go:38
2200 CF1114E 交互 有 copypasta/rand.go:39
2200 CF1996G 异或哈希 xor hashing 有 copypasta/rand.go:30
2300 CF995C 随机 有 copypasta/rand.go:14
2300 CF1314D 随机 推荐 有 copypasta/rand.go:15
2400 CF869E 多项式哈希 加法哈希 有 copypasta/rand.go:35
2400 CF1523D 随机 有 copypasta/rand.go:16
2400 CF1830C 异或哈希 xor hashing 有 copypasta/rand.go:31
2500 CF1305F 随机 数论 有 copypasta/rand.go:17
2500 CF1771F 异或哈希 xor hashing 主席树 有 copypasta/rand.go:32
2700 CF995E 随机 有 copypasta/rand.go:18
2800 CF1746F 随机映射 copypasta/rand.go:27
2900 CF364D 随机 copypasta/rand.go:19
2900 CF1198F 随机 有 copypasta/rand.go:20

杂项

难度 题目 专题 备注 相关 LeetCode 源码 索引来源
1400 CF1974D 有思路但是不好实现 有 copypasta/awesome_code_reviews.go:4
1500 CF1066B 注：对于复杂变形题，采用分组循环不易写错 这题其实不算，但如果每个加热器的 r 不同，就是跳跃游戏 II 了 minimum-number-of-taps-to-open-to-water-a-garden
minimum-number-of-taps-to-open-to-water-a-garden		 有 copypasta/misc.go:1217
1500 CF1101C 合并 a 中所有重叠的闭区间 merge-intervals 有 copypasta/misc.go:1239
1500 CF1181B 高精度 copypasta/big.go:15
1600 CF1781C 有思路但是不好实现 有 copypasta/awesome_code_reviews.go:5
1600 CF1861C 有思路但是不好实现 有 copypasta/awesome_code_reviews.go:6
1600 CF2132D 例如 k=1 就是小数点后第 1 位，即 1 前 k 项和 copypasta/misc.go:928
1657 CF243E 占坑待填 https://blog.aor.sd.cn/archives// copypasta/pq_tree.go:8
1700 CF983A b must not be zero fraction-to-recurring-decimal copypasta/misc.go:591
1700 CF1626C 合并 a 中所有重叠的闭区间 merge-intervals 有 copypasta/misc.go:1240
1800 CF1859D 合并 a 中所有重叠的闭区间 merge-intervals 有 copypasta/misc.go:1242
1900 CF1260D 合并 a 中所有重叠的闭区间 merge-intervals 有 copypasta/misc.go:1243
2000 CF1244C 高精度 有 copypasta/big.go:16
2200 CF1630C 注：对于复杂变形题，采用分组循环不易写错 变形 minimum-number-of-taps-to-open-to-water-a-garden
minimum-number-of-taps-to-open-to-water-a-garden		 有 copypasta/misc.go:1216
CF11B 原地哈希 find-all-duplicates-in-an-array 有 copypasta/misc.go:34
CF375B 如果输入按照行来读入更方便的话…… 有 copypasta/io.go:276
CF547A 1<=next[i]<=n 有 copypasta/misc.go:98
CF663A 小结论：把 n 用 m 等分，得到 m-n%m 个 n/m 和 n%m 个 n/m+1 有 copypasta/misc.go:133
CF691B 编程技巧 有 copypasta/awesome_code_reviews.go:11
CF700A 小奥 copypasta/misc.go:21
CF825B 五子棋 copypasta/misc.go:71
CF960B 不能把 a[i] 改成负数 有 copypasta/misc.go:1001
CF1034B 原地哈希 有 copypasta/misc.go:53
CF1137D Floyd 判圈算法 有 copypasta/misc.go:116
CF1203F1 括号拼接 有 copypasta/misc.go:202
CF1278B 原地哈希 有 copypasta/misc.go:35
CF1381B max record pos 有 copypasta/misc.go:120
CF1419E dfs(0, 0, 0, 0) gray-code
minimum-one-bit-operations-to-make-integers-zero		 有 copypasta/misc.go:480
CF1483B 在 a 上不断循环合并直至没有可以合并的相邻元素，返回删除的元素 有 copypasta/misc.go:342
CF1511E 原地哈希 copypasta/misc.go:56
CF1552I 占坑待填 copypasta/pq_tree.go:10
CF1904E top tree copypasta/top_tree.go:11
CF1907C 从特殊到一般 有 copypasta/cp.go:14
CF101341A 括号拼接 有 copypasta/misc.go:200
CF101955K 思路：用递推公式，自底向上计算 yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-lcof
find-the-winner-of-the-circular-game		 copypasta/misc.go:832

代码随想录算法路线补充

来源：代码随想录算法学习路线。该站点可直接访问；本节按其算法类型整理文章链接，未提供统一难度，因此保留路线顺序。

  • 补充算法类型：14
  • 补充文章链接：297
类型 链接数
算法基础 8
数组 10
链表 9
哈希表 11
字符串 9
双指针法 2
栈与队列 10
二叉树 35
回溯算法 22
贪心算法 25
动态规划 55
单调栈 6
图论 33
学习体系补充文章 62

代码随想录-算法基础

序号 文章 关键词/模型
1 算法基础学习路线 代码随想录
2 刷了这么多题，你了解自己代码的内存消耗么？ 内存管理；栈区；堆区；内存对齐
3 递归算法的时间与空间复杂度分析！ 递归算法；斐波那契数列；二分法
4 通过一道面试题目，讲一讲递归算法的时间复杂度！ 递归算法；时间复杂度；二叉树
5 空间复杂度分析 空间复杂度；内存空间；递归
6 On的算法居然超时了，此时的n究竟是多大？ 时间复杂度；超时分析
7 究竟什么时候用库函数，什么时候要自己实现 库函数；内部实现原理；时间复杂度
8 关于时间复杂度，你不知道的都在这里！ 时间复杂度；大O表示法；数据规模

代码随想录-数组

序号 文章 关键词/模型
1 27. 移除元素 双指针法；原地覆盖
2 209.长度最小的子数组 滑动窗口；连续子数组
3 59.螺旋矩阵II 螺旋矩阵；模拟；循环不变量
4 数组学习路线 代码随想录
5 44. 开发商购买土地 前缀和；矩阵划分
6 数组理论基础 数组；连续内存空间；下标索引
7 数组总结篇 二分法；双指针法；滑动窗口
8 58. 区间和 前缀和；区间查询
9 704. 二分查找 二分查找；有序数组；循环不变量
10 977.有序数组的平方 双指针；有序数组；平方排序

代码随想录-链表

序号 文章 关键词/模型
1 19.删除链表的倒数第N个节点 双指针；虚拟头节点
2 206.反转链表 双指针法；递归法；指针反转
3 双指针技巧：链表相交问题（力扣 160 链表相交）
4 203.移除链表元素 链表；虚拟头节点
5 链表学习路线 代码随想录
6 关于链表，你该了解这些！ 链表；指针；节点
7 707.设计链表 虚拟头节点；双链表
8 链表总结篇 虚拟头结点；双指针法；反转链表
9 142.环形链表II 快慢指针；环入口查找

代码随想录-哈希表

序号 文章 关键词/模型
1 第15题. 三数之和 双指针；哈希法；去重
2 第202题. 快乐数 哈希法；集合；无限循环检测
3 383. 赎金信 哈希法；数组
4 第454题.四数相加II 哈希表；map；统计查找
5 第18题. 四数之和 双指针法；剪枝去重
6 242.有效的字母异位词 哈希表；数组；字符统计
7 哈希表理论基础 哈希表；哈希函数；哈希碰撞
8 哈希表总结篇 哈希表；哈希函数；哈希碰撞
9 哈希表学习路线 代码随想录
10 1. 两数之和｜哈希表 Map 解法｜O(n)时间复杂度｜数组查找算法核心技巧
11 349. 两个数组的交集 哈希表；集合

代码随想录-字符串

序号 文章 关键词/模型
1 344.反转字符串 双指针；原地修改
2 28. 实现 strStr() KMP；前缀表；字符串匹配
3 541. 反转字符串II 字符串反转；分段处理
4 459.重复的子字符串 KMP算法；重复子串；最长相同前后缀
5 151.翻转字符串里的单词 双指针；字符串反转；单词翻转
6 字符串：总结篇 双指针法；KMP；前缀表
7 字符串学习路线 代码随想录
8 替换数字 双指针；字符串替换；数组填充
9 右旋字符串 整体反转；局部反转

代码随想录-双指针法

序号 文章 关键词/模型
1 双指针法学习路线 代码随想录
2 双指针总结篇 双指针法；快慢指针

代码随想录-栈与队列

序号 文章 关键词/模型
1 150. 逆波兰表达式求值 栈；后缀表达式
2 225. 用队列实现栈 队列；栈；模拟
3 20. 有效的括号 栈；括号匹配；对称匹配
4 232.用栈实现队列 栈；队列；模拟
5 347.前 K 个高频元素 哈希表；小顶堆；优先级队列
6 单调队列模板题：滑动窗口最大值（力扣239）
7 栈与队列总结篇 栈与队列；单调队列；优先级队列
8 栈与队列学习路线 代码随想录
9 栈与队列理论基础 栈；队列；容器适配器
10 1047. 删除字符串中的所有相邻重复项 栈；相邻重复项；匹配问题

代码随想录-二叉树

序号 文章 关键词/模型
1 98.验证二叉搜索树 中序遍历；递归；二叉搜索树
2 递归后序遍历：对称二叉树判断（力扣101 对称二叉树）
3 104.二叉树的最大深度 递归法；层序遍历
4 106.从中序与后序遍历序列构造二叉树 中序遍历；后序遍历；递归
5 二叉树层序遍历登场！ 层序遍历；广度优先遍历；队列
6 108.将有序数组转换为二叉搜索树 二叉搜索树；高度平衡；递归迭代
7 110.平衡二叉树 后序遍历；高度差；递归
8 112. 路径总和 深度优先遍历；回溯
9 222.完全二叉树的节点个数 完全二叉树；递归；深度比较
10 226.翻转二叉树 翻转二叉树；遍历交换
11 235. 二叉搜索树的最近公共祖先 二叉搜索树；最近公共祖先；有序性
12 111.二叉树的最小深度 二叉树；最小深度；遍历
13 236. 二叉树的最近公共祖先 二叉树；后序遍历；回溯
14 递归回溯：二叉树路径问题（力扣257 二叉树的所有路径）
15 450.删除二叉搜索树中的节点 二叉搜索树；删除节点；结构调整
16 501.二叉搜索树中的众数 二叉搜索树；中序遍历；双指针
17 513.找树左下角的值 递归回溯；层序遍历
18 538.把二叉搜索树转换为累加树 二叉搜索树；累加树；反中序遍历
19 530.二叉搜索树的最小绝对差 二叉搜索树；中序遍历；有序数组
20 654.最大二叉树 最大二叉树；递归
21 617.合并二叉树 递归；迭代；二叉树
22 404.左叶子之和 二叉树；左叶子；递归迭代
23 669. 修剪二叉搜索树 修剪二叉搜索树；递归；迭代
24 700.二叉搜索树中的搜索 二叉搜索树；递归；迭代
25 二叉树学习路线 代码随想录
26 二叉树：总结篇！（需要掌握的二叉树技能都在这里了） 递归；迭代；深度优先遍历
27 701.二叉搜索树中的插入操作 二叉搜索树；插入操作；递归迭代
28 二叉树的递归遍历 递归；二叉树遍历
29 二叉树的统一迭代法 统一迭代法；栈；二叉树遍历
30 二叉树的迭代遍历 迭代法；栈；二叉树遍历
31 本周小结！（二叉树系列三）
32 本周小结！（二叉树系列二）
33 二叉树理论基础篇 二叉树；遍历；存储方式
34 本周小结！（二叉树系列四）
35 本周小结！（二叉树）

代码随想录-回溯算法

序号 文章 关键词/模型
1 17.电话号码的字母组合 回溯算法；数字映射；字符集
2 46.全排列 回溯算法；used数组
3 39. 组合总和 回溯；剪枝
4 37. 解数独 回溯法；二维递归
5 40.组合总和II 回溯；树层去重；组合总和
6 51. N皇后 回溯；N皇后；剪枝
7 47.全排列 II 回溯；去重；全排列
8 78.子集 回溯算法；子集
9 77.组合优化 回溯搜索法；剪枝优化
10 131.分割回文串 回溯算法；回文子串；动态规划
11 回溯分割字符串：IP地址生成问题（力扣93 复原IP地址）
12 回溯算法学习路线 代码随想录
13 90.子集II 回溯算法；树层去重
14 216.组合总和III 回溯算法；剪枝
15 第77题. 组合 回溯法；组合问题；剪枝
16 回溯算法去重问题的另一种写法 回溯算法；set 去重；本层去重
17 491.递增子序列 回溯；树层去重；递增子序列
18 回溯算法理论基础 回溯算法；递归；剪枝
19 回溯总结篇 回溯算法；树形结构；剪枝
20 本周小结！（回溯算法系列三）
21 本周小结！（回溯算法系列一）
22 本周小结！（回溯算法系列二）

代码随想录-贪心算法

序号 文章 关键词/模型
1 53. 最大子序和 贪心算法；动态规划；连续子数组
2 55. 跳跃游戏 贪心算法；覆盖范围
3 56. 合并区间 合并区间；排序；重叠区间
4 45.跳跃游戏 II 贪心算法；覆盖范围
5 122.买卖股票的最佳时机 II 贪心算法；动态规划；状态转移
6 135. 分发糖果 贪心；两次遍历
7 406.根据身高重建队列 贪心；排序；插入
8 435. 无重叠区间 贪心算法；区间排序；重叠区间
9 452. 用最少数量的箭引爆气球 贪心；排序；重叠区间
10 455.分发饼干 贪心算法；排序；分配
11 134. 加油站 贪心算法；剩余油量累加和
12 376. 摆动序列 贪心算法；动态规划；峰值统计
13 738.单调递增的数字 贪心算法；从后向前遍历；字符串调整
14 860.柠檬水找零 贪心算法；零钱维护
15 763.划分字母区间 贪心算法；最远边界
16 1005.K次取反后最大化的数组和 贪心算法；绝对值排序；取反操作
17 关于贪心算法，你该了解这些！ 贪心算法；局部最优；全局最优
18 968.监控二叉树 贪心算法；后序遍历；状态转移
19 贪心算法：根据身高重建队列（续集） 贪心算法；vector；链表
20 本周小结！（贪心算法系列二）
21 贪心算法学习路线 代码随想录
22 本周小结！（贪心算法系列四）
23 本周小结！（贪心算法系列三）
24 本周小结！（贪心算法系列一）
25 贪心算法总结篇 贪心算法；区间问题；股票问题

代码随想录-动态规划

序号 文章 关键词/模型
1 63. 不同路径 II 动态规划；dp 数组；障碍物处理
2 70. 爬楼梯（进阶版） 完全背包；排列问题
3 70. 爬楼梯 动态规划；状态转移
4 62.不同路径 动态规划；状态转移；滚动数组
5 115.不同的子序列 动态规划；子序列；dp数组
6 53. 最大子序和 动态规划；状态转移公式；dp数组
7 96.不同的二叉搜索树 动态规划；二叉搜索树；递推公式
8 188.买卖股票的最佳时机IV 动态规划；状态转移；dp数组
9 123.买卖股票的最佳时机III 动态规划；状态转移
10 198.打家劫舍 动态规划；状态转移
11 213.打家劫舍II 动态规划；状态转移
12 72. 编辑距离 动态规划；状态转移；编辑距离
13 121. 买卖股票的最佳时机 动态规划；贪心；状态转移
14 139.单词拆分 动态规划；完全背包；状态转移
15 300.最长递增子序列 动态规划；状态转移方程；子序列
16 279.完全平方数 动态规划；完全背包
17 309.最佳买卖股票时机含冷冻期 动态规划；状态转移；冷冻期
18 337.打家劫舍 III 树形动态规划；后序遍历；状态转移
19 322. 零钱兑换 动态规划；完全背包；状态转移
20 122.买卖股票的最佳时机II 动态规划；状态转移；滚动数组
21 392.判断子序列 动态规划；子序列；状态转移
22 377. 组合总和 Ⅳ 动态规划；完全背包；排列
23 474.一和零 动态规划；背包问题；二维背包
24 516.最长回文子序列 动态规划；回文子序列；状态转移
25 583. 两个字符串的删除操作 动态规划；最长公共子序列
26 509. 斐波那契数 动态规划；状态转移方程；递归
27 343. 整数拆分 动态规划；递推公式；dp数组
28 674. 最长连续递增序列 动态规划；贪心算法；连续递增子序列
29 714.买卖股票的最佳时机含手续费 动态规划；状态转移；手续费
30 494.目标和 背包问题；动态规划；组合总和
31 718. 最长重复子数组 动态规划；滚动数组；状态转移
32 518.零钱兑换II 完全背包；动态规划；组合数
33 647. 回文子串 动态规划；双指针法
34 746. 使用最小花费爬楼梯 动态规划；递推公式
35 416. 分割等和子集 01 背包；动态规划
36 1035.不相交的线 最长公共子序列；动态规划
37 动态规划学习路线 代码随想录
38 完全背包理论基础-二维DP数组 完全背包；二维DP数组；状态转移
39 动态规划之编辑距离总结篇 动态规划；状态转移；编辑距离
40 听说背包问题很难？ 这篇总结篇来拯救你了 动态规划；背包问题；递推公式
41 Leetcode股票问题总结篇! 动态规划；状态转移；贪心解法
42 动态规划理论基础 动态规划；状态推导；dp数组
43 1049.最后一块石头的重量II 01背包；动态规划；dp数组
44 动态规划：关于多重背包，你该了解这些！ 多重背包；动态规划；01背包
45 动态规划最强总结篇！ 动态规划；动规五部曲；背包问题
46 1143.最长公共子序列 动态规划；状态转移；dp数组
47 本周小结！（动态规划系列二）
48 本周小结！（动态规划系列五）
49 本周小结！（动态规划系列六）
50 动态规划：01背包理论基础 动态规划；01背包；二维dp数组
51 本周小结！（动态规划系列四）
52 本周小结！（动态规划系列一）
53 本周小结！（动态规划系列七）
54 本周小结！（动态规划系列三）
55 动态规划：01背包理论基础（滚动数组） 动态规划；滚动数组；01背包

代码随想录-单调栈

序号 文章 关键词/模型
1 496.下一个更大元素 I 单调栈；哈希表
2 单调栈学习路线 代码随想录
3 42. 接雨水 单调栈；双指针；凹槽计算
4 739. 每日温度 单调栈；递增栈；右边第一个更大元素
5 84.柱状图中最大的矩形 单调栈；柱状图最大矩形面积；左右两侧第一个小于该柱子的柱子
6 503.下一个更大元素II 单调栈；循环数组；成环搜索

代码随想录-图论

序号 文章 关键词/模型
1 图论学习路线 代码随想录
2 图论总结篇 深搜与广搜；并查集；最小生成树
3 广度优先搜索理论基础 广度优先搜索；最短路径；图论
4 深度优先搜索理论基础 深度优先搜索；回溯；递归
5 dijkstra（堆优化版）精讲 堆优化；邻接表；dijkstra
6 Bellmanford 队列优化算法（又名SPFA） Bellmanford 队列优化算法；SPFA；最短路径
7 dijkstra（朴素版）精讲 dijkstra；最短路径；朴素版
8 prim算法精讲 prim算法；最小生成树；贪心策略
9 图论理论基础 图论；有向图；无向图
10 bellman_ford之单源有限最短路 Bellman-Ford；松弛；负权回路
11 Floyd 算法精讲 Floyd 算法；多源最短路；动态规划
12 Bellmanford 算法精讲 Bellmanford；松弛；单源最短路
13 99. 岛屿数量 广度优先搜索；深度优先搜索；并查集
14 100. 岛屿的最大面积 深度优先搜索；广度优先搜索
15 98. 所有可达路径 深度优先搜索；有向无环图；邻接矩阵
16 kruskal算法精讲 Kruskal算法；并查集；最小生成树
17 101. 孤岛的总面积 深度优先搜索；广度优先搜索；矩阵遍历
18 99. 岛屿数量 深度优先搜索；矩阵遍历；连通分量
19 103. 水流问题 深度优先搜索；广度优先搜索；逆流遍历
20 102. 沉没孤岛 深搜优先搜索DFS；矩阵标记
21 bellmanford之判断负权回路 bellmanford；负权回路；SPFA
22 105.有向图的完全联通 有向图；深度优先搜索；广度优先搜索
23 107. 寻找存在的路径 并查集；无向图
24 106. 岛屿的周长 遍历；方向检查
25 108. 冗余连接 并查集；冗余连接
26 110. 字符串接龙 广度优先搜索；无权图
27 109. 冗余连接II 有向图；并查集；入度
28 104.建造最大岛屿 深度优先搜索；岛屿面积；矩阵
29 拓扑排序精讲 拓扑排序；有向无环图；广度优先搜索
30 A 算法精讲 （A star算法） A 算法；启发式函数；优先级队列
31 并查集理论基础 并查集；路径压缩；连通性问题
32 图论为什么统一使用ACM模式 ACM模式；邻接表；邻接矩阵
33 最短路算法总结篇 Dijkstra；Bellman_ford；Floyd

代码随想录-学习体系补充文章

序号 文章 关键词/模型
1 31.下一个排列 下一个排列；字典序；原地修改
2 35.搜索插入位置 二分法；排序数组；循环不变量
3 34. 在排序数组中查找元素的第一个和最后一个位置 二分查找；左右边界
4 52. N皇后II 回溯；剪枝
5 24. 两两交换链表中的节点 链表；虚拟头结点；节点交换
6 116. 填充每个节点的下一个右侧节点指针 递归；层序遍历
7 54.螺旋矩阵 螺旋矩阵；顺时针遍历；循环不变量
8 100. 相同的树 二叉树；递归；迭代法
9 129. 求根节点到叶节点数字之和 递归；回溯；二叉树
10 127. 单词接龙 广度优先搜索；无向图；最短路径
11 132. 分割回文串 II 动态规划；回文子串
12 160. 相交链表
13 189. 旋转数组 反转；原地算法
14 141. 环形链表 快慢指针法；链表环检测
15 130. 被围绕的区域 深度优先搜索；广度优先搜索；矩阵边界
16 200. 岛屿数量 广度优先搜索；DFS；BFS
17 5.最长回文子串 动态规划；双指针；Manacher 算法
18 205. 同构字符串 映射；哈希表
19 200. 岛屿数量 深度优先搜索；二维网格
20 拓扑排序（BFS）实现：有向无环图排序（力扣207 课程表）
21 拓扑排序模板题：课程表 II（力扣210）
22 143.重排链表 双指针法；快慢指针法；反转链表
23 649. Dota2 参议院 贪心；模拟；标志变量
24 283. 移动零：动态规划：一样的套路，再求一次完全平方数 双指针；数组
25 234.回文链表 快慢指针；反转链表
26 673.最长递增子序列的个数 动态规划；状态转移；计数数组
27 332.重新安排行程 回溯法；深度优先搜索；路径查找
28 463. 岛屿的周长 二维网格；遍历；边界检查
29 684.冗余连接 并查集；冗余连接
30 714. 买卖股票的最佳时机含手续费 动态规划；贪心算法
31 657. 机器人能否返回原点 坐标计数；移动顺序
32 417. 太平洋大西洋水流问题 深度优先搜索；广度优先搜索；逆流而上
33 724.寻找数组的中心下标 数组；总和；左右和
34 685.冗余连接II 有向图；并查集；入度
35 695. 岛屿的最大面积 DFS；BFS
36 797.所有可能的路径 深度优先搜索；回溯；有向无环图
37 743.网络延迟时间 Dijkstra 算法；堆优化；最短路径
38 827.最大人工岛 深度优先搜索；岛屿标记
39 787. K 站中转内最便宜的航班 SPFA；状态转移；邻接表
40 双指针奇偶交换：数组排序（力扣922 按奇偶排序数组II）
41 844.比较含退格的字符串 栈模拟；双指针
42 1002. 查找常用字符 哈希表；最小频率
43 1020. 飞地的数量 深度优先搜索；广度优先搜索
44 841.钥匙和房间 有向图；深度优先搜索；广度优先搜索
45 1207.独一无二的出现次数 哈希法；数组；频率统计
46 941.有效的山脉数组 双指针；递增递减序列
47 1254. 统计封闭岛屿的数目 深度优先搜索；二维矩阵
48 1356. 根据数字二进制下 1 的数目排序 位运算；自定义排序
49 1221. 分割平衡字符串 贪心；平衡字符串；遍历
50 Floyd算法模板题：找到阈值距离内邻居最少的城市（力扣1334）
51 1382.将二叉搜索树变平衡 二叉搜索树；中序遍历；有序数组
52 1971. 寻找图中是否存在路径 并查集；路径压缩
53 1365.有多少小于当前数字的数字 排序；哈希
54 代码随想录算法补充文章
55 完全背包-一维数组 完全背包；一维数组；动态规划
56 二叉树：以为使用了递归，其实还隐藏着回溯 递归；回溯
57 算法模板 二分查找法；KMP；二叉树遍历
58 925.长按键入
59 1791.找出星型图的中心节点 度；中心节点；星型图
60 右旋字符串 整体反转；局部反转
61 程序提交之后为什么会超时？O(n)的算法会超时，n究竟是多大？ 时间复杂度；性能测试；CPU 配置
62 替换数字 双指针；字符串替换