OopsYanxi

EBCC（边双连通分量）

Sat, 18 Apr 2026 00:00:00 GMT

EBCC（边双连通分量）

1. 定义

边双连通分量（Edge Biconnected Component, e-BCC）是无向图中的一个极大子图，满足：

删掉子图内任意一条边后，这个子图仍然连通。
等价地说，子图内不存在桥。

常见等价结论：

两个点属于同一个 e-BCC，当且仅当它们之间存在至少两条边不相交路径。
把整张图里的所有桥删掉，剩下的每个连通块就是一个 e-BCC。

2. 这个模板能做什么

这份模板完成了 3 件事：

求无向图中的所有桥。
求所有边双连通分量。
把每个 e-BCC 缩成一个点，得到一棵树或森林。

复杂度：

时间复杂度：O(V + E)
空间复杂度：O(V + E)

3. 核心性质

3.1 桥的判定

设 dfn[u] 表示 u 被 DFS 首次访问的时间戳，low[u] 表示：

从 u 出发，
只走 DFS 树边向下，
最多经过一条返祖边，
能回到的最早祖先时间戳。

若 DFS 树边 u -> v 满足：

low[v] > dfn[u]

则这条边是桥。

含义是：v 这棵子树无论怎么绕，都回不到 u 或 u 的祖先，所以 u-v 一断，图就被分开了。

3.2 缩点后的图一定无环

把每个 e-BCC 缩成一个点后：

原图中的桥，变成新图中的边。
新图一定是一棵树或森林。

原因很直接：

如果缩点图里还有环，那么环上的边都不是桥。
这和“缩点图中的边全部来自原图桥”矛盾。

4. 为什么无向图找桥必须用边编号

这是这类题最容易写错的地方。

在无向图里，一条无向边会拆成两条方向相反的邻接记录。如果你只用“父节点编号”判断回边：

if (v == parent) continue;

那么遇到重边时会直接出错。

反例：两个点之间有两条边

1 == 2

如果从 1 走到 2 用的是第一条边，那么从 2 回看 1 时：

第一条边确实是“原路返回”，应该跳过。
第二条边其实是一条合法返祖边，必须参与更新 low。

但如果你写的是 if (v == parent) continue;，这两条边都会被跳过，结果会把本来不是桥的边误判成桥。

所以正确做法是：

给每条无向边一个唯一的 edge_id
DFS 时记录“进入当前点所使用的那条边编号”
只跳过这同一条边，而不是跳过父节点

模板里的关键写法：

if (id == in_edge_id) continue;

这是支持重边的标准写法。

5. 模板字段说明

5.1 边结构

struct Edge {
    int to;
    int id;
};

to：边的终点
id：无向边编号，同一条无向边的两个方向共用同一个 id

5.2 关键数组

graph[u]：邻接表
dfn[u]：DFS 访问序
low[u]：追溯值
stk：当前 DFS 栈中尚未归属分量的点
is_bridge[id]：第 id 条无向边是否为桥
edccs：每个 e-BCC 内包含哪些点
edcc_id[u]：点 u 属于哪个 e-BCC

6. 模板流程

6.1 建图

void addEdge(int u, int v) {
    graph[u].push_back({v, edge_counter});
    graph[v].push_back({u, edge_counter});
    is_bridge.push_back(0);
    edge_counter++;
}

无向边 (u, v) 会被拆成两条邻接边，但共享同一个 edge_id。

6.2 主过程

void build() {
    for (int i = 0; i < n; i++) {
        if (!dfn[i]) {
            tarjan(i, -1);
        }
    }
}

因为原图可能不连通，所以要从每个未访问点出发。

6.3 Tarjan 过程

核心逻辑：

dfn[u] = low[u] = ++timer
u 入栈
枚举所有邻边
遇到未访问点就递归
回溯时更新 low
若 low[v] > dfn[u]，则 u-v 是桥
若 dfn[u] == low[u]，说明当前形成一个 e-BCC

