连通性问题

有向图 - 强连通

  • 当 \(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]\) 的和,有

\[\sum_{i=1}^n\sum_{j=1}^id_j=\sum_{j=1}^n(n-j+1)d_j=\sum_{j=1}^n(n+1)d_j+\sum_{j=1}^nj\cdot d_j \]

下面直接给出实现。具体搞不懂也没关系,不管了。

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\) 为质数时,有:

\[\binom nm\equiv \binom{\lfloor n/p\rfloor}{\lfloor m/p\rfloor}\binom{n\bmod p}{m\bmod p}\pmod 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