连通性问题
有向图 - 强连通
- 当 \(v\) 是 \(u\) 的树中孩子时,用
low[v]更新,否则用dfn[v]更新。 - 似乎不需要记录
from来防止漏算重边。
无向图 - 双连通
边双连通
桥 / 割边
- 根据定义,对于 \(u\leftrightarrow v\),若 \(v\) 不能通过其他途径回到 \(u\) 或更上方的点,则 \(u\leftrightarrow v\) 是一条割边。
- 形式化地说,就是当
low[v] > dfn[u]时,这条边是割边。 - 要用
from记录入边,防止漏算重边。
边双
- 和求解
scc的算法一模一样。只不过不需要判断横叉边了。
边双缩点
缩完之后会形成一棵树;树边即为桥。
待补。
点双连通
割点
- 根据定义,割点的子节点无法绕过割点回到它或更上方的点。
- 于是当
low[v] >= dfn[u]时,\(u\) 就是割点。注意与桥的判定区分。 - 注意:上述条件对于搜索的起始点不适用,还需判断在搜索树上它的子树个数是否 \(>1\)。若只有 \(1\),则显然它不是割点。
- 同样要用
from记录入边,养成好习惯。 - 特别注意:是搜索树上的子树个数,而非
G[u].size();要在循环内维护它的孩子数量cnt!
点双
-
虽然点双连通分量的定义存在争议,但只在两个点的图、桥、孤立点等特殊情况下。
-
两个点双之间至多有 \(1\) 个交点,且这个点一定是割点。
-
求解:当 \(u\) 是割点时(存在
low[v] >= dfn[u]),栈顶到 \(v\) 的点加上 \(u\) 形成了一个点双。 -
注意:需要特判孤立点的情形,其算作一个点双;
且需要避免输入自环。
-
同样需要用
from记录入边,养成好习惯。
点双缩点 & 圆方树
待补。
图论
欧拉路
有向图欧拉通路
- 当 \(u\) 的所有边都遍历完时,说明它已经成为了当前的终点,把它加入路径;最后再反转整条路径。
- 注意若存在通路但不存在回路时,一定要从路径的起点开始 dfs.
- 注意用当前弧优化,不然会跑得很慢。并且要在下一次 dfs 前就将
cur[u]++.
网络流
最大流代码
bool bfs(){
memset(lev, -1, sizeof(lev));
lev[s] = 0, q.push(s);
while(!q.empty()){
int u = q.front(); q.pop();
for(const auto& [v, rev, c] : G[u]){
if(c <= 0 || lev[v] != -1) continue;
lev[v] = lev[u] + 1;
q.push(v);
}
}
return lev[t] != -1;
}
ll dfs(int u, ll flow){
if(u == t) return flow;
for(int &i = cur[u]; i < G[u].size(); i++){
const auto& [v, rev, c] = G[u][i];
if(lev[v] != lev[u] + 1 || c <= 0) continue;
ll p = dfs(v, min(flow, c));
if(p > 0) return G[u][i].c -= p, G[v][rev].c += p, p;
}
return lev[u] = -1, 0;
}
ll Dinic(){
ll ret = 0;
while(bfs()){
memset(cur, 0, sizeof(cur));
while(1){
ll p = dfs(s, INF);
if(!p) break;
ret += p;
}
}
return ret;
}
dp
多重背包优化
先提一下二进制分组优化。将 \(c_i\) 个物品拆成若干个 \(2\) 的整数次幂的物品,若最后不足下个幂则单独分为一组。
显然这种方式可以组合出任意 \(\le c_i\) 的物品。时间复杂度 \(O(W\sum\log c_i)\).
然后是单调队列优化,优化源于一个观察。多重背包朴素转移为 \(f(i, j)\leftarrow\max\limits_{0\le k\le c_i} f(i - 1, j - kw_i)+kv_i\).
发现 \(f(i, j)\) 依赖于 \(f(i - 1, j - w_i), f(i - 1, j - 2w_i), \dots, f(i - 1, j - c_iw_i)\), 而 \(f(i, j - w_i)\) 由依赖于 \(f(i - 1, j - 2w_i)\) 等。
说明 \(j - kw_i\) 本质都是在同一堆东西里面转移。换言之,\(j\bmod w_i\) 所依赖的东西都是一样的。
于是想到对 \(j\bmod w_i\) 余数分组:设 \(g_r(i, p)\) 来表示 \(j=pw_i+r\) 的 dp 值,即 \(g_r(i, p) = f(i, pw_i + r)\).
那么原转移可以写为 \(g_r(i, p)\leftarrow\max\limits_{0\le k\le\min(c_i, p)} f(i - 1, pw_i + r - kw_i)+kv_i\).
你发现 \(w_i\) 的系数 \(p - k\) 中存在两个变量,于是希望用一个变量来表示它。设 \(t = p - k\),那么 \(k = p - t\).
则原转移变为 \(g_r(i, p)\leftarrow\max\limits_{0\le p - t\le\min(c_i, p)} f(i - 1, tw_i + r) + (p - t)v_i\).
再把 \(t\) 和 \(p\) 分开,得到 \(g_r(i, p)\leftarrow\max\limits_{\max(0, p - c_i)\le t\le p}\{f(i - 1, tw_i + r) - tv_i\} + pv_i\).
记 \(h_r(i, t) = f(i - 1, tw_i + r) - tv_i = g_r(i, t) - tv_i\),那么转移为 \(g_r(i, p) = \max\limits_{\max(0, p - c_i)\le j\le p} h_r(i - 1, j) + pv_i\).
发现随着 \(p\) 的增大 \(h_r(i - 1, j)\) 是一段滑动窗口,那么用滑窗优化即可。时间复杂度 \(O\left(nc\dfrac Wc\right) = O(nW)\).
代码
for(int i = 1; i <= n; i++)
for(int r = 0; r < w[i]; r++){
dq.clear();
for(int t = 0; t * w[i] + r <= W; t++){
while(!dq.empty() && dq.front() < t - c[i]) dq.popf();
while(!dq.empty() && f[i - 1][dq.back() * w[i] + r] - 1ll * dq.back() * v[i]
<= f[i - 1][t * w[i] + r] - 1ll * t * v[i]) dq.popb();
dq.pushb(t);
f[i][t * w[i] + r] = f[i - 1][dq.front() * w[i] + r] - 1ll * dq.front() * v[i] + 1ll * t * v[i];
}
}
数据结构
sgt
线段树 2 中加法、乘法混合的情况。
对于先 \(+\) 再 \(\times\) 和先 \(\times\) 再 \(+\) 肯定要至少处理一个。加乘混合容易想到乘法分配律,于是先 \(+\) 再 \(\times\) 就可以被解决了,只需要在出现 \(\times k\) 时也把 \(+\) 的 tag 同时乘 \(k\) 即可。于是所有乘法前面的加法都被处理了,剩下的就先乘法后加法。
对于值域很大的权值线段树最好用动态开点。否则离散化需要记录每一段的块长很难处理。
在矩形面积并中,需要维护区间加减后总共有多少个位置上有值。
解决方法是维护每个区间被完整覆盖的次数 \(cnt\). 当 \(cnt\ge 1\) 时有值位置 \(b_u\) 显然为 \(r-l+1\),否则令其为 \(b_{lc}+b_{rc}\).
bit
注意 bit 的上界 \(n\) 必须覆盖所有可能的查询 / 插入!!
介绍 bit 维护区间加区间求和的做法。简单来说需要多一个 bit 维护 \(j\cdot d_j\).
具体来说,bit 实质上在维护差分数组 \(d\). 其中 \(\sum_{j=1}^id_j=a_i\). 那么对于 \([1, n]\) 的和,有
下面直接给出实现。具体搞不懂也没关系,不管了。
struct bit{
// ask(int x), upd(int x, ll k)...
}tr1, tr2;
void upd(int l, int r, int k){
tr1.upd(l, k), tr1.upd(r + 1, -k);
tr2.upd(l, 1ll * l * k), tr2.upd(r + 1, -1ll * (r + 1) * k);
}
ll ask(int x){ return 1ll * (n + 1) * tr1.ask(x) - tr2.ask(x); }
ll query(int l, int r){ return ask(r) - ask(l - 1);
需要注意在离散化时对于 \(r+1,l-1\) 这些位置也要考虑跟着离散化?
数论相关
exgcd
void exgcd(int a, int b, int &x, int &y){
// work out ax + by = 1
if(!b) return x = 1, y = 0, void();
exgcd(b, a % b, y, x);
y -= a / b * x;
}
pair<int, int> compute(int a, int b, int c){
// work out (x, y) of ax + by = c
int k = __gcd(a, b), x, y;
if(c % k != 0) return make_pair(-inf, -inf);
a /= k, b /= k;
exgcd(a, b, x, y);
x *= c / k, y *= c / k; // (x, y) is one of the answers
if(a + b == 0) return {x, y}; // !!
int h = (x - y) / (a + b);
x -= b * h, y += a * h;
return {x, y};
}
注意:默认 \(a,b,c\) 非负(否则 exgcd 会出错),且 \(a, b\) 不同时为 \(0\)(否则 c % k 会让除数为 \(0\))。
其中 compute(a, b, c) 用于计算 \(ax+by=c\) 的整数解,这里返回的是 \(|x-y|\) 最小的一组解。
注意用 exgcd 得到特解 \(x_0, y_0\) 后,通解为 \(x=x_0+bt, y = y_0-at\),其中 \(\gcd(a,b)=1\). 特别地,若 \(a+b=0\) 则只有唯一解。
提一下差最小解的推导:令 \(x-y=(x_0-y_0)+t(a+b)=0\),解得 \(t=-\cfrac{x_0-y_0}{a+b}\)。所以代码中 h 实际上要带入 -h.
Lucas 定理
Lucas 定理可以在 \(O(p)\) 空间、\(O(\log_pn+p)\) 时间内求解出与 \(n\) 有关的组合数。适用于模数 \(p\) 不大但 \(n\) 很大,以及 \(n\) 有可能大于 \(p\) 的情形。
Lucas 定理求解组合数的核心原理是把大组合数分成若干个小组合数计算。
朴素的 Lucas 定理要求 \(p\) 为质数。exLucas 没有这个要求,但其本身与 Lucas 定理关系已经不大了。
定理内容
当 \(p\) 为质数时,有:
约定当 \(n<m\) 时,\(\binom nm=0\).
其中第一个组合数可以一直递归直到 \(n,m<p\);第二个组合数可以直接计算,或者提前预处理出来。
代码实现
ll fac[P + 5], ifac[P + 5];
ll C(int n, int m){ return n < m ? 0 : fac[n] * ifac[n - m] % P * ifac[m] % P; }
ll Lucas(ll n, ll m){ return !m ? 1 : C(n % P, m % P) * Lucas(n / P, m / P) % P; }
字符串
哈希
int get(int l, int r){ return (h[r] + P - h[l - 1] * pw[r - l + 1] % P) % P; }
for(int i = 1; i <= n; i++) h[i] = (h[i - 1] * B % P + s[i]) % P;
Trie
- 本质是按字符 / 二进制位逐层划分集合。关于 Trie 的应用:https://chat.deepseek.com/share/8537o1gxe9zp6emq74
- 在与字典序有关问题中可能用上。此外 01Trie 可以用来计算一个数在一堆数中的最大异或值。
- 对于
nxt[A][B],第一维大小为节点总数(串数 * 串长),第二大小为字符集大小。 - 其他相关数组大小大多为节点数,如
cnt.
KMP
- 用于计算单个模式串在文本串中的匹配问题。
- 首先分清模式串和文本串。一般而言,长度长的为文本串 \(S\), 短的为模式串 \(T\). 模式串会出现在文本串中。
- border 是模式串的最长公共前后缀。
Code
for(int i = 2; i <= m; i++){
int j = nxt[i - 1];
while(j && t[i] != t[j + 1]) j = nxt[j];
if(t[i] == t[j + 1]) j++;
nxt[i] = j;
}
- 考虑这里为什么是
j = nxt[j].
其中的 \(\pi\) 即为 nxt 数组。
ACAM
- 用于计算多个模式串在文本串中的匹配问题。
- 其真正强大之处在于自动机,即由
nxt和fail构建出来的有向图。可以运用其性质解决很多问题。 fail[u]是状态 \(u\) 的最长真后缀,使得它是某个模式串的前缀。采用ac::build通过 bfs 构建。nxt[u][j]是 \(u\) 字符串后加上 \(j\) 字符的最长真后缀,使得它是某个模式串的前缀。具体来说,它是状态 \(u\) 后走 \(j\) 边所达的状态,若不存在则沿着fail边向上跳直到 \(j\) 边存在,若都不存在则nxt指向根。- 注意:多测时 ACAM 中所有东西都必须清空!
- 以及时刻记得 ACAM 至少也要从 \(1\) 开始,不能将 \(p\) 设为 \(0\).
模版题代码 & 解析
namespace ac{
int nxt[N][26], m = 1, fail[N], rk[N], bfc, tot[N];
queue<int> q;
void ins(string s, int id){
int p = 1;
for(int i = 0; i < s.length(); i++){
int c = s[i] - 'a';
if(!nxt[p][c]) nxt[p][c] = ++m;
p = nxt[p][c];
}
Id[id] = p;
}
void build(){
for(int j = 0; j < 26; j++)
if(nxt[1][j]) fail[nxt[1][j]] = 1, q.push(nxt[1][j]);
else nxt[1][j] = 1;
while(!q.empty()){
int u = q.front(); q.pop();
rk[++bfc] = u;
for(int j = 0; j < 26; j++)
if(nxt[u][j]){
int v = nxt[u][j];
fail[v] = nxt[fail[u]][j];
q.push(v);
}else nxt[u][j] = nxt[fail[u]][j];
}
}
void query(string s){
int p = 1;
for(int i = 0; i < s.length(); i++){
int c = s[i] - 'a';
if(!nxt[p][c]) break;
p = nxt[p][c];
tot[p]++;
}
}
void solve(){
for(int i = bfc; i >= 1; i--){
int u = rk[i];
tot[fail[u]] += tot[u];
}
}
}
- 其中
ins与 Trie 中相同。 build即为构建自动机的函数,照着代码不难理解。- 模版题要求对于文本串 \(S\) 求出每个模式串 \(T\) 在其中的出现次数。对于所有模式串构建自动机,拿着 \(S\) 在自动机上跑一遍。
注意经过build的nxt全不为 \(0\),是完整的“字典图”。对于当前节点 \(p\),可以认为其代表 \(S\) 的一个前缀(失配前)。
每走到一处就记录状态 \(p\) 在 \(S\) 中出现过。 - 然后使用
solve来利用 bfs 序的倒序来计算 fail tree 上子树和。因为 \(u\) 在 \(S\) 中出现时 \(u\) 的后缀也同时出现了。(前缀的后缀) - tip: 使用
namespace的常数比struct小。在不需要复用时尽量使用namespace.
另一例
计算每个模式串在所有模式串中的出现次数。
void ins(string s, ...){
int p = 1;
for(int i = 0; i < s.length(); i++){
int c = s[i] - 'a';
if(!nxt[p][c]) nxt[p][c] = ++m;
p = nxt[p][c];
cnt[p]++; // here!
}
...
}
- 这里将
cnt的累加放到了循环内部,即在 \(s\) 每个前缀出现的位置都 \(+1\). - 这样在做完 fail tree 上子树和后,
cnt[u]就是串 \(u\) 作为后缀出现在了多少个前缀中。也就是它在模式串中的出现次数。
Manacher
- Manacher 算法通过维护每个位置的回文半径 \(R\) 和当前时刻右端点 \(r\) 最大的回文区间 \([l, r]\) 来高效计算最长回文串。
- 由回文性质,当正在处理的 \(i\) 在 \([l, r]\) 内时,几乎总可以令 `R[i] = R[l + r - i]$;否则 \(i\) 在区间外就为 \(1\).
- 但若 \(l + r - i\) 处的回文串边界超过了 \([l, r]\),其在 \(i\) 处就无法完全保证正确。于是
R[i] = min(R[l + r - i], r - i + 1)即可。 - 然后暴力扩展
R. 最后记得用R[i]来更新[l, r]. - 原串中回文串的真实长度为
R[i] - 1. - 注意:若采用
t[++n] = ..的方式构建新串,则应使用char数组而非string否则会 RE,且本地测不出来!!
代码
for(int i = 1, l = 1, r = 0; i <= n; i++){
if(i > r) R[i] = 1;
// here!!
else R[i] = min(R[l + r - i], r - i +1);
while(t[i - R[i]] == t[i + R[i]]) R[i]++;
if(i + R[i] - 1 > r) l = i - R[i] + 1, r = i + R[i] - 1;
// ans = max(ans, R[i] - 1); // 最长回文串
}
- 特别注意
l + r - i容易写成l + r - 1,且很难发现!
模版题
图论连通性
scc: https://www.luogu.com.cn/problem/P3387
桥:https://www.luogu.com.cn/problem/U582665
ecc: https://www.luogu.com.cn/problem/P8436
割点:https://www.luogu.com.cn/problem/P3388
bcc: https://www.luogu.com.cn/problem/P8435
字符串
Trie: https://www.luogu.com.cn/problem/P8306
KMP: https://www.luogu.com.cn/problem/P3375
ACAM: https://www.luogu.com.cn/problem/P5357
Manacher: https://www.luogu.com.cn/problem/P3805
浙公网安备 33010602011771号