对应代码里的关键部分：

if (!dfn[v]) {
    tarjan(v, id);
    low[u] = std::min(low[u], low[v]);
    if (low[v] > dfn[u]) {
        is_bridge[id] = 1;
    }
} else {
    low[u] = std::min(low[u], dfn[v]);
}

注意这里返祖边更新必须是：

low[u] = min(low[u], dfn[v]);

不能写成 low[v]。这是 Tarjan 的标准写法。

7. 为什么 `dfn[u] == low[u]` 时可以弹出一个 e-BCC

在这份模板里，栈中存的是“点”。

当 dfn[u] == low[u] 时，说明：

从 u 往下这一整段 DFS 子树，
已经无法通过返祖边再连到 u 上方的点，
所以从栈顶到 u 的这些点恰好构成一个完整的边双连通分量。

代码：

if (dfn[u] == low[u]) {
    std::vector<int> current_edcc;
    int node;
    do {
        node = stk.back();
        stk.pop_back();
        current_edcc.push_back(node);
        edcc_id[node] = edccs.size();
    } while (node != u);
    edccs.push_back(current_edcc);
}

8. 缩点图怎么建

模板里的做法：

if (edcc_id[u] != edcc_id[v]) {
    tree[edcc_id[u]].push_back(edcc_id[v]);
}

含义：

若原图一条边的两个端点属于不同 e-BCC
说明它必然是一条桥
那么它就在缩点图中连接这两个分量

注意：

这里得到的是无向图邻接表，所以一条桥会在两个方向各记录一次。
如果你统计缩点图边数，通常要记得除以 2。

9. 使用方式

int n = 5;
EBCC solver(n);

solver.addEdge(0, 1);
solver.addEdge(1, 2);
solver.addEdge(2, 0);
solver.addEdge(1, 3);
solver.addEdge(3, 4);

solver.build();

// 1. 判断桥
for (int id = 0; id < solver.edge_counter; id++) {
    if (solver.is_bridge[id]) {
        // id 是桥
    }
}

// 2. 查看所有 e-BCC
for (auto &comp : solver.edccs) {
    // comp 是一个边双连通分量中的所有点
}

// 3. 查看点属于哪个 e-BCC
int cid = solver.edcc_id[3];

// 4. 建缩点图
auto tree = solver.buildShrunkenGraph();

10. 例子理解

10.1 图结构

0 - 1 - 3 - 4
 \ /
  2

其中：

0-1-2-0 构成一个环，不存在桥
1-3 是桥
3-4 是桥

因此 e-BCC 为：

{0, 1, 2}
{3}
{4}

缩点后得到一条链：

{0,1,2} - {3} - {4}

11. 常见坑

11.1 用父节点判回边

错误写法：

if (v == parent) continue;

这会在重边图上出错。

11.2 返祖边用 `low[v]` 更新

错误写法：

low[u] = min(low[u], low[v]);

返祖边必须用 dfn[v] 更新。

11.3 忘记处理非连通图

build() 必须从每个未访问点都启动一次 DFS。

11.4 把边双和点双混了

边双连通分量看的是“删边后是否断开”，核心对象是桥。
点双连通分量看的是“删点后是否断开”，核心对象是割点。

两者不是一个东西，模板也不同。

12. 适用题型

这份模板常用于：

求桥的数量、桥的列表
求每个点属于哪个边双连通分量
缩点后在树上做 DP
统计删去某条边后的连通性变化
处理“至少两条边不相交路径”的判定类问题

13. 记忆版总结

e-BCC = 删掉所有桥之后剩下的连通块
无向图找桥：low[v] > dfn[u]
重边防错：跳过的是 in_edge_id，不是父节点
缩点之后得到树 / 森林
这份模板一次 DFS 同时求桥、e-BCC、缩点映射

虚树（Virtual Tree / Auxiliary Tree）

Sat, 18 Apr 2026 00:00:00 GMT

虚树（Virtual Tree / Auxiliary Tree）

1. 定义

虚树用于处理“树上多次查询，每次只关心少量关键点”的问题。

给定原树上的一组关键点 key_nodes，虚树会：

保留所有关键点
补上必要的 LCA
只保留这些点之间的祖先关系

最终得到一棵规模远小于原树的“浓缩树”。

它的意义是：

原来一次查询可能要扫整棵树，复杂度接近 O(N)
用虚树后，只需要在与关键点相关的极少数节点上做 DP / 统计

2. 适用场景

典型特征：

原图是一棵树
有很多组询问
每次询问只给出 K 个关键点
需要在这些关键点之间做路径、覆盖、DP、贡献统计

常见题型：

树上关键点最短连通子图
树上路径覆盖 / 染色 / 切断类 DP
一组点之间的距离和、边权贡献
每次只对少量特殊点做转移的树形 DP

3. 核心性质

3.1 虚树只保留“必要节点”

虚树中的点只包含两类：

原询问给出的关键点
为了保持树结构而补上的 LCA

因此虚树规模通常很小。

3.2 点数上界是 `2K - 1`

设去重后的关键点数量为 K，则虚树中的节点总数不超过：

2K - 1

原因：

每加入一个新的关键点，最多只会额外引入一个新的分叉 LCA
所以补点数量不会超过 K - 1

3.3 虚树保留祖先关系

虚树上的父子关系，就是原树中的祖先关系压缩后得到的关系。

因此：

可以直接在虚树上做树形 DP
如果需要边权或路径长度，可以用原树信息补回来

例如原树有 dist[u] 表示根到 u 的距离，那么虚树边 (fa, son) 的真实长度就是：

dist[son] - dist[fa]

4. 预处理前提

构建虚树前，原树必须先支持以下信息：

dfn[u]：DFS 序
depth[u]：节点深度
get_lca(u, v)：能快速查询 LCA

常见 LCA 实现：

倍增 LCA
Euler Tour + RMQ
树剖求 LCA

5. 这份模板做了什么

模板接口：

int build(std::vector<int> key_nodes,
          const std::vector<int>& dfn,
          const std::vector<int>& depth,
          const std::function<int(int, int)>& get_lca)

返回值：

返回虚树根节点编号

结果存储：

graph[u]：虚树中 u 向下连到哪些儿子
used_nodes：本次构建用到的所有节点，便于下次 O(K) 清空

注意这份实现的一个细节：

函数参数是 std::vector<int> key_nodes
这是按值传参
所以函数内部确实会排序、去重
但不会修改调用者手里的原数组

也就是说，代码行为比注释更安全。

6. 为什么按 DFN 排序

虚树构造的核心前提是：

std::sort(key_nodes.begin(), key_nodes.end(),
          [&](int u, int v) { return dfn[u] < dfn[v]; });

原因：

按 DFS 序排序后，关键点在原树上的出现顺序与“子树区间”一致
相邻关键点之间的 LCA 足以恢复整棵虚树结构
配合单调栈，可以只维护一条“当前右链”

这是整套做法成立的基础。

7. 单调栈在维护什么

栈中维护的是：

当前已经处理过的点
在虚树中尚未完成连边的那条祖先链

可以把它理解成：

栈底更高
栈顶更深
栈里节点的 dfn 单调递增
同时它们在原树上形成一条“右边界链”

每来一个新点 u：

求 lca = LCA(u, stk.back())
如果 lca 在栈顶上方，说明要把一些点先退栈并连边
必要时把 lca 作为新的分叉点插入栈
再把 u 入栈

8. 模板流程拆解

8.1 清空上一次查询的残留

for (int u : used_nodes) {
    graph[u].clear();
}
used_nodes.clear();

这是虚树模板里非常重要的优化。

不能每次都把整张 graph 全清空，因为：

原树有 N 个点
单次查询只会用到 O(K) 个点
全清空会退化成每次 O(N)

所以要靠 used_nodes 精准回收。

8.2 排序 + 去重

std::sort(key_nodes.begin(), key_nodes.end(),
          [&](int u, int v) { return dfn[u] < dfn[v]; });

key_nodes.erase(std::unique(key_nodes.begin(), key_nodes.end()), key_nodes.end());

作用：

保证构造顺序正确
防止输入中重复关键点导致虚树出现脏结构

8.3 初始化栈

std::vector<int> stk;
stk.push_back(key_nodes[0]);
used_nodes.push_back(key_nodes[0]);

第一个关键点先作为当前链的起点。

8.4 处理新关键点

核心代码：

int u = key_nodes[i];
int lca = get_lca(u, stk.back());

若 lca != stk.back()，说明当前点 u 不在栈顶节点的子树内部最深位置，需要调整结构。

情况 1：持续退栈

while (stk.size() > 1 && depth[stk[stk.size() - 2]] >= depth[lca]) {
    graph[stk[stk.size() - 2]].push_back(stk.back());
    stk.pop_back();
}

含义：

只要次栈顶仍然不低于 lca
栈顶节点就已经确定应该挂到次栈顶下面
可以直接连边并弹出

情况 2：补入 LCA 分叉点

if (depth[stk.back()] > depth[lca]) {
    graph[lca].push_back(stk.back());
    stk.pop_back();

    if (stk.empty() || stk.back() != lca) {
        stk.push_back(lca);
        used_nodes.push_back(lca);
    }
}

这一步表示：

栈顶节点仍然在 lca 下方
但更高层已经不属于它这一支了
所以 lca 必须显式出现，作为一个新分叉点

然后再把当前节点 u 入栈：

stk.push_back(u);
used_nodes.push_back(u);

8.5 收尾

while (stk.size() > 1) {
    graph[stk[stk.size() - 2]].push_back(stk.back());
    stk.pop_back();
}

最终栈中剩下的一条链，依次连起来即可。

最后：

return stk[0];

栈底就是虚树根。

9. 为什么这棵树是“有向树”

模板里建边方式是：

graph[parent].push_back(child);

也就是说方向固定为：

父节点指向子节点

这样做的好处是：

直接适配树形 DP
不需要再带父节点参数防止走回头路
单次查询构出的图天然就是一棵 rooted tree

10. 复杂度要说准确

这份模板常被口头写成 O(K log K)，但严格来说应分开看：

排序：O(K log K)
去重：O(K)
单调栈建树：O(K)
LCA 查询：一共 O(K) 次，每次代价取决于你的 LCA

因此总复杂度更准确地写成：

O(K log K + K * T_lca)

若：

LCA = O(1)，则整体是 O(K log K)
LCA = O(log N)，则整体是 O(K log K + K log N)

11. 使用方式

假设你已经对原树完成了 DFS 和 LCA 预处理：

int n = ...;
VirtualTree vt(n);

std::vector<int> key_nodes = {5, 9, 13, 20};

int root = vt.build(
    key_nodes,
    dfn,
    depth,
    [&](int u, int v) {
        return lca(u, v);
    }
);

// 在虚树上做 DP
std::function<void(int)> dfs = [&](int u) {
    for (int v : vt.graph[u]) {
        dfs(v);
    }
};

dfs(root);

如果题目需要知道“哪些点是原始关键点”，通常会额外维护：

is_key[u] = true / false

然后在虚树 DP 时区分：

原始关键点
补出来的 LCA 点

12. 例子理解

设原树中查询关键点是：

{4, 5, 8, 9}

它们在原树上的结构大致是：

        1
      /   \
     2     3
    / \   / \
   4   5 8   9

那么虚树中需要保留的点是：

{4, 5, 8, 9, 2, 3, 1}

虚树结构就是：

        1
      /   \
     2     3
    / \   / \
   4   5 8   9

如果一组关键点本来几乎都落在同一条链上，虚树会更小。

比如关键点是：

{10, 15, 18}

而这三个点祖先链很接近，那么虚树可能只包含少量补点。

13. 常见坑

13.1 没按 `dfn` 排序

不排序，整套单调栈逻辑都不成立。

13.2 忘记去重

重复关键点可能导致：

无意义重复入栈
虚树结构异常
DP 统计重复

13.3 每次查询都整图清空

错误做法会把单次复杂度拖回 O(N)。

虚树模板必须利用 used_nodes 做局部清空。

13.4 把虚树边当成原树边长为 `1`

虚树中的一条边，代表原树中的一整段祖先路径。

如果题目涉及距离、边权、路径贡献，必须用原树信息恢复真实代价。

13.5 忘记标记关键点和补点的区别

很多题的转移只对原始关键点生效。

LCA 补点只是结构点，不一定有题意贡献。

13.6 节点编号体系混乱

这份模板 graph.assign(max_nodes + 1, ...) 默认更偏向：

节点编号从 1 开始

如果你题里是 0 下标，也能用，但需要整套保持一致。

14. 记忆版总结

虚树 = 关键点 + 必要 LCA 的浓缩树
构造顺序：dfn 排序 -> 去重 -> 单调栈建树
栈维护的是当前未完成连边的祖先链
虚树规模最多 2K - 1
单次构造复杂度是 O(K log K + K * T_lca)
模板中的边是“父 -> 子”的有向边，适合直接做树形 DP

网络编程基本概念

Thu, 16 Apr 2026 00:00:00 GMT

网络通信和协议

网络通信 指的是不同设备之间通过网络交换数据的过程。
两台主机想要正确通信，必须遵循统一的规则，这些规则就叫做协议。

协议本质上约定了：数据如何封装、如何发送、如何接收、如何校验，以及出现错误后如何处理。

网络协议和OSI网络模型

网络协议 是一组通信规则，用来保证不同厂商、不同系统的设备能够互联互通。
为了更清晰地理解网络通信过程，人们把复杂的通信过程分层描述，典型代表就是 OSI 七层模型。

OSI 七层模型 自下而上分别是：

物理层：负责比特流传输，例如网线、电信号、光信号。
数据链路层：负责相邻节点之间的数据传输，例如 MAC 地址、帧。
网络层：负责路径选择与跨网络传输，例如 IP 协议。
传输层：负责端到端通信，例如 TCP、UDP。
会话层：负责建立、管理、终止会话。
表示层：负责数据格式转换、加密解密、压缩解压。
应用层：直接为用户程序提供服务，例如 HTTP、FTP、SMTP。

OSI 模型的意义 主要在于：

降低网络系统设计复杂度。
让每一层只关注自己的职责。
便于协议标准化与模块化开发。
出现故障时更容易定位问题。

TCP/IP模型

在实际互联网中，更常用的是 TCP/IP 模型。
它比 OSI 模型更贴近真实网络实现，通常分为四层或五层。

常见四层 TCP/IP 模型 包括：

网络接口层：对应 OSI 的物理层和数据链路层。
网络层：主要协议是 IP，负责寻址和路由。
传输层：主要协议是 TCP 和 UDP，负责进程之间的通信。
应用层：包含 HTTP、HTTPS、DNS、FTP 等协议。

数据在发送时会经历逐层封装：

应用层产生原始数据。
传输层添加 TCP 头或 UDP 头。
网络层添加 IP 头。
网络接口层再封装成帧并发送。

接收方则进行逐层拆包，还原出原始数据。

IP地址

IP 地址 用于唯一标识网络中的一台主机。
可以把它理解为设备在网络中的地址，没有 IP 地址，数据就不知道该发送到哪里。

IP 地址主要分为两类：

IPv4：由 32 位二进制组成，通常写成点分十进制形式，例如 192.168.1.10。
IPv6：由 128 位二进制组成，地址空间更大，例如 2001:db8::1。

按照使用范围，IP 地址还可以分为：

公网 IP：可在互联网中直接访问。
私网 IP：通常用于局域网内部，常见网段有 192.168.x.x、10.x.x.x、172.16.x.x 到 172.31.x.x。

在网络通信中，IP 地址负责找到目标主机，但只靠 IP 地址还不能确定具体是主机上的哪个程序在通信，因此还需要 端口号。

端口号

端口号 用于标识一台主机上的某个具体应用程序或服务。
IP 地址定位的是主机，端口号定位的是主机中的进程。

端口号范围 是 0 ~ 65535，通常分为：

知名端口：0 ~ 1023，例如 HTTP 默认端口 80，HTTPS 默认端口 443。
注册端口：1024 ~ 49151，常用于某些固定服务。
动态或私有端口：49152 ~ 65535，通常由客户端临时使用。

例如访问网站时，目标可能是：

服务器IP + 80端口

这表示把数据发送到某台服务器上的 Web 服务程序。

客户端和服务端

网络程序通常分为 客户端 和 服务端 两部分。

服务端：负责提供服务，通常长期运行并监听固定端口，等待客户端连接或请求。
客户端：负责发起请求，主动去连接服务端并获取结果。

以浏览器访问网页为例：

浏览器是客户端。
网站服务器是服务端。
浏览器向服务器发起请求。
服务器返回网页数据给浏览器。

在编程中，两者职责不同：

服务端 重点在于监听、接收连接、处理多个请求。
客户端 重点在于连接目标主机、发送请求、接收响应。

UDP和TCP

UDP 和 TCP 都是传输层协议，用于实现进程与进程之间的通信，但两者设计目标不同。

协议	主要特点
UDP	无连接、速度快、开销小，但不保证可靠性
TCP	面向连接、可靠、有序，但开销较大

简单理解：

UDP 更像“发消息”，发出去就结束，不确认对方是否收到。
TCP 更像“打电话”，先建立连接，再进行可靠通信。

UDP网络协议

UDP 全称是 User Datagram Protocol，即 用户数据报协议。
它在发送数据之前不需要建立连接，直接把数据打包后发出去，因此效率较高。

UDP 的通信特点是 面向数据报。发送方每发送一次，就是一个独立的数据包；接收方一次接收的也是一个完整数据报。

UDP编程步骤

UDP 编程的一般流程如下：

创建 Socket 对象，指定使用 UDP 协议。
如果是接收方，可以绑定本地 IP 和端口。
发送方直接调用发送接口，把数据发送到目标 IP 和端口。
接收方调用接收接口，获取数据报。
通信结束后关闭 Socket。

UDP 通信通常不需要先建立连接，因此实现简单，适合快速收发短消息。

UDP特点与优缺点

UDP 的特点：

无连接。
不保证数据一定到达。
不保证数据按顺序到达。
没有重传机制。
首部开销小，效率较高。

UDP 的优点：

传输速度快。
实现简单。
资源消耗较小。
适合实时性要求高的场景。

UDP 的缺点：

容易丢包。
数据可能乱序。
不能自动处理可靠传输问题。

UDP应用场景

UDP 常用于 对实时性要求高、对少量丢包可容忍的场景，例如：

语音通话。
视频直播。
在线游戏中的实时状态同步。
DNS 查询。
局域网广播和组播。

TCP网络协议

TCP 全称是 Transmission Control Protocol，即 传输控制协议。
它是一种 面向连接、可靠、有序、基于字节流 的传输协议。

在正式通信之前，TCP 需要先建立连接；通信结束后，还要断开连接。
为了保证可靠性，TCP 提供 确认应答、超时重传、流量控制、拥塞控制 等机制。

TCP编程步骤

TCP 编程的一般流程如下：

服务端步骤：

创建 ServerSocket 或监听 Socket 对象。
绑定本地 IP 和端口。
监听客户端连接。
接收到连接后，得到与客户端通信的 Socket 对象。
通过输入输出流或收发接口与客户端交换数据。
通信结束后关闭连接。

客户端步骤：

创建 Socket 对象。
主动连接服务端 IP 和端口。
连接成功后发送数据。
接收服务端返回的数据。
通信结束后关闭连接。

TCP特点与优缺点

TCP 的特点：

面向连接。
可靠传输。
按顺序到达。
基于字节流。
具有流量控制和拥塞控制机制。

TCP 的优点：

数据可靠，不易丢失。
能保证顺序。
适合传输重要业务数据。

TCP 的缺点：

建立连接和断开连接有额外开销。
传输速度通常比 UDP 慢。
协议实现更复杂。

TCP应用场景

TCP 适用于 对准确性、完整性要求高的场景，例如：

网页访问。
文件传输。
邮件发送。
数据库连接。
即时通信中的可靠消息传输。

Socket编程

Socket 可以理解为网络通信的“插座”或“接口”，应用程序通过它与传输层协议进行交互。
无论是 TCP 还是 UDP 编程，最终通常都要通过 Socket 来完成数据发送和接收。

Socket 编程的核心作用包括：

创建网络通信端点。
绑定本地地址和端口。
建立连接或直接发送数据。
接收远程主机发来的数据。
在通信结束后释放资源。

根据协议不同，Socket 编程可以分为两类：

UDP Socket：无连接，直接发送数据报。
TCP Socket：面向连接，需要先建立连接再通信。

OopsYanxi

EBCC（边双连通分量）

EBCC（边双连通分量）

1. 定义

2. 这个模板能做什么

3. 核心性质

3.1 桥的判定

3.2 缩点后的图一定无环

4. 为什么无向图找桥必须用边编号

反例：两个点之间有两条边

5. 模板字段说明

5.1 边结构

5.2 关键数组

6. 模板流程

6.1 建图

6.2 主过程

6.3 Tarjan 过程

7. 为什么 dfn[u] == low[u] 时可以弹出一个 e-BCC

8. 缩点图怎么建

9. 使用方式

10. 例子理解

10.1 图结构

11. 常见坑

11.1 用父节点判回边

11.2 返祖边用 low[v] 更新

11.3 忘记处理非连通图

11.4 把边双和点双混了

12. 适用题型

13. 记忆版总结

虚树（Virtual Tree / Auxiliary Tree）

虚树（Virtual Tree / Auxiliary Tree）

1. 定义

2. 适用场景

3. 核心性质

3.1 虚树只保留“必要节点”

3.2 点数上界是 2K - 1

3.3 虚树保留祖先关系

4. 预处理前提

5. 这份模板做了什么

6. 为什么按 DFN 排序

7. 单调栈在维护什么

8. 模板流程拆解

8.1 清空上一次查询的残留

8.2 排序 + 去重

8.3 初始化栈

8.4 处理新关键点

情况 1：持续退栈

情况 2：补入 LCA 分叉点

8.5 收尾

9. 为什么这棵树是“有向树”

10. 复杂度要说准确

11. 使用方式

12. 例子理解

13. 常见坑

13.1 没按 dfn 排序

13.2 忘记去重

13.3 每次查询都整图清空

13.4 把虚树边当成原树边长为 1

13.5 忘记标记关键点和补点的区别

13.6 节点编号体系混乱

14. 记忆版总结

网络编程基本概念

网络通信和协议

网络协议和OSI网络模型

TCP/IP模型

IP地址

端口号

客户端和服务端

UDP和TCP

UDP网络协议

UDP编程步骤

UDP特点与优缺点

UDP应用场景

TCP网络协议

TCP编程步骤

TCP特点与优缺点

TCP应用场景

Socket编程

7. 为什么 `dfn[u] == low[u]` 时可以弹出一个 e-BCC

11.2 返祖边用 `low[v]` 更新

3.2 点数上界是 `2K - 1`

13.1 没按 `dfn` 排序

13.4 把虚树边当成原树边长为 `1`