圆方树学习笔记 —— 一种关于点双连通分量的思考方式

引言

本文原名为《圆方树学习笔记 & 最短路题解》，原始版本可见文末。

本文旨在系统梳理 圆方树（Block forest） 及其思想在图论问题中的应用，尤其是在信息学奥林匹克竞赛（OI）中的实际价值。

我们将从一种特殊的图结构------仙人掌图（Cactus Graph）出发，逐步扩展至一般无向图，分析如何通过构造圆方树，来将复杂图上问题转化为树上问题，并借助经典算法（如树形 DP、树链剖分、DDP、虚树等）解决。

本文对涉及的问题进行了系统归类，并配有例题与代码，构建出一套完整的知识体系，帮助读者深入理解核心思想并掌握其在实际题目中的变形与拓展。当然，并非所有问题都需要显式构造圆方树，部分情况下我们仅借助其结构思想进行分析和维护。

在此基础上，本文还创新性地提出了「圆树」这一辅助结构的概念，以优化特定类型问题的建模与求解过程。

希望本笔记能为正在学习相关内容的读者提供一套完整、实用的参考资料。

全文约二十万字符，除代码外有五万字，因此建议阅读的同时做题来巩固知识。

问题引入

在处理无向图上的复杂问题时，我们常借助图的结构性质进行化简，在简化后的图上使用算法解决问题。比如，使用 Tarjan 算法对图进行缩点：

• 强连通分量 缩点后可构成一个有向无环图（DAG）；
• 边双连通分量 缩点后可转化为一棵树；
• 那么，点双连通分量缩点之后，会变成什么结构？

答案是：圆方树（Block forest）。

圆方树正是对图进行点双连通分量 缩点后的结构表示。它将原图中复杂的连通关系映射为树上的结构，从而使许多原本难以处理的问题得以简化为树上问题，显著降低分析与求解的难度。

圆方树的定义

在一张无向图中，对每个点双连通分量建立一个对应的超级节点，并将该分量中所有原图中的点与该超级节点相连，随后删除原图中的所有边。在构建完成后：

• 将这些新增的超级节点称为 「方点」；
• 将原图中的普通节点称为 「圆点」；

这样得到的一棵圆点与方点交错连接的树结构，即为该图的圆方树。

在圆方树上，一个方点的父亲一定是圆点，我们称这个圆点为它的 「父亲圆点」 ，类似定义 「孩子圆点」 ，对于一个圆点类似定义 「父亲方点」 ，「孩子方点」。

以下展示的是一张无向图及其对应的圆方树结构。例如，原图中点双 \(\{2,3,4,5\}\) 对应超级节点 \(15\)，在圆方树中，\(15\) 和 \(2,3,4,5\) 都连有边。

本文中，若无特殊说明，认为「两点被一条边连接」这种图结构 是一个点双 ，如上图中 \(\{8,9\}\)。并为这种点双同样创建一个方点。即在圆方树上不会出现两个圆点直接相连的情况，即不出现圆圆边。

圆方树的简单性质

我们首先需要对圆方树的基本特点有一定了解。

1. 圆方树节点数小于 \(2n\)，其中 \(n\) 为原图点数。

   一个点双引入一个方点，一张图的点双最多只有 \(n-1\) 个，这个上界在图退化为树的情况下达到。所以代码中不要忘记给相关数组开两倍大小。

2. 圆方树上一种类型的点只会和另一种类型的点连边。

   方点只会和圆点连边，圆点只会和方点连边。由定义不难得到这一点。

3. 圆方树上任意一条树链都是「圆方交错」的。

   结合上一条性质，不难发现这个性质。

圆方树构建方式

一种简洁而典型的圆方树建树方法是：在运行 Tarjan 算法求点双连通分量的同时构造圆方树 。并且可以直接把圆方树建成一棵外向树 ，便于后续树上遍历。我们直接让方点从 \(n+1\) 开始编号，圆点保持原图上的编号。

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                ++dcc_cnt;
                while (true) {
                    int x = stack[top--];
                    T.add(dcc_cnt + n, x); // 连边：方点 -> 圆点
                    if (x == v) break;
                }
                T.add(u, dcc_cnt + n);     // 连边：圆点 -> 方点
            }
        } else {
            low[u] = min(low[u], dfn[v]);
        }
    }
}

这是最基础的构建框架，在后文具体问题中，我们将在此代码的基础上进行拓展，比如，为圆方树赋上边权，维护当前点双的子图。

圆方树维护点对间所有简单路径信息

关于原图中两点 \(u,v\) 之间所有的简单路径，我们可以将其映射到圆方树上 \(u,v\) 之间的树链，并且借助圆方树的树形结构，来维护这些所有简单路径的信息和。

点对间所有简单路径信息

对于圆方树的映射方式，等到我们分析完信息维护的方式，就呼之欲出了。

我们先来看几种典型的信息：\(u,v\) 间最长简单路径长度、\(u,v\) 间简单路径条数、\(u,v\) 间所有简单路径长度之和、所有能被某一条 \(u,v\) 间简单路径经过的点权和。

我们可以大致分为如下两类。

类型一：满足分配率的边权、点权相关信息

让我们尝试用形式化的语言来形容，进行适当抽象。

设 \(p_i(u,v)\) 表示某一条 \(u\rightarrow v\) 的简单路径。对于这一条简单路径的信息，如果可以看做其中每一条边 \(e\in p_i(u,v)\) 的信息 \(\operatorname{info}(e)\) 按照一种特定的合并方式 \(\odot\) 合并后的结果，我们就称这种信息为 「边权相关信息」 ，即路径 \(p_i(u,v)\) 的信息为 \(\operatorname{info}(p_i(u,v)) = \bigodot\limits_{e\in p_i(u,v)}\operatorname{info}(e)\)。类似定义点权相关信息，处理这种信息，可以把所有点的点权按照一种方式变成边权，除了某一点需要特殊考虑，剩下维护的就是边权相关信息。因此为了简化讨论，仅考虑边权相关信息。例如：「路径长」是边权相关信息，对于一条边 \(e\)，\(\operatorname{info}(e)\) 就是 \(e\) 的长度 \(\operatorname{len}(e)\)，\(\odot\) 即为 \(+\)，\(\operatorname{info}(p_i(u,v)) = \bigodot\limits_{e\in p_i(u,v)}\operatorname{info}(e) = \sum\limits_{e\in p_i(u,v)}\operatorname{len}(e)\)。

所求的是对于 \(u,v\) 间所有简单路径的信息，按照 \(\oplus\) 合并后的结果，即 \(\operatorname{info}(u,v)=\bigoplus_i\operatorname{info}(p_i(u,v))\)。\(\oplus\) 显然需要满足交换律，否则答案就不唯一了。例如，对于「最长简单路径长度」，就是「路径长」通过 \(\max\) 合并后的信息，\(\odot=+\)，\(\oplus=\max\)，\(\operatorname{info}(u,v)=\max_i\operatorname{info}(p_i(u,v))=\max_i\sum\limits_{e\in p_i(u,v)}\operatorname{len}(e)\)。

明确需要求解什么后，考虑如何维护。

考虑什么情况下可能可以合并 \(\operatorname{info}(u,v)\) 与 \(\operatorname{info}(v,w)\) 得到 \(\operatorname{info}(u,w)\)。发现当且仅当 \(v\) 是割点的时候，合并信息，才可能得到不重不漏的的结果。因为 \(v\) 作为割点，\(u\rightarrow w\) 的每一条简单路径总是可以拆分成 \(u\rightarrow v\) 和 \(v\rightarrow w\) 两条仅在 \(v\) 处相交的简单路径。这是类似于卷积的，即对于所有 \(i,j\)，\(p_i(u,v)\sim p_j(v,w)\) 拼出了一条 \(p_k(u,w)\)，并且这种 \(i,j\mapsto k\) 的映射是唯一的。那么 \(\operatorname{info}(u,w)=\bigoplus_k\operatorname{info}(p_k(u,w))=\bigoplus_{i,j}\operatorname{info}(p_i(u,v)\sim p_j(v,w))\)。

在树上，因为 \(u\rightarrow v\) 和 \(v\rightarrow w\) 的简单路径是唯一的，我们有 \(\operatorname{info}(u,w)=\operatorname{info}(u,v)\oplus\operatorname{info}(v,w)\)，这是简单的。但是此时 \(u\rightarrow v\) 和 \(v\rightarrow w\) 的简单路径不是唯一的，就不能直接通过 \(\oplus\) 合并了。

有时候我们能够找到一种运算 \(\otimes\)，使得我们可以打开这个 \(\bigoplus\)，直接合并两个子问题的信息。它需要满足 \(\bigoplus_{i,j}\operatorname{info}(p_i(u,v)\sim p_j(v,w))=\Big(\bigoplus_{i}\operatorname{info}(p_i(u,v))\Big)\otimes\Big(\bigoplus_{j}\operatorname{info}(p_j(v,w))\Big)\)，也就是通过 \(\otimes\) 类似树上直接合并两个子问题的信息。把 \(\operatorname{info}\) 用 \(\odot\) 表示，也就是 \(\bigoplus_{i,j}\bigodot_{e\in p_i(u,v)\sim p_j(v,w)}\operatorname{info}(e)=\Big(\bigoplus_{i}\bigodot_{e\in p_i(u,v)}\operatorname{info}(e)\Big)\otimes\Big(\bigoplus_{j}\bigodot_{e\in p_j(v,w)}\operatorname{info}(e)\Big)\)。为了方便观察，不妨用 \(S_i\) 表示 \(p_i(u,v)\)，\(T_i\) 表示 \(p_i(v,w)\)，等式变为：\(\bigoplus_{i,j}\bigodot_{e\in S_i\cup T_j}\operatorname{info}(e)=\Big(\bigoplus_{i}\bigodot_{e\in S_i}\operatorname{info}(e)\Big)\otimes\Big(\bigoplus_{j}\bigodot_{e\in T_j}\operatorname{info}(e)\Big)\)。用 \(f_i\) 表示 \(\bigodot_{e\in S_i}\operatorname{info}(e)\)，\(g_j\) 表示 \(\bigoplus_{j}\bigodot_{e\in T_j}\operatorname{info}(e)\)，上等式变成：\(\bigoplus_{i,j}\Big(f_i\odot g_j\Big)=\Big(\bigoplus_{i}f_i\Big)\otimes\Big(\bigoplus_{j}g_j\Big)\)。这个形式很像分配律，进一步，我们可以断言，当且仅当 \(\odot\) 对 \(\oplus\) 满足 分配律 时，\(\otimes\) 存在，且 \(\otimes\) 就是 \(\odot\) 本身，此时，\(\odot\) 和 \(\oplus\) 构成一个 半环。

例如，当 \(\odot=+\)，\(\oplus=\max\) 时，\(+\) 对 \(\max\) 满足分配律，此时 \(\otimes\) 存在，且 \(\otimes=\odot=+\)。实际图论意义也很好理解，\(u\rightarrow w\) 所有简单路径中的最长的长度，即为 \(u\rightarrow v\) 和 \(v\rightarrow w\) 分别找到两条最长的拼起来。当 \(\odot=\times\)，\(\oplus=+\) 时，\(\times\) 对 \(+\) 满足分配律，此时 \(\otimes\) 存在，且 \(\otimes=\odot=\times\)。当 \(\odot=\oplus=+\) 时，\(+\) 对 \(+\) 不满足分配律，我们找不到 \(\otimes\) 这个运算吗？若仅记录「边权相关信息」，我们确实找不到这样一个运算。但是在后文，我们通过扩展信息的方式，找到了维护这种信息的方式。

有了合并信息的方式，我们要考虑 「原子信息」 ，即小到不能再小的信息，此时就是 \(u,w\) 处在同一个点双的时候，我们不能找到一条连接 \(u,w\) 的简单路径通过某一个割点 \(v\)，于是不能通过合并信息的方式得到 \(u\rightarrow w\) 的信息。不妨对于处于同一点双中的 \(u,w\)，用 \(\operatorname{info}(u,w)\) 表示 \(u,w\) 之间的原子信息。原子信息通常是能够方便处理出来的。

我们已经学会了如何维护 \(\odot\) 对 \(\oplus\) 满足分配律的「边权相关信息」、「点权相关信息」。

类型二：非权值相关信息或 \(\odot=\oplus\) 的权值相关信息

此时只存在 \(\otimes\) 这个合并运算。预处理出原子信息同样通常是简单的。例如对于「简单路径条数」，\(\otimes\) 就是 \(\times\)。

上文中遗留一个问题，当 \(\odot=\oplus=+\) 时，由于 \(+\) 对其自身不具有分配律时，不能直接通过「边权相关信息」的方式维护。考虑扩展信息，设 \(\operatorname{info}(u,v)=(s,c)\)，其中 \(s\) 表示所求的「所有简单路径长度之和」，\(c\) 表示 \(u\rightarrow v\) 简单路径条数。我们惊喜地发现，有 \((s_1,c_1)\otimes(s_2,c_2)=(s_1c_2+s_2c_1,c_1\cdot c_2)\)，这是可以维护的！式子的意义是，对于每一条 \(p_i(u,v)\)，由于有 \(c_2\) 条 \(p_j(v,w)\)，所以 \(s_1\) 会贡献 \(c_2\) 次。

推广到到一般情况，当 \(\odot=\oplus\) 且对自身不具有分配律时，由于 \(\oplus\) 具有交换律，那么 \(\odot\) 也具有交换律，我们总是可以多记录一个 \(c\)，有 \((s_1,c_1)\otimes(s_2,c_2)=\Big((\odot_{c_2}(s_1))\odot(\odot_{c_1}(s_2)),c_1\cdot c_2\Big)\)，其中 \(\odot_{k}(x)=\underbrace{x\odot x\odot\cdots\odot x}_{k\text{ 个 }x}\)。

还有另一种可能需要维护的信息，即求能被任意一条 \(u\rightarrow v\) 简单路径经过的所有点 / 边的权值和，这个问题其实非常好处理，只需令 \(\otimes=\oplus\) 即可，这样就能统计到所有点 / 边的权值和，这和树上十分类似。

总结

以上几种信息，在处理完原子信息后，最后都是需要在一个个割点处，将信息通过 \(\otimes\) 合并起来，这正是圆方树可以解决的。

支持查询信息

让我们回到圆方树上，看看它对我们维护信息有什么帮助。

对于 \(u\rightarrow v\) 路径上的信息，可以将路径拆分成不断从一个点双走到另一个点双的过程，即 \(w_1 \stackrel{d_1}{\longrightarrow} w_2\stackrel{d_2}{\longrightarrow} w_3\stackrel{\cdots}{\longrightarrow} w_{m-1}\stackrel{d_{m-1}}{\longrightarrow}w_m\)，其中 \(w_1=u, w_m=v\)，对于 \(i=1,\ldots,m-1\)，\(w_{i},w_{i+1}\) 分别是编号为 \(d_i\) 的点双中两个点。根据上述讨论，我们要求的就是 \(\bigotimes\limits_{i=1}^{m-1}\operatorname{info}(w_i,w_{i+1})\)，而每个 \(\operatorname{info}(w_i,w_{i+1})\) 均为原子信息。

\(w_i\stackrel{d_i}{\longrightarrow}w_{i+1}\) 是走进一个点双，再从中走出来，圆方树上，我们为每个点双建立了一个方点，这不就相当于从 \(w_i\) 走到 \(d_i\) 对应的方点，再走到 \(w_{i+1}\) 吗？进一步地，这不就构成了圆方树上一条以 \(u,v\) 为端点的树链了吗？我们于是自然得出了圆方树和原图之间的对应关系：

1. 圆方树上一条「圆方圆」的路径，对应原图点双中两点之间所有简单路径。

   比如上图中 \(\{3,15,5\}\) 这条圆方圆路径，对应原图中 \(\{2,3,4,5\}\) 这个点双中以 \(3,5\) 为端点的所有简单路径，即 \(\{3,2,5\},\{3,4,5\}\) 两条简单路径。

   这就是进入一个点双，再从这个点双中走出来。

2. 圆方树上任意一条树链 \((u,v)\) 对应原无向图中 \(u,v\) 之间所有简单路径。

   比如上图中 \((3,8)\) 这条树链，对应了原图中 \(\{3,2,5,9,8\},\{3,2,5,6,9,8\},\{3,4,5,9,8\},\{3,4,5,6,9,8\}\) 这些简单路径。

   这种把每一条「圆方圆」的路径合并起来的过程，对应不断从一个点双走到另一个点双的过程。

圆方树很好地刻画了通过 \(\otimes\) 合并信息的过程！让我们继续分析。

对于一次查询 \((u,v)\)，设 \(p=\operatorname{lca}(u,v)\)，将树链拆分成 \(u\rightarrow p\rightarrow v\)。考虑 \(u\rightarrow p\) 一侧，另一侧类似。

考虑如下圆方树一部分：

当我们经过某一个圆点（蓝点）\(u\)，跳向它爷爷（绿点）\(v\) 时，需要求的是 \(u\) 和 \(v\) 的原子信息 \(\operatorname{info}(u,v)\)。不考虑修改的情况下，每一次从 \(u\) 跳到 \(v\)，原子信息都是相同的，因为它的爷爷 \(v\) 是唯一的。我们于是这可以预处理出这些原子信息，而这类原子信息的个数和非根圆点个数相同，是 \(\mathcal{O}(n)\) 的。我们将 \(u\) 和 \(v\) 的信息，放在 \(u\) 到它父亲方点（红点）的边权上，每个方点和它父亲圆点之间的边权设为单位元。那么我们考虑一对具有祖孙关系的节点，他们之间的信息，便是圆方树上他们之间边权按序合并的结果。

对于 \(u\rightarrow p\) 和 \(p\rightarrow v\) 两段，根据我们赋的边权，和我们之前学过的树上信息维护方式，这两段路径的信息已经可以求出。对于不满足交换律的信息，可能需要维护向上跳的信息和向下跳的信息。接下来，好像直接把这两个信息合并起来就是对的，其实不然。对于 \(p\) 是圆点的情况，这么做是正确的；但是对于 \(p\) 是方点的情况，设 \(u'\) 为 \(p\) 的孩子且是 \(u\) 的祖先，\(v'\) 同理，那么考虑直接合并信息的实际意义，是从 \(u\) 走到 \(u'\)，进入了 \(p\) 对应的点双，走到了 \(\operatorname{fa}(p)\)，再走进 \(p\) 对应的点双，走到 \(v'\)，最终到 \(v\)。这显然是错误的，我们要求 \(u'\rightarrow v'\) 的原子信息 \(\operatorname{info}(u',v')\)，而非 \(\operatorname{info}(u',\operatorname{fa}(p))\otimes\operatorname{info}(\operatorname{fa}(p),v')\)。解决方式很简单，只需要特殊查询一次 \(u'\rightarrow v'\) 的原子信息，和之前两个信息合并。

在实现上，我们需要支持询问点双内两点之间的原子信息，那么这是否意味着需要为每个点记录其所在所有点双内的信息？如果真的需要，我们可以为每一个元素开 \(m+1\) 个 vector，其中 \(m\) 个 vector<> info 用来记录信息，\(1\) 个 vector<int> id 用来存所有 \(u\) 点双的编号，意为 \(u\) 在编号为 id[u][i] 的点双内对应的信息为 info[u][i]，对于查询 \(u\) 在编号为 \(x\) 的点双中的信息，先在 id[u] 中二分出 \(x\) 的下标，再拿这个下标去访问 info[u]。但是这是不必要的，这是因为我们的查询并不真的「任意」，而是只会查询一个圆点，在其父亲方点对应点双中的信息。而每个孩子圆点的父亲是唯一的，如果他被查询到，所用到的信息也是唯一的，那就不需要使用 vector 了。vector 的写法请参考下文仙人掌部分例五代码。

至此，我们借助圆方树的特殊结构，结合树上信息维护方式，通过 \(\otimes\) 的合并方式，可以查询给定点对间所有简单路径的信息。

支持修改信息

如果有了修改呢？树上我们使用树剖来支持修改查询树链信息，那么接下来要做的就是把圆方树剖开，尝试在上面维护信息。

先来考虑一种特殊的信息，求 \(u\rightarrow v\) 能到达的所有点的点权的信息和。这时候同一个点双内 \(u\rightarrow v\) 的信息为点双中除去 \(v\) 的点权信息和。发现圆方树上的边权很有规律，对于一个方点，它连向所有孩子圆点的边权总是相同的，都是该点双中除去父亲圆点的点权信息和。我们把边权上放，给方点一个点权（注意和原点权加以区分），为原先我们给圆方树赋的边权，再把圆点的点权设置为单位元。我们的查询似乎就变成了圆方树上路径的点权信息之和。

考虑在 LCA 处的特殊情况。若 LCA 为方点，同样需要得到 \(u'\rightarrow v'\) 的信息。如果严格遵循上文对原子信息的定义，我们需要先扣掉 \(v'\) 的点权，但是这样到最后会漏掉 \(v'\) 的点权（点权转换后的特殊情况），所以我们完全不必扣掉 \(v'\) 的点权，而是查出 LCA 的点权后，再加上 LCA 父亲圆点的点权。对于 LCA 为圆点的情况，我们统计漏了这个 LCA 圆点的信息，这把它的点权贡献到答案里就好了。如此就完成了查询。

修改某个点的权值的时候，除了需要维护仙人掌上每个点的点权，还要修改其在圆方树上父亲方点的点权。要想快速得到新的点权，要对每一个方点维护一个支持插入删除的数据结构，每次先删除原先的贡献，再加入修改后点权的贡献即可。

我们现在只需要在一棵树上，支持修改点权，询问 \(\operatorname{lca}\)，询问路径点权和。这个可以树剖做到 \(\log^2\)，或者可以做到单 \(\log\)。另外，理论上来说，我们还可以继续上放点权，也就是在圆树操作。但是这会造成很多边界情况，不优雅，故不展开讨论。

考虑更为一般的情况。我们发现边权上放的本质是为了修改的时候，能够将父亲方点的所有孩子圆点往上跳的边权都修改。但是真的一定需要更新每个孩子圆点吗？并不是，我们只需要修改重孩子圆点。每次跳重链时，只需要考虑链顶这个轻儿子的特殊情况。于是完成了修改和维护信息。

「圆树」：不设置方点的可行性

上文中，方点的作用仅是用来判断 \(u'\) 和 \(v'\) 是否在同一点双内，在一些简单的问题中，我们确实可以不建出方点，只建出「圆树」，并在每个点记录它在圆方树上父亲方点是谁，在查询的时候，只需要要找出 \(u',v'\)（如果存在的话），然后判断他们的父亲圆点是否相同，就能知道 LCA 是方点还是圆点。

优点

1. 节点总数为 \(n\)：

   不引入新的方点，整棵树的节点数量保持为原图大小的 \(n\)，在最坏情况下仅为传统圆方树节点数的一半。这样可以节省时间空间，而且不会因为手残数组开小，或者预处理只处理到 \(n\) 而红温。

2. 实现简单：

   若采用倍增算法来维护树上信息和求 LCA，当一个节点是另一个节点的祖先时，不会出现 LCA 是方点的特殊情况。剩下来的情况，我们倍增本来就是先求出了 \(u',v'\)，然后再跳最后一步到 LCA 的，那我们在跳之前判断一下就好了，不必等到跳了才发现是同一个方点。

缺点

1. 过度依赖倍增：
   若题目采用树上前缀和、差分等方式来维护信息，通常使用基于 DFS 序的 \(\mathcal{O}(1)\) LCA 算法，而寻找 \(u', v'\) 却是 \(\mathcal{O}(\log n)\) 的，导致效率不匹配。除非你愿意使用如长链剖分实现 \(\mathcal{O}(1)\) 的 kth-father 查询：先求出 LCA，再通过深度差计算 \(u'\) 或 \(v'\)，这会显著增加代码复杂度。

   发明了基于 DFS 序 \(\mathcal{O}(1)\) 求 \(u',v'\) 的算法，可见：博客。

2. 在特定情况下有过多边界问题：

   例如维护需要支持修改的信息，使用圆树将需要很多分类讨论，万一没有讨论所有情况，就会出错，而且代码将变得难以理解。

3. 过于小众：
   求调的时候别人说看不懂。

---

总而言之，这是仅是一种小优化，在掌握了圆方树的基本构造与思想后，读者可根据题目类型与实现习惯，自行选择是否采用此优化版本。

圆树和圆方树两种写法，在例题五和例题十三均分别给出，供参考对比。

圆方树在「仙人掌」上的应用

我们先从 仙人掌 这种特殊的无向图开始研究圆方树，这是因为仙人掌具有十分良好的性质。

初识仙人掌

仙人掌的定义

仙人掌指任意一条边最多出现在一个简单环中的无向连通图。

仙人掌的性质

1. 仙人掌边数上界为 \(\mathcal{O}(n)\)。

   准确来说，为 \(2n-2\) 或 \(\lfloor\frac{3}{2}(n-1)\rfloor\)。

   当允许重边时，把一棵树的所有 \(n-1\) 条树边，复制一遍，得到一棵 \(2n-2\) 条边的仙人掌。注意不可能出现三条重边连接两个点，否则就不满足仙人掌的定义了。

   当不允许重边时，可以发现如下「类菊花」的结构使得边数达到最多，为 \(\lfloor\frac{3}{2}(n-1)\rfloor\)。

   

2. 仙人掌具有类似树的结构。

   我们发现，由于仙人掌的环不交（准确的说为边不交），这使得其保留了树的一些形态。

   把每一个环看做一个巨大的节点，仙人掌就成了一棵树了，只不过有些节点间不依靠边相连，而是在公共点处相切。

   类似树上「子树」，我们可以定义「子仙人掌」。
   「子仙人掌」

   指定一个根，定义 \(u\) 的「子仙人掌」为，断开根和 \(u\) 的所有简单路径的边后，\(u\) 所在的连通块。

   不难发现，\(u\) 的「子仙人掌」对应圆方树上 \(u\) 的子树。画个图就十分清晰了：

   

   不难做进一步推广，类似在一般无向图上定义「子无向图」，容易发现，这同样对应圆方树的子树。

   类似树上「树链」，在 只存在奇环 的仙人掌上，由于最长 / 短路唯一，我们可以定义「长链」、「短链」的概念。
   「长链」、「短链」

   \(u,v\) 之间经过边数最多的的简单路径称为 \(u,v\) 间的「长链」；\(u,v\) 之间经过边数最少的简单路径称为 \(u,v\) 间的「短链」。

   显然，在仙人掌中每经过一个环时，若都选择在环上走最长（或最短）路径 ，则整条走出的路径即为 \(u, v\) 间的长链（或短链）。

需要注意仙人掌上的点双并 不一定是环，通过一条不在环上的边连接的两个点，构成了两个点的点双，而这个点双不是一个环。有时候我们需要特判这种情况。

仙人掌上构造圆方树

我们可能需要在构造圆方树的时候，维护当前环的形态，即得到当前环对应的子图。

方法一：树上前缀和

一种做法是，对每个节点维护在 tarjan 的 dfs 树上的树上前缀和（即到根的信息），对于在 dfs 树上 \(u\) 是 \(v\) 的祖先，用 \(v\) 的前缀和减去 \(u\) 的前缀和，就能得到 \(u\) 到 \(v\) 之间的信息。那我们选用父亲圆点 \(u\) 作为环首，这样环上每一个点都处于 dfs 树中 \(u\) 的子树中，于是可以得到每个点到环首 \(u\) 的信息。至于总环长，发现我们上述过程考虑的是一条以 \(u\) 为环首的一条链，对于环尾 \(v\)，他有且仅有一条返祖边，且这条返祖边恰连向 \(u\)，从而构成一个环。一个点不可能有两条或以上返祖边，否则不满足仙人掌的定义。而这个返祖边我们可以轻松维护。如下图，蓝色的边为 dfs 树树边，红色的边为返祖边，细黑边为圆方树上的树边。当前的环即为若干条蓝边和一条红边构成的环。绿色箭头表示环首走向环尾的方向，蓝紫色箭头指向形成闭环的那条环尾指向环首的边。

方法二：弹边栈

这种做法对于不可差分信息不太好处理，并且依赖于环这种形态，不好向一般点双拓展。考虑类似点的栈，维护一个边的栈，存返祖边和树边，在 tarjan 的过程中，每次找到一个点双（\(\operatorname{low}(v) \geq \operatorname{dfn}(u)\)），就不断弹栈，直到弹出连接 \(u,v\) 的树边 （注意必须是树边）。这个过程中弹出的边，便构成了这个点双的子图。对于复杂一些的点双，我们需要建出这个子图，然后在这个子图上跑一些算法，但是于仙人掌而言，我们把一个环建出来再处理，未免小题大做了。我们发现按照弹栈的顺序，弹出的边依次为环中的返祖边，深度最深的树边，深度次深的树边，直到 \(u,v\) 之间的树边。更加优雅的做法是，我们按照弹栈的顺序，假设当前弹出的边为 \(u'\rightarrow v'\)，边权为 \(w\)，并且不是连接 \(u,v\) 的树边，设 \(u\) 在环上的信息前缀和为 \(p_u\)，那么就让 \(p_{u'}\gets p_{v'}+w\)。这种方法下，环首为 \(u\)，环尾是 \(v\)，\(u,v\) 之间的树边成了环尾连向环首的边。如下图。事实上，使用了这种方式，我们不需要原先的点栈，每次弹出的边的起点，相当于原先点栈每次弹出的点。

类型一：单次询问整体信息

计数类问题

在处理计数类问题时，往往需要借助圆方树进行类似树形 DP，或其他类似树上的统计方法。

在普通树上，这类问题我们已非常熟悉；放到基环树上，常见的技巧是将环上 DP 与树形 DP 分开处理，其本质原因是，把环上每个结点看做对应树根，这棵树是一个子问题，所以剩下的部分是一个环上问题。

在仙人掌上，由于我们前文提到的仙人掌具有的类似树的性质，所以在 DP 转移的时候，可以分环上 DP 和树形 DP 进行转移，或者按照环上和树上进行统计答案。这在圆方树上体现为，在方点、圆点上分别处理。

实际上，对于这类问题，我们甚至无需显式构建整棵圆方树。只需在分析与转移过程中设想当前所处的是圆点还是方点，并据此决定转移逻辑，即可完成建模与求解。这也是圆方树思想灵活而强大的体现。
例一、静态仙人掌最大独立集（小 C 的独立集，黑暗爆炸、洛谷、Hydro） Problem Statement

给你一个有 \(n\) 个点和 \(m\) 条边的仙人掌，求它的最大独立集大小。

\(n\leq 5\times 10^4\)，\(m\leq 6\times 10^4\)。
Problem Analysis

树上最大独立集是经典的（猜你想找：没有上司的舞会），我们设 \(f_{u,0/1}\) 表示以 \(u\) 为根的子树这个子问题，\(u\) 选 / 不选，最大独立集为多少。转移为 \(f_{u,0}=\sum\limits_{v\in\operatorname{son}(u)}\max\Big\{f_{v,0},f_{v,1}\Big\}\)，\(f_{u,1}=\operatorname{val}(u)+\sum\limits_{v\in\operatorname{son}(u)}f_{v,0}\)。

基环树上最大独立集是经典的（猜你想找：MAFIJA，ZJOI2008 骑士），我们先把树形 DP 跑了，得到环上每个点 \(u\) 的 \(f_{u,0/1}\)，然后再做一遍环上 DP。如果这个环没有首尾之间的独立集限制，这其实就是一条链，按照树的方式转移即可。但是首尾之间有限制，我们就先钦定首必不能选，然后做一遍 DP，把尾的 \(f_{0/1}\) 算到答案的贡献里，然后钦定首必选（亦可钦定其可选可不选，如果需要求独立集方案，为了不冲不漏，此处要钦定必选），再做一遍 DP，把尾的 \(f_0\) 贡献进去，这里就不贡献 \(f_1\) 了，不然会不满足首尾之间的限制条件。
另外一种基环树 DP 形式

有人说，我学的基环树 DP 不太一样，是：把环上一条边拎出来，剩下一棵树，然后类似上面的钦定，做两遍树形 DP。这两种方法其实是本质相同的，只不过这种方法把断边后的环当做树上一条链，整体做一遍 DP，相当于把环上 DP 放在树形 DP 里做了。对于仙人掌来说，我们还是喜欢单独对环做 DP。

那么仙人掌上也很好做了。\(f\) 的定义便是关于 \(u\) 的子仙人掌上的信息。圆点上我们赋初值 \(f_{u,0}\gets 0, f_{u,1}\gets 1\)。在方点上，我们做环上 DP，然后把答案统计到方点的父亲圆点 \(u\) 上。先使得 \(u\) 在环尾，然后类似基环树上的环做两遍 DP，得到 \(f_{u,0/1}\)。在两遍环上的 DP 的时候，不要把答案直接赋给 \(f_u\)，而是应该使用临时变量存放，做完两遍 DP 后再存到 \(f_u\) 里面，这样是为了避免第一次 DP 对第二次 DP 造成的影响。

于是，我们做到了时空线性 \(\mathcal{O}(n+m)\) 解决了本题。

---

做完这题可以去尝试一下 SDOI2010 城市规划，树套环上求至少间隔两个位置的最大独立集，可以参考我的题解。
Solution

#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;

const int N = 5e4 + 10;
const int M = 6e4 + 10;

int n, m;

struct node {
    int v, nxt;
} edge[M << 1];
int head[N], tot = 1;
void add(int u, int v) {
    edge[++tot] = { v, head[u] };
    head[u] = tot;
}

int dfn[N], low[N], timer;
int stack[N], top;

int f[N][2], g[N][2];

void tarjan(int u, int fr) {
    f[u][1] = 1, f[u][0] = 0;  // 圆点直接赋初值
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = head[u]; i; i = edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = edge[i].v;
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                // 这里应该会新建一个方点
                // 但我们并不需要真的把圆方树建出来
                
                vector<int> scc;
                while (true) {
                    int x = stack[top--];
                    scc.emplace_back(x);
                    if (x == v) break;
                }
                scc.emplace_back(u);   // u 在环尾
                
                int m = scc.size();
                int f0 = 0, f1 = 0;
                
                // 强制首不选
                g[0][0] = f[scc[0]][0], g[0][1] = -0x3f3f3f3f;
                for (int i = 1; i < m; ++i) {
                    g[i][0] = max(g[i - 1][0], g[i - 1][1]) + f[scc[i]][0];
                    g[i][1] = g[i - 1][0] + f[scc[i]][1];
                }
                f0 = max(f0, g[m - 1][0]);
                f1 = max(f1, g[m - 1][1]);
                
                // 首可选可不选
                g[0][0] = f[scc[0]][0], g[0][1] = f[scc[0]][1];
                for (int i = 1; i < m; ++i) {
                    g[i][0] = max(g[i - 1][0], g[i - 1][1]) + f[scc[i]][0];
                    g[i][1] = g[i - 1][0] + f[scc[i]][1];
                }
                f0 = max(f0, g[m - 1][0]);
                
                f[u][0] = f0, f[u][1] = f1;
            }
        } else {
            low[u] = min(low[u], dfn[v]);
        }
    }
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1, u, v; i <= m; ++i) {
        scanf("%d%d", &u, &v);
        add(u, v), add(v, u);
    }
    tarjan(1, 0);
    printf("%d", max(f[1][0], f[1][1]));
    return 0;
}

从最简单的树开始思考，然后想想基环树怎么处理，最后思考仙人掌上的问题，是我们处理此类问题的一般模式。这是由 \(0\) 个环，到 \(1\) 个环，再到若干个环，不断加强问题的过程。
例二、静态仙人掌直径（SHOI2008 仙人掌图，黑暗爆炸、洛谷、Hydro） Problem Statement

给你一个有 \(n\) 个点和 \(m\) 条边的仙人掌，求它的直径。直径被定义为两点间最短距离的最大值。

\(n\leq 5\times 10^4\)，\(m\leq 10^7\)。
Problem Analysis

树的直径是经典的（猜你想找：Longest path in a tree）。我们有两种解法，一种是两遍 DFS，但是它碰到负权边就挂了，而且不太具有可拓展性；另一种解法是树形 DP，记 \(f_u\) 表示从 \(u\) 开始往叶子的方向走，最长距离是多少，枚举 \(v\in \operatorname{son}(u)\)，先贡献答案 \(D\Leftarrow f_u+f_v+1\)，再做 DP \(f_u\Leftarrow f_v+1\)。（其中 \(a\Leftarrow b\) 表示 \(a\gets\max\{a,b\}\)。）

基环树求直径是经典的（猜你想找：IOI 2008 Island，NOI2013 快餐店，但是需要说明的是，这两题形式和本题相同，但是对直径的定义都略有不同，以下按照本题的定义分析）。先跑树形 DP，该贡献答案的贡献到答案里去，然后得到环上每一个点的 \(f\)，考虑一条经过环边的路径，设 \(\{c_m\}\) 表示这个环，那么这条路径形如：\(u \stackrel{\displaystyle f_{c_i}}{\longrightarrow} c_i \stackrel{w(i,j)}{\longrightarrow} c_j \stackrel{\displaystyle f_{c_j}}{\longrightarrow} v\)，其中 \(w(i,j)\) 表示环上第 \(i\) 个点到第 \(j\) 个点之间的最短距离，即为 \(\min\Big\{j-i,m-(j-i)\Big\}\)。考虑怎么求出 \(f_{c_i}+w(i,j)+f_{c_j}\) 的最大值。我们先拆换成链，再复制一份接在后面。枚举 \(i\) 和小于它的 \(j\)，强制让 \(w(j,i)\) 就等于 \(i-j\)，此时 \(j\) 需要满足的条件为 \(i-j\leq m-(i-j)\) 即 \(j\geq i-\lfloor m/2\rfloor\)，如此，我们统计的信息就是 \(\max\limits_{j=i-\lfloor m/2\rfloor}^{i-1}\Big\{f_{c_j}-j\Big\}+i+f_{c_i}\)，滑动窗口最值，可以用单调队列维护。注意到，这样我们并不会漏掉某一种情况。

那么仙人掌求直径也是简单的。我们在方点统计完答案的贡献后，还要处理出方点的父亲圆点 \(u\) 的 \(f\) 值，这个直接枚举环上另一个点 \(v\) 就可以了。

时空复杂度 \(\mathcal{O}(n+m)\)。
Solution

#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;

const int N = 5e4 + 10;
const int M = 1e7 + 10;

int n, m, ans;

struct node {
    int v, nxt;
} edge[M << 1];
int head[N], tot = 1;
void add(int u, int v) {
    edge[++tot] = { v, head[u] };
    head[u] = tot;
}

int dfn[N], low[N], timer;
int stack[N], top;

int f[N], g[N << 1], Q[N << 1];

void tarjan(int u, int fr) {
    f[u] = 0;
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = head[u]; i; i = edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = edge[i].v;
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                vector<int> scc;
                while (true) {
                    int x = stack[top--];
                    scc.emplace_back(x);
                    if (x == v) break;
                }
                scc.emplace_back(u);
                int m = scc.size();
                
                for (int j = 0; j < m; ++j)
                    g[j] = g[j + m] = f[scc[j]];
                
                int head = 0, tail = -1;
                for (int j = 0; j < m << 1; ++j) {
                    while (head <= tail && Q[head] < j - m/2) ++head;
                    if (head <= tail) ans = max(ans, g[Q[head]] - Q[head] + j + g[j]);
                    while (head <= tail && g[Q[tail]] - Q[tail] <= g[j] - j) --tail;
                    Q[++tail] = j;
                }
                
                for (int j = 0; j < m - 1; ++j)
                    f[u] = max(f[u], f[scc[j]] + min(j + 1, m - j - 1));
            }
        } else {
            low[u] = min(low[u], dfn[v]);
        }
    }
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1, k; i <= m; ++i) {
        scanf("%d", &k);
        for (int u = 0, v; k--; u = v) {
            scanf("%d", &v);
            if (u) add(u, v), add(v, u);
        }
    }
    tarjan(1, 0);
    printf("%d", ans);
    return 0;
}

通过这两道板子题，相信你已经对静态仙人掌上全局问题的求解有了清晰的认识。

以上，我们了解了静态仙人掌上统计全局信息的方法。尽管我们并没有把圆方树建出来，我们还是可以想象在一棵虚拟的圆方树上求解问题：在一个方点上，处理这环上的信息，把孩子圆点的信息合并到父亲圆点中去；在一个圆点上，我们赋 DP 初值。这也是标题中「一种关于点双连通分量的思考方式」的体现，我们解题可能不需要圆方树，但是思考过程会借助圆方树方便思考。

所有路径类问题

如果你需要统计所有路径的信息，树上我们可能需要用到点分治。那么在仙人掌上，我们要对圆方树进行点分治，类似于树上，对于一个点统计经过这个点的信息。理论上来说点分树也可以被应用在仙人掌上。

由于作者还没有学习到 FFT，例题暂时不能完成，这部分暂且不展开。

所有「子仙人掌」类问题

树上这类问题我们有 树上启发式合并（DSU on tree） 的做法，也可以使用线段树合并优化。

根据结论，子仙人掌对应圆方树的子树，问题就被放到圆方树上，真的成了一棵树上的问题了。
例三、persistent DSU on cactus（洛谷） Problem Statement

\(n\) 个点 \(m\) 条边的仙人掌，每个结点有一个颜色 \(c_u\)。

\(q\) 次询问 \((u,k)\)，求 \(u\) 的子仙人掌中出现次数不小于 \(k\) 的颜色的颜色编号和。

\(u\) 的子仙人掌被定义为：断开在 \(1,u\) 所有简单路径上出现过的边后，\(u\) 所在的连通块。

不知道为什么出题的时候出成了强制在线。只要空间复杂度别太离谱就行。

\(2\leq n\leq10^5\)。\(1\leq q\leq 10^5\)。\(k\leq n\)。\(c_u\in1,n\)。
Problem Analysis

离线 DSU on tree，时间复杂度两只 \(\log\)，如果强制在线，其实就是需要树状数组的在每一个结点上的版本。换成一个可以支持：继承、单点修改、区间查询的数据结构，就是主席树。
Solution Code

#include <cstdio>
#include <iostream>
using namespace std;

const int N = 1e5 + 10;
const int M = N * 2;
const int NN = N * 2;

int n, m, q, c[N], O;

template <size_t _N, size_t _M>
class Graph {
public:
    Graph(): tot(1) {}
    struct node {
        int v, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v) {
        edge[++tot] = { v, head[u] };
        head[u] = tot;
    }
};

Graph<N, M << 1> G;
Graph<NN, NN> T;

namespace $build {

int dfn[N], low[N], timer;
int stack[N], top;
int dcc_cnt;

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                ++dcc_cnt;
                T.add(u, dcc_cnt + n);
                while (true) {
                    int x = stack[top--];
                    T.add(dcc_cnt + n, x);
                    if (x == v) break;
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
        }
    }
}

}

namespace $yzh {

const int M = N * 230;

struct node {
    int ls, rs;
    long long sum;
} tr[M];

int tot;
inline int copy(int u) {
    return tr[++tot] = tr[u], tot;
}

void modify(int& u, int l, int r, int p, int v) {
    tr[u = copy(u)].sum += v;
    if (l == r) return;
    int mid = (l + r) >> 1;
    if (p <= mid) modify(tr[u].ls, l, mid, p, v);
    else modify(tr[u].rs, mid + 1, r, p, v);
}

long long query(int u, int trl, int trr, int l, int r) {
    if (!u) return 0;
    if (l <= trl && trr <= r) return tr[u].sum;
    int mid = (trl + trr) >> 1;
    long long res = 0;
    if (l <= mid) res += query(tr[u].ls, trl, mid, l, r);
    if (r >  mid) res += query(tr[u].rs, mid + 1, trr, l, r);
    return res;
}

int combine(int u, int v) {
    if (!u || !v) return u | v;
    int o = copy(u);
    tr[o].sum += tr[v].sum;
    tr[o].ls = combine(tr[o].ls, tr[v].ls);
    tr[o].rs = combine(tr[o].rs, tr[v].rs);
    return o;
}

}

int dfn[NN], L[NN], R[NN], timer;
int siz[NN], son[NN];

void dfs(int u) {
    dfn[L[u] = ++timer] = u;
    siz[u] = 1;
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        dfs(v);
        siz[u] += siz[v];
        if (siz[v] > siz[son[u]])
            son[u] = v;
    }
    R[u] = timer;
}

int cnt[N], rt[NN];

void sub(int l, int r) {
    for (int i = l; i <= r; ++i) {
        int u = dfn[i];
        if (u > n) continue;
        cnt[c[u]] -= 1;
    }
}

void add(int l, int r, int& rt) {
    for (int i = l; i <= r; ++i) {
        int u = dfn[i];
        if (u > n) continue;
        if (cnt[c[u]])
            $yzh::modify(rt, 1, n, cnt[c[u]], -c[u]);
        $yzh::modify(rt, 1, n, ++cnt[c[u]], c[u]);
    }
}

void redfs(int u) {
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        if (v == son[u]) continue;
        redfs(v);
        sub(L[v], R[v]);
    }
    if (son[u]) redfs(son[u]), rt[u] = rt[son[u]];
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        if (v == son[u]) continue;
        add(L[v], R[v], rt[u]);
    }
    add(L[u], L[u], rt[u]);
}

int main() {
    scanf("%d%d%d", &O, &n, &m);
    for (int i = 1; i <= n; ++i)
        scanf("%d", &c[i]);
    for (int i = 1, u, v; i <= m; ++i) {
        scanf("%d%d", &u, &v);
        G.add(u, v), G.add(v, u);
    }
    $build::tarjan(1, 0);
    dfs(1), redfs(1);
    scanf("%d", &q);
    for (long long u, k, lst = 0; q--; ) {
        scanf("%lld%lld", &u, &k);
        if (O) u ^= lst, k ^= lst;
        printf("%lld\n", lst = $yzh::query(rt[u], 1, n, k, n));
    }
    return 0;
}

Gen

#include <cstdio>
#include <iostream>
#include <vector>
#include <random>
#include <chrono>
#include <map>
#include <sstream>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;

const int SEED = chrono::system_clock::now().time_since_epoch().count();

mt19937 rnd(SEED);

inline int rand(int l, int r) {
    if (l > r) throw "invalid range";
    return l + rnd() % (r - l + 1);
}

bool multiedge = true;
bool onlyOddCircle = false;

int n = rand(99000, 100000);

vector<pair<int, int>> edges;
vector<vector<int>> son(n, vector<int>());
vector<int> dpt(n);

int dfs(int u) {
    int res = u;
    int cnt = 0;
    for (size_t i = 0; i < son[u].size(); ++i) {
        int v = son[u][i];
        dpt[v] = dpt[u] + 1;
        int t = dfs(v);
        if (rand(0, son[u].size()) == 0)
            res = t;
        else if ((t != v || (multiedge && cnt < 2)) && ((dpt[t] - dpt[u] + 1) % 2 == 1 || !onlyOddCircle))
            edges.emplace_back(u, t), cnt += t == v;
    }
    return res;
}

std::ostringstream odata;

const int QSIZE = 1e5;

namespace $yzh {
void build(istringstream&);
vector<pair<pair<int, int>, long long>> qrys;
}

int main() {
    for (int i = 1; i < n; ++i) {
        int fa = rand(0, i - 1);
        edges.emplace_back(fa, i);
        son[fa].emplace_back(i);
    }
    dfs(0);
    for (size_t i = 1; i < edges.size(); ++i) {
        swap(edges[i], edges[rand(0, i)]);
    }
    
    int QJ = 1;
    
    odata << QJ << endl;
    
    int m = edges.size();
    
    odata << n << ' ' << m << endl;
    
    for (int i = 1; i <= n; ++i) odata << rand(1, 3) << " \n"[i == n];
    
    for (size_t i = 0; i < edges.size(); ++i) {
        int u = edges[i].first;
        int v = edges[i].second;
        if (rand(0, 1)) swap(u, v);
        odata << u + 1 << ' ' << v + 1 << endl;
    }
    
    auto _ = istringstream(odata.str());
    $yzh::build(_);
    
    auto& Q = $yzh::qrys;
    int q = Q.size();
    for (int i = 1; i < q; ++i)
        swap(Q[i], Q[rand(0, i)]);
    
    odata << q << endl;
    
    std::ostringstream oans;
    
    long long lstans = 0;
    for (auto [_, ans] : Q) {
        long long u = _.first, k = _.second;
        if (QJ) u ^= lstans, k ^= lstans;
        odata << u << ' ' << k << endl;
        oans << ans << endl;
        lstans = ans;
    }
    
    FILE* f = fopen("testdata\\10.in", "w");
    fprintf(f, "%s", odata.str().c_str());
    fclose(f);
    
    f = fopen("testdata\\10.ans", "w");
    fprintf(f, "%s", oans.str().c_str());
    fclose(f);
    
    
    fprintf(stderr, "SEED = %d\n", SEED);
    fprintf(stderr, "circle = %d\n", (int)edges.size() - (n - 1));
    fprintf(stderr, "n = %d, m = %d, q = %d\n", n, m, q);
    
    return 0;
}

namespace $yzh {

const int N = 1e5 + 10;
const int M = N * 2;
const int NN = N * 2;

int n, m, q, c[N];

template <size_t _N, size_t _M>
class Graph {
public:
    Graph(): tot(1) {}
    struct node {
        int v, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v) {
        edge[++tot] = { v, head[u] };
        head[u] = tot;
    }
};

Graph<N, M << 1> G;
Graph<NN, NN> T;

namespace $build {

int dfn[N], low[N], timer;
int stack[N], top;
int dcc_cnt;

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                ++dcc_cnt;
                T.add(u, dcc_cnt + n);
                while (true) {
                    int x = stack[top--];
                    T.add(dcc_cnt + n, x);
                    if (x == v) break;
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
        }
    }
}

}

long long ans[N];

int dfn[NN], L[NN], R[NN], timer;
int siz[NN], son[NN];

void dfs(int u) {
    dfn[L[u] = ++timer] = u;
    siz[u] = 1;
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        dfs(v);
        siz[u] += siz[v];
        if (siz[v] > siz[son[u]])
            son[u] = v;
    }
    R[u] = timer;
}

namespace $yzh {

vector<pair<int, int>> qrys;

long long tr[N];
void modify(int p, int v) {
    for (; p; p &= p - 1)
        tr[p] += v;
}
long long query(int p) {
    long long res = 0;
    for (; p <= n; p += p & -p)
        res += tr[p];
    return res;
}

}

int cnt[N];

void add(int l, int r, int f) {
    for (int i = l; i <= r; ++i) {
        int u = dfn[i];
        if (u > n) continue;
        $yzh::modify(cnt[c[u]], -c[u]);
        $yzh::modify(cnt[c[u]] += f, c[u]);
    }
}

void redfs(int u) {
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        if (v == son[u]) continue;
        redfs(v);
        add(L[v], R[v], -1);
    }
    if (son[u]) redfs(son[u]);
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        if (v == son[u]) continue;
        add(L[v], R[v], 1);
    }
    add(L[u], L[u], 1);
    if (qrys.size() == QSIZE || u > n) return;
    int x = rand(0, 2);
    while (x) {
        int p = rand(1, 10);
        if ($yzh::query(p) == 0) continue;
        qrys.push_back({{ u, p }, $yzh::query(p) });
        --x;
        if (qrys.size() == QSIZE) return;
    }
}

void build(istringstream& is) {
    int o;
    is >> o;
    is >> n >> m;
    for (int i = 1; i <= n; ++i)
        is >> c[i];
    for (int i = 1, u, v; i <= m; ++i) {
        is >> u >> v;
        G.add(u, v), G.add(v, u);
    }
    $build::tarjan(1, 0);
    dfs(1);
    redfs(1);
}

}

分别以每个点为根求解

树上这类问题我们有 换根 DP 的做法，仙人掌上也可以类似做换根 DP。
例四、GAME on cactus（洛谷） Problem Statement

小 X 和小 Y 来到一棵 \(n\) 个点 \(m\) 条边的仙人掌上玩游戏，点编号为 \(1\sim n\)。

一开始某个节点上有个棋子，小 X 和小 Y 轮流移动这个棋子，已经走过的边不能再走，谁不能移动谁就输了。

小 Y 先手，她向你求助，对于每一个节点，若其作为初始放置棋子的节点，她是否有必胜策略？

\(2\leq n\leq2\times10^5\)。
Problem Analysis

见我的题解。
Solution Code

见我的题解。
Gen

#include <cstdio>
#include <iostream>
#include <vector>
#include <random>
#include <chrono>
using namespace std;

const int SEED = chrono::system_clock::now().time_since_epoch().count();

void _err(const char* msg, int lineNum) {
    fprintf(stderr, "Error at line #%d: %s\n", lineNum, msg);
    exit(1);
}
#define err(msg) _err(msg, __LINE__)

inline int rand(int l, int r) {
    static mt19937 rnd(SEED);
    if (l > r) err("invalid range");
    return l + rnd() % (r - l + 1);
}

vector<vector<int>> pts;
vector<pair<int, int>> edges;

int main() {
	int rem = rand(230990, 231000), o = 0;  // data may be wrong!
	int m = 0;
	pts.push_back({});
	while (rem > 0) {
		int x = rand(3, max(3, min(10, rem)));
		rem -= x;
		if (rem == 1) --rem, ++x;
		m++;
		vector<int> vec;
		if (m == 1) {
			for (int i = 1; i <= x; ++i)
				vec.emplace_back(++o);
		} else {
			int fa = rand(1, max(1, m - 20));
			auto& y = pts[fa];
			int t = rand(0, (int)y.size() - 1);
			vec.emplace_back(y[t]);
			for (int i = 2; i <= x; ++i)
			 	vec.emplace_back(++o);
		}
		for (int i = 2; i <= x; ++i)
			edges.emplace_back(vec[i - 2], vec[i - 1]);
		edges.emplace_back(vec[x - 1], vec[0]);
		pts.emplace_back(vec);
	}
	
	int n = o;
	
    vector<int> id(n);
    for (int i = 0; i < n; ++i) id[i] = i;
    for (int i = 1; i < n; ++i)
        swap(id[i], id[rand(0, i)]);
	
	for (size_t i = 1; i < edges.size(); ++i)
        swap(edges[i], edges[rand(0, i)]);
    
    printf("%d %d\n", o, (int)edges.size());
    for (size_t i = 0; i < edges.size(); ++i) {
        int u = edges[i].first;
        int v = edges[i].second;
        if (rand(0, 1)) swap(u, v);
        u = id[u - 1], v = id[v - 1];
        printf("%d %d\n", u + 1, v + 1);
    }
	
	return 0;
}

#include <cstdio>
#include <iostream>
#include <vector>
#include <random>
#include <chrono>
using namespace std;

/* =========== Parameter =========== */

const int SEED = chrono::system_clock::now().time_since_epoch().count();

bool multiedge = true;
bool onlyOddCircle = false;

int MULTI_P = 50;

/* =========== Parameter =========== */

void _err(const char* msg, int lineNum) {
    fprintf(stderr, "Error at line #%d: %s\n", lineNum, msg);
    exit(1);
}
#define err(msg) _err(msg, __LINE__)

inline int rand(int l, int r) {
    static mt19937 rnd(SEED);
    if (l > r) err("invalid range");
    return l + rnd() % (r - l + 1);
}

int n = rand(199990, 200000);
int LEN = rand(1314, 1324);

int m_limit = -1;  // -1 for not limit

vector<pair<int, int>> edges;
vector<vector<int>> son(n, vector<int>());
vector<int> dpt(n);

int maxcir = LEN;
int chong = 0;

void dfs(int u) {
    for (size_t i = 0; i < son[u].size(); ++i) {
        int v = son[u][i];
        dpt[v] = dpt[u] + 1;
        dfs(v);
    }
}

int redfs(int u, int ban, vector<int>& vec) {
    vec.emplace_back(u);
    int res = u;
    for (size_t i = 0; i < son[u].size(); ++i) {
        int v = son[u][i];
        if (v == ban) continue;
        int t = redfs(v, -1, vec);
        int len = dpt[t] - dpt[u] + 1;
        if ((t != v || (multiedge && rand(0, MULTI_P) == 0))
                && (len % 2 == 1 || !onlyOddCircle)
                && (m_limit == -1 || (int)edges.size() < m_limit))
            edges.emplace_back(u, t), maxcir = max(maxcir, len), chong += t == v;
        else if (/* res == u ||  */rand(0, son[u].size()) == 0 || dpt[t] > dpt[res])
            res = t;
    }
    return res;
}

int main() {
    // freopen(".\\testdata\\4.in", "w", stdout);
    
    // freopen("yzh", "w", stdout);
    // freopen("in", "w", stdout);
    
    if (n < 1) err("n shouldn't be less than 1");
    if (m_limit != -1 && m_limit < n - 1)
        err("m_limit shouldn't less than n-1");
    if (LEN > n)
        err("LEN too long");
    
    vector<int> id(n);
    for (int i = 0; i < n; ++i) id[i] = i;
    for (int i = 1; i < n; ++i)
        swap(id[i], id[rand(0, i)]);
    
    for (int i = 1; i < LEN; ++i) {
        int fa = i - 1;
        edges.emplace_back(fa, i);
        son[fa].emplace_back(i);
    }
    for (int i = LEN; i < n; ++i) {
        // int fa = rand(0, i - 1);
        int fa = rand(max(0, i - 20), i - 1);
        edges.emplace_back(fa, i);
        son[fa].emplace_back(i);
    }
    if (LEN > 1 && m_limit != n - 1) {
        edges.emplace_back(0, LEN - 1);
    }
    dfs(0);
    vector<int> son[n];
    for (int i = 1; i < LEN; ++i)
        redfs(i - 1, i, son[i - 1]);
    redfs(LEN - 1, -1, son[LEN - 1]);
    
    for (size_t i = 1; i < edges.size(); ++i)
        swap(edges[i], edges[rand(0, i)]);
    
    printf("%d %d\n", n, (int)edges.size());
    for (size_t i = 0; i < edges.size(); ++i) {
        int u = edges[i].first;
        int v = edges[i].second;
        if (rand(0, 1)) swap(u, v);
        u = id[u], v = id[v];
        printf("%d %d\n", u + 1, v + 1);
    }
    
    fprintf(stderr, "Success!\n");
    fprintf(stderr, "n = %d, m = %d\n", n, (int)edges.size());
    fprintf(stderr, "circle = %d\n", (int)edges.size() - (n - 1));
    fprintf(stderr, "maxcir = %d\n", maxcir);
    fprintf(stderr, "chong = %d\n", chong);
    return 0;
}

类型二：静态仙人掌，维护点对间所有简单路径信息

这类问题需要我们支持：修改点权或边权，询问点对之间路径上信息。
例五、仙人掌点对间最短路长度（【模板】静态仙人掌，洛谷） Problem Statement

给你一个有 \(n\) 个点和 \(m\) 条边的仙人掌，和 \(q\) 组询问，每次询问两点 \(u,v\) 间最短路长度。

\(n\leq 10^4\)，\(m\leq 2\times 10^4\)，\(q\leq 10^4\)。
Problem Analysis

属于「边权相关信息」，\(\odot=+\)，\(\oplus=\min\)，\(+\) 对 \(\min\) 有分配律，可以求解。

对于原子信息的求解，我们需要对每个点双维护总环长，对于每个圆点维护，他在他父亲方点代表的环中，到环首的距离。

对于前文提到过的不是环的点双，特殊处理成一个环即可。

于是，我们可以在 \(\mathcal{O}\Big(m+(n+q)\log n\Big)\) 或者长链剖分优化求 kth-father \(\mathcal{O}(n\log n + q+m)\) 的时间复杂度内求解问题。
Solution

均采用倍增维护树上信息。
正常圆方树，采用树上前缀和预处理信息

#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;

const int N = 1e4 + 10;
const int M = 2e4 + 10;
const int lg2N = __lg(N << 1) + 1;

int n, m, q;

template <size_t _N, size_t _M>
class Graph {
public:
    Graph(): tot(1) {}
    struct node {
        int v, w, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v, int w) {
        edge[++tot] = { v, w, head[u] };
        head[u] = tot;
    }
};

Graph<N, M << 1> G;
Graph<N << 1, N << 1> T;  // 圆方树

int dfn[N], low[N], timer;
int stack[N], top;

int pre[N];  // dfs 树的树上前缀和
int rev[N];  // 返祖边边权
int dis[N];  // 在父亲方点代表的点双中，到环首的距离

int dcc_cnt;
int cirsum[N];  // 环的总环长

inline int query(int u, int v, int x) {
    // u, v 在编号为 x 的点双中的距离
    int d = abs(dis[u] - dis[v]);
    return min(d, cirsum[x] - d);
}

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v, w = G.edge[i].w;
        if (!dfn[v]) {
            pre[v] = pre[u] + w;
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                ++dcc_cnt;
                cirsum[dcc_cnt] = pre[stack[top]] - pre[u] + rev[stack[top]];
                if (stack[top] == v)
                    cirsum[dcc_cnt] <<= 1;
                T.add(u, dcc_cnt + n, 0);
                while (true) {
                    int x = stack[top--];
                    dis[x] = pre[x] - pre[u];
                    T.add(dcc_cnt + n, x, min(dis[x], cirsum[dcc_cnt] - dis[x]));
                    if (x == v) break;
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
            if (dfn[v] < dfn[u])
                rev[u] = w;
        }
    }
}

int dpt[N << 1];
int fa[lg2N][N << 1];
int sum[lg2N][N << 1];

void dfs(int u) {
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v, w = T.edge[i].w;
        fa[0][v] = u;
        sum[0][v] = w;
        dpt[v] = dpt[u] + 1;
        dfs(v);
    }
}

int query(int u, int v) {
    int ans = 0;
    if (dpt[u] < dpt[v]) swap(u, v);
    for (int i = lg2N - 1; ~i; --i)
        if (fa[i][u] && dpt[fa[i][u]] >= dpt[v]) {
            ans += sum[i][u];
            u = fa[i][u];
        }
    if (u == v) return ans;
    for (int i = lg2N - 1; ~i; --i)
        if (fa[i][u] != fa[i][v]) {
            ans += sum[i][u] + sum[i][v];
            u = fa[i][u], v = fa[i][v];
        }
    // 此时 u,v 即为 u',v'
    int p = fa[0][u];  // lca
    if (p <= n)  // lca 为圆点
        ans += sum[0][u] + sum[0][v];  // 这一行其实没有作用，因为 sum[0][u]=sum[0][v]=0
    else
        ans += query(u, v, p - n);
    return ans;
}

int main() {
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1, u, v, w; i <= m; ++i) {
        scanf("%d%d%d", &u, &v, &w);
        G.add(u, v, w), G.add(v, u, w);
    }
    tarjan(1, 0);
    dfs(1);
    for (int k = 1; k < lg2N; ++k)
        for (int i = 1; i <= n + dcc_cnt; ++i) {
            fa[k][i] = fa[k - 1][fa[k - 1][i]];
            sum[k][i] = sum[k - 1][i] + sum[k - 1][fa[k - 1][i]];
        }
    for (int u, v; q--; ) {
        scanf("%d%d", &u, &v);
        printf("%d\n", query(u, v));
    }
    return 0;
}

正常圆方树，采用弹边栈预处理信息

#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;

const int N = 1e4 + 10;
const int M = 2e4 + 10;
const int lg2N = __lg(N << 1) + 1;

int n, m, q;

template <size_t _N, size_t _M>
class Graph {
public:
    Graph(): tot(1) {}
    struct node {
        int v, w, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v, int w) {
        edge[++tot] = { v, w, head[u] };
        head[u] = tot;
    }
};

Graph<N, M << 1> G;
Graph<N << 1, N << 1> T;  // 圆方树

int dfn[N], low[N], timer;
int stack[M], top;  // 注意这里的边栈的数组大小

int dis[N];  // 在父亲方点代表的点双中，到环首的距离

int dcc_cnt;
int cirsum[N];  // 环的总环长

inline int query(int u, int v, int x) {
    // u, v 在编号为 x 的点双中的距离
    int d = abs(dis[u] - dis[v]);
    return min(d, cirsum[x] - d);
}

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            stack[++top] = i;
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                static int tmp[N];
                int tot = 0;
                ++dcc_cnt;
                while (true) {
                    int j = stack[top--];
                    int uu = G.edge[j ^ 1].v;
                    int vv = G.edge[j].v;
                    int w = G.edge[j].w;
                    cirsum[dcc_cnt] += w;
                    if (j == i) break;
                    dis[uu] = dis[vv] + w;
                    tmp[++tot] = uu;
                }
                if (tot == 0) {
                    tmp[++tot] = v;
                    dis[v] = cirsum[dcc_cnt];
                    cirsum[dcc_cnt] <<= 1;
                }
                T.add(u, dcc_cnt + n, 0);
                for (int j = 1; j <= tot; ++j) {
                    int x = tmp[j];
                    T.add(dcc_cnt + n, x, min(dis[x], cirsum[dcc_cnt] - dis[x]));
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
            if (dfn[v] < dfn[u])
                stack[++top] = i;
        }
    }
}

int dpt[N << 1];
int fa[lg2N][N << 1];
int sum[lg2N][N << 1];

void dfs(int u) {
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v, w = T.edge[i].w;
        fa[0][v] = u;
        sum[0][v] = w;
        dpt[v] = dpt[u] + 1;
        dfs(v);
    }
}

int query(int u, int v) {
    int ans = 0;
    if (dpt[u] < dpt[v]) swap(u, v);
    for (int i = lg2N - 1; ~i; --i)
        if (fa[i][u] && dpt[fa[i][u]] >= dpt[v]) {
            ans += sum[i][u];
            u = fa[i][u];
        }
    if (u == v) return ans;
    for (int i = lg2N - 1; ~i; --i)
        if (fa[i][u] != fa[i][v]) {
            ans += sum[i][u] + sum[i][v];
            u = fa[i][u], v = fa[i][v];
        }
    // 此时 u,v 即为 u',v'
    int p = fa[0][u];  // lca
    if (p <= n)  // lca 为圆点
        ans += sum[0][u] + sum[0][v];  // 这一行其实没有作用，因为 sum[0][u]=sum[0][v]=0
    else
        ans += query(u, v, p - n);
    return ans;
}

int main() {
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1, u, v, w; i <= m; ++i) {
        scanf("%d%d%d", &u, &v, &w);
        G.add(u, v, w), G.add(v, u, w);
    }
    tarjan(1, 0);
    dfs(1);
    for (int k = 1; k < lg2N; ++k)
        for (int i = 1; i <= n + dcc_cnt; ++i) {
            fa[k][i] = fa[k - 1][fa[k - 1][i]];
            sum[k][i] = sum[k - 1][i] + sum[k - 1][fa[k - 1][i]];
        }
    for (int u, v; q--; ) {
        scanf("%d%d", &u, &v);
        printf("%d\n", query(u, v));
    }
    return 0;
}

不设置方点的圆树

#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;

const int N = 1e4 + 10;
const int M = 2e4 + 10;
const int lgN = __lg(N) + 1;

int n, m, q;

template <size_t _N, size_t _M>
class Graph {
public:
    Graph(): tot(1) {}
    struct node {
        int v, w, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v, int w) {
        edge[++tot] = { v, w, head[u] };
        head[u] = tot;
    }
};

Graph<N, M << 1> G;
Graph<N, N> T;  // 不设置方点的圆树

int dfn[N], low[N], timer;
int stack[N], top;

int pre[N];  // dfs 树的树上前缀和
int rev[N];  // 返祖边边权
int dis[N];  // 在父亲方点代表的点双中，到环首的距离

int dcc_cnt;
int cirsum[N];  // 环的总环长

int tfa[N];  // 父亲方点对应的点双编号

inline int query(int u, int v, int x) {
    // u, v 在编号为 x 的点双中的距离
    int d = abs(dis[u] - dis[v]);
    return min(d, cirsum[x] - d);
}

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v, w = G.edge[i].w;
        if (!dfn[v]) {
            pre[v] = pre[u] + w;
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                ++dcc_cnt;
                cirsum[dcc_cnt] = pre[stack[top]] - pre[u] + rev[stack[top]];
                if (stack[top] == v)
                    cirsum[dcc_cnt] <<= 1;
                while (true) {
                    int x = stack[top--];
                    dis[x] = pre[x] - pre[u];
                    tfa[x] = dcc_cnt;
                    T.add(u, x, min(dis[x], cirsum[dcc_cnt] - dis[x]));
                    if (x == v) break;
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
            if (dfn[v] < dfn[u])
                rev[u] = w;
        }
    }
}

int dpt[N];
int fa[lgN][N];
int sum[lgN][N];

void dfs(int u) {
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v, w = T.edge[i].w;
        fa[0][v] = u;
        sum[0][v] = w;
        dpt[v] = dpt[u] + 1;
        dfs(v);
    }
}

int query(int u, int v) {
    int ans = 0;
    if (dpt[u] < dpt[v]) swap(u, v);
    for (int i = lgN - 1; ~i; --i)
        if (fa[i][u] && dpt[fa[i][u]] >= dpt[v]) {
            ans += sum[i][u];
            u = fa[i][u];
        }
    if (u == v) return ans;
    for (int i = lgN - 1; ~i; --i)
        if (fa[i][u] != fa[i][v]) {
            ans += sum[i][u] + sum[i][v];
            u = fa[i][u], v = fa[i][v];
        }
    // 此时 u,v 即为 u',v'
    if (tfa[u] != tfa[v])
        ans += sum[0][u] + sum[0][v];  // 这一行现在就必要了
    else
        ans += query(u, v, tfa[u]);
    return ans;
}

int main() {
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1, u, v, w; i <= m; ++i) {
        scanf("%d%d%d", &u, &v, &w);
        G.add(u, v, w), G.add(v, u, w);
    }
    tarjan(1, 0);
    dfs(1);
    for (int k = 1; k < lgN; ++k)
        for (int i = 1; i <= n; ++i) {
            fa[k][i] = fa[k - 1][fa[k - 1][i]];
            sum[k][i] = sum[k - 1][i] + sum[k - 1][fa[k - 1][i]];
        }
    for (int u, v; q--; ) {
        scanf("%d%d", &u, &v);
        printf("%d\n", query(u, v));
    }
    return 0;
}

正常圆方树，使用 vector 处理信息

#include <cstdio>
#include <iostream>
#include <vector>
#include <cassert>
#include <algorithm>
using namespace std;

const int N = 1e4 + 10;
const int M = 2e4 + 10;
const int lg2N = __lg(N << 1) + 1;

int n, m, q;

template <size_t _N, size_t _M>
class Graph {
public:
    Graph(): tot(1) {}
    struct node {
        int v, w, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v, int w) {
        edge[++tot] = { v, w, head[u] };
        head[u] = tot;
    }
};

Graph<N, M << 1> G;
Graph<N << 1, N << 1> T;  // 圆方树

int dfn[N], low[N], timer;
int stack[N], top;

int pre[N];  // dfs 树的树上前缀和
int rev[N];  // 返祖边边权

vector<int> idx[N];
vector<int> dis[N];

int dcc_cnt;
int cirsum[N];  // 环的总环长

inline int query(int u, int v, int x) {
    // u, v 在编号为 x 的点双中的距离
    int ku = lower_bound(idx[u].begin(), idx[u].end(), x) - idx[u].begin();
    int kv = lower_bound(idx[v].begin(), idx[v].end(), x) - idx[v].begin();
    assert(idx[u][ku] == x && idx[v][kv] == x);
    int d = abs(dis[u][ku] - dis[v][kv]);
    return min(d, cirsum[x] - d);
}

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v, w = G.edge[i].w;
        if (!dfn[v]) {
            pre[v] = pre[u] + w;
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                ++dcc_cnt;
                cirsum[dcc_cnt] = pre[stack[top]] - pre[u] + rev[stack[top]];
                if (stack[top] == v)
                    cirsum[dcc_cnt] <<= 1;
                idx[u].push_back(dcc_cnt);
                dis[u].push_back(0);
                T.add(u, dcc_cnt + n, 0);
                while (true) {
                    int x = stack[top--];
                    idx[x].push_back(dcc_cnt);
                    dis[x].push_back(pre[x] - pre[u]);
                    T.add(dcc_cnt + n, x, query(u, x, dcc_cnt));
                    if (x == v) break;
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
            if (dfn[v] < dfn[u])
                rev[u] = w;
        }
    }
}

int dpt[N << 1];
int fa[lg2N][N << 1];
int sum[lg2N][N << 1];

void dfs(int u) {
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v, w = T.edge[i].w;
        fa[0][v] = u;
        sum[0][v] = w;
        dpt[v] = dpt[u] + 1;
        dfs(v);
    }
}

int query(int u, int v) {
    int ans = 0;
    if (dpt[u] < dpt[v]) swap(u, v);
    for (int i = lg2N - 1; ~i; --i)
        if (fa[i][u] && dpt[fa[i][u]] >= dpt[v]) {
            ans += sum[i][u];
            u = fa[i][u];
        }
    if (u == v) return ans;
    for (int i = lg2N - 1; ~i; --i)
        if (fa[i][u] != fa[i][v]) {
            ans += sum[i][u] + sum[i][v];
            u = fa[i][u], v = fa[i][v];
        }
    // 此时 u,v 即为 u',v'
    int p = fa[0][u];  // lca
    if (p <= n)  // lca 为圆点
        ans += sum[0][u] + sum[0][v];  // 这一行其实没有作用，因为 sum[0][u]=sum[0][v]=0
    else
        ans += query(u, v, p - n);
    return ans;
}

int main() {
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1, u, v, w; i <= m; ++i) {
        scanf("%d%d%d", &u, &v, &w);
        G.add(u, v, w), G.add(v, u, w);
    }
    tarjan(1, 0);
    dfs(1);
    for (int k = 1; k < lg2N; ++k)
        for (int i = 1; i <= n + dcc_cnt; ++i) {
            fa[k][i] = fa[k - 1][fa[k - 1][i]];
            sum[k][i] = sum[k - 1][i] + sum[k - 1][fa[k - 1][i]];
        }
    for (int u, v; q--; ) {
        scanf("%d%d", &u, &v);
        printf("%d\n", query(u, v));
    }
    return 0;
}

接下来看有修改的问题。

对于前文分析的特殊点权相关信息，由于其对于仙人掌的形态没有要求，所以将在无向图部分例题十四给出一种实现方式。
例六、BUY on cactus（洛谷） Problem Statement

小 Y 来到一棵 \(n\) 个点 \(m\) 条边的仙人掌上旅游，并希望通过买卖赚差价，点编号为 \(1\sim n\)。

在一次旅游时，她告诉你旅游的起点和终点 \(u,v\)。她会选择一条以 \(u,v\) 为端点的简单路径 ，并在路上选择一个结点 \(u'\)，花费 \(c_{u'}\) 的代价购入某个物品，再选择一个结点 \(v'\)，以 \(w_{v'}\) 的价格卖出，获得 \(w_{v'}-c_{u'}\) 的利润。显然她必须先购入才能卖出，但 \(u'\) 可以等于 \(v'\)。她不能啥也不做。小 Y 问你，在最优计划下，她能够获得的利润最大值，这个值可能为负。

由于这棵仙人掌很不稳定，每一个点的 \(c_u,w_u\) 都可能发生变化。你需要支持这种修改的同时，能够回答小 Y 的问题。具体来说，总共有 \(q\) 次修改或询问。

\(2\leq n\leq2\times10^5\)，\(1\leq q\leq 10^5\)。
Problem Analysis

购买类问题是十分经典的，我们就做过静态树上的问题：POJ-3728 The merchant。

需要维护的信息是什么？千万不要矩阵学傻了，说需要维护矩阵。我们可以维护三元组 \((\mathrm{mic},\mathrm{mxw},\mathrm{ans})\)，分别表示 minimum cost, maximum value and answer（最小花费、最大收益和路上的答案）。树上我们只需要考虑拼接两条简单路径的情况，有：

\\\begin{matrix} (\\mathrm{mic}_1,\\mathrm{mxw}_1,\\mathrm{ans}_1)+(\\mathrm{mic}_2,\\mathrm{mxw}_2,\\mathrm{ans}_2)\\\\ \\Downarrow\\\\ \\Big(\\min\\{\\mathrm{mic}_1,\\mathrm{mic}_2\\},\\max\\{\\mathrm{mxw}_1,\\mathrm{mxw}_2\\},\\max\\{\\mathrm{ans}_1,\\mathrm{ans}_2,\\mathrm{mxw}_2-\\mathrm{mic}_1\\}\\Big) \\end{matrix} \\

一步一步来看看这个模型怎么放到仙人掌上。

首先对于每一个环，可以拉下来变成一个序列，容易得到每一个点，通过左链和右链到环顶的两个信息，注意潜在的信息合并顺序问题。我们需要将这两个信息或起来，而不是上文的 \(+\) 运算：

\\\begin{matrix} (\\mathrm{mic}_1,\\mathrm{mxw}_1,\\mathrm{ans}_1)\\cup(\\mathrm{mic}_2,\\mathrm{mxw}_2,\\mathrm{ans}_2)\\\\ \\Downarrow\\\\ \\Big(\\min\\{\\mathrm{mic}_1,\\mathrm{mic}_2\\},\\max\\{\\mathrm{mxw}_1,\\mathrm{mxw}_2\\},\\max\\{\\mathrm{ans}_1,\\mathrm{ans}_2\\}\\Big) \\end{matrix} \\

我们于是可以得到它与方点父亲之间的边权，注意潜在的方向问题。

其实已经解决了整个问题。修改的时候修改重儿子，查询的时候跳重链，链顶轻儿子特殊查询。可以参考示例代码。

时间复杂度：\(\mathcal{O}(m+n\log n+q\log^2n)\)。单次修改 \(\mathcal{O}(\log n)\)，单次查询 \(\mathcal{O}(\log^2n)\)。
Solution

#include <cstdio>
#include <iostream>
#include <cstring>
#include <vector>
#include <cassert>
using namespace std;

const int N = 5e5 + 10;
const int M = 1e6 + 10;
const int N2 = N << 1;

const int inf = 0x3f3f3f3f;

int n, m, q;
int c[N], w[N];

struct node {
    int mic, mxw, a1, a2;
    void init(int c, int w) {
        mic = c, mxw = w;
        a1 = a2 = w - c;
    }
    void unit() {
        mic = inf, mxw = -inf;
        a1 = a2 = -inf;
    }
    friend inline node operator + (const node& a, const node& b) {
        node c;
        c.mic = min(a.mic, b.mic);
        c.mxw = max(a.mxw, b.mxw);
        c.a1 = max(a.a1, b.a1);
        c.a2 = max(a.a2, b.a2);
        c.a1 = max(c.a1, b.mxw - a.mic);
        c.a2 = max(c.a2, a.mxw - b.mic);
        return c;
    }
    friend inline node operator | (const node& a, const node& b) {
        node c;
        c.mic = min(a.mic, b.mic);
        c.mxw = max(a.mxw, b.mxw);
        c.a1 = max(a.a1, b.a1);
        c.a2 = max(a.a2, b.a2);
        return c;
    }
    inline node rev() const {
        return { mic, mxw, a2, a1 };
    }
};
inline node gen(int c, int w) {
    node r;
    r.init(c, w);
    return r;
}

template <size_t _N, size_t _M>
class Graph {
public:
    Graph(): tot(1) {}
    struct node {
        int v, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v) {
        edge[++tot] = { v, head[u] };
        head[u] = tot;
    }
};

Graph<N, M << 1> G;
Graph<N2, N2> T;

int dcc_cnt;

namespace $build {

int dfn[N], low[N], timer;
int stack[N], top;

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                ++dcc_cnt;
                T.add(u, dcc_cnt + n);
                while (true) {
                    int x = stack[top--];
                    T.add(dcc_cnt + n, x);
                    if (x == v) break;
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
        }
    }
}

}

class Segment_Tree {
private:
    struct _node {
        int ls, rs;
        node v;
    };
    vector<_node> buf;
    int n, rt[2], tot;
#define ls buf[u].ls
#define rs buf[u].rs
    inline void pushup(int u, bool f) {
        if (f)
            buf[u].v = buf[rs].v + buf[ls].v;
        else
            buf[u].v = buf[ls].v + buf[rs].v;
    }
    void _build(int& u, int l, int r, node val[], bool f) {
        u = ++tot;
        if (l == r) {
            if (f)
                buf[u].v = val[l].rev();
            else
                buf[u].v = val[l];
            return;
        }
        int mid = (l + r) >> 1;
        _build(ls, l, mid, val, f);
        _build(rs, mid + 1, r, val, f);
        pushup(u, f);
    }
    void _upd(int u, int l, int r, int p, node v, bool f) {
        if (l == r) {
            if (f)
                buf[u].v = v.rev();
            else
                buf[u].v = v;
            return;
        }
        int mid = (l + r) >> 1;
        if (p <= mid) _upd(ls, l, mid, p, v, f);
        else _upd(rs, mid + 1, r, p, v, f);
        pushup(u, f);
    }
    node query(int u, int trl, int trr, int l, int r) {
        if (l <= trl && trr <= r) return buf[u].v;
        int mid = (trl + trr) >> 1;
        if (r <= mid)
            return query(ls, trl, mid, l, r);
        if (l > mid)
            return query(rs, mid + 1, trr, l, r);
        return query(ls, trl, mid, l, r) + query(rs, mid + 1, trr, l, r);
    }
    node query_rev(int u, int trl, int trr, int l, int r) {
        if (l <= trl && trr <= r) return buf[u].v;
        int mid = (trl + trr) >> 1;
        if (r <= mid)
            return query_rev(ls, trl, mid, l, r);
        if (l > mid)
            return query_rev(rs, mid + 1, trr, l, r);
        return query_rev(rs, mid + 1, trr, l, r) + query_rev(ls, trl, mid, l, r);
    }
#undef ls
#undef rs
public:
    void build(int _n, node val[]) {
        n = _n, rt[0] = rt[1] = 0, tot = 0;
        buf.resize(n * 4 + 10);
        _build(rt[0], 1, n, val, 0);
        _build(rt[1], 1, n, val, 1);
    }
    void upd(int p, node v) {
        assert(1 <= p && p <= n);
        _upd(rt[0], 1, n, p, v, 0);
        _upd(rt[1], 1, n, p, v, 1);
    }
    node query(int l, int r) {
        assert(1 <= l && l <= r && r <= n);
        return query(rt[0], 1, n, l, r);
    }
    node query_rev(int l, int r) {
        assert(1 <= l && l <= r && r <= n);
        return query_rev(rt[1], 1, n, l, r);
    }
};

using tree_t = Segment_Tree;

int siz[N2], son[N2];
int fa[N2], top[N2], dpt[N2];
int idx[N2], dfn[N2], timer;
int bl[N], cir[N];

tree_t tr[N], yzh;

node getfa(int u) {
    int v = fa[u];
    assert(v != 0 && v > n);
    int m = cir[v - n];
    node L = tr[v - n].query(1, bl[u]);
    node R = tr[v - n].query_rev(bl[u], m);
    return L | R;
}

node getfa_rev(int u) {
    return getfa(u).rev();
}

node __val[N2];
void dfs(int u) {
    siz[u] = 1;
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        fa[v] = u;
        dpt[v] = dpt[u] + 1;
        dfs(v), siz[u] += siz[v];
        if (siz[v] > siz[son[u]])
            son[u] = v;
    }
    if (u > n) {
        static node tmp[N];
        int m = 0;
        for (int i = T.head[u]; i; i = T.edge[i].nxt) {
            int v = T.edge[i].v;
            tmp[++m].init(c[v], w[v]);
            bl[v] = m;
        }
        cir[u - n] = m;
        tr[u - n].build(m, tmp);
    }
}

void redfs(int u, int tp) {
    top[u] = tp;
    dfn[idx[u] = ++timer] = u;
    if (u == tp || u > n)
        __val[idx[u]].unit();
    else
        __val[idx[u]] = getfa(u);
    if (son[u]) redfs(son[u], tp);
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        if (v == son[u]) continue;
        redfs(v, v);
    }
}

node qcir(int u, int v) {
    assert(fa[u] == fa[v]);
    int p = fa[u];
    assert(p != 0 && p > n);
    assert(u != v);
    int bu = bl[u], bv = bl[v];
    int m = cir[p - n];
    if (bu <= bv) {
        node A = tr[p - n].query(bu, bv);
        node B = tr[p - n].query_rev(1, bu) + gen(c[fa[p]], w[fa[p]]) + tr[p - n].query_rev(bv, m);
        return A | B;
    } else {
        node A = tr[p - n].query_rev(bv, bu);
        node B = tr[p - n].query(bu, m) + gen(c[fa[p]], w[fa[p]]) + tr[p - n].query(1, bv);
        return A | B;
    }
}

int query(int u, int v) {
    int lu = 0, lv = 0;
    node L, R;
    L.unit(), R.unit();
    while (top[u] != top[v]) {
        if (dpt[top[u]] < dpt[top[v]]) {
            if (lv && lv <= n) R = getfa(lv) + R;
            R = yzh.query(idx[top[v]], idx[v]) + R;
            lv = top[v];
            v = fa[top[v]];
        } else {
            if (lu && lu <= n) L = L + getfa_rev(lu);
            L = L + yzh.query_rev(idx[top[u]], idx[u]);
            lu = top[u];
            u = fa[top[u]];
        }
    }
    if (u == v) {
        if (u <= n) {
            if (lu && lu <= n) L = L + getfa_rev(lu);
            if (lv && lv <= n) R = getfa(lv) + R;
            L = L + gen(c[u], w[u]);
        } else {
            assert(lu != 0 && lv != 0);
            L = L + qcir(lu, lv);
        }
    } else if (dpt[u] > dpt[v]) {
        if (v <= n) {
            if (lu && lu <= n) L = L + getfa_rev(lu);
            if (lv && lv <= n) R = getfa(lv) + R;
            L = L + yzh.query_rev(idx[v] + 1, idx[u]);
            L = L + gen(c[v], w[v]);
        } else {
            if (lu && lu <= n) L = L + getfa_rev(lu);
            assert(lv != 0);
            if (idx[v] + 2 <= idx[u])
                L = L + yzh.query_rev(idx[v] + 2, idx[u]);
            L = L + qcir(dfn[idx[v] + 1], lv);
        }
    } else {
        if (u <= n) {
            if (lu && lu <= n) L = L + getfa_rev(lu);
            if (lv && lv <= n) R = getfa(lv) + R;
            R = yzh.query(idx[u] + 1, idx[v]) + R;
            R = gen(c[u], w[u]) + R;
        } else {
            if (lv && lv <= n) R = getfa(lv) + R;
            assert(lu != 0);
            if (idx[u] + 2 <= idx[v])
                R = yzh.query(idx[u] + 2, idx[v]) + R;
            R = qcir(lu, dfn[idx[u] + 1]) + R;
        }
    }
    node ans = L + R;
    return ans.a1;
}

void modify(int u, int v, int t) {
    if (t == 0) c[u] = v;
    else w[u] = v;
    if (u != 1) {
        int p = fa[u];
        tr[p - n].upd(bl[u], gen(c[u], w[u]));
        int x = son[p];
        yzh.upd(idx[x], getfa(x));
    }
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1, u, v; i <= m; ++i) {
        scanf("%d%d", &u, &v);
        G.add(u, v), G.add(v, u);
    }
    for (int i = 1; i <= n; ++i)
        scanf("%d", &c[i]);
    for (int i = 1; i <= n; ++i)
        scanf("%d", &w[i]);
    $build::tarjan(1, 0);
    dfs(1);
    redfs(1, 1);
    yzh.build(n + dcc_cnt, __val);
    scanf("%d", &q);
    for (int op, u, v, t; q--; ) {
        scanf("%d%d%d", &op, &u, &v);
        if (op == 1) {
            printf("%d\n", query(u, v));
        } else {
            scanf("%d", &t);
            modify(u, v, t);
        }
    }
    return 0;
}

Gen

#include <cstdio>
#include <iostream>
#include <vector>
#include <random>
#include <chrono>
using namespace std;

/* =========== Parameter =========== */

const int SEED = chrono::system_clock::now().time_since_epoch().count();

bool multiedge = true;
bool onlyOddCircle = false;

int MULTI_P = 50;

/* =========== Parameter =========== */

void _err(const char* msg, int lineNum) {
    fprintf(stderr, "Error at line #%d: %s\n", lineNum, msg);
    exit(1);
}
#define err(msg) _err(msg, __LINE__)

inline int rand(int l, int r) {
    static mt19937 rnd(SEED);
    if (l > r) err("invalid range");
    return l + rnd() % (r - l + 1);
}

int n = rand(199990, 200000);
int q = rand(99990, 100000);
int LEN = rand(13140, 23240);

int m_limit = -1;  // -1 for not limit

vector<pair<int, int>> edges;
vector<vector<int>> son(n, vector<int>());
vector<int> dpt(n);

int maxcir = LEN;
int chong = 0;

void dfs(int u) {
    for (size_t i = 0; i < son[u].size(); ++i) {
        int v = son[u][i];
        dpt[v] = dpt[u] + 1;
        dfs(v);
    }
}

int redfs(int u, int ban, vector<int>& vec) {
    vec.emplace_back(u);
    int res = u;
    for (size_t i = 0; i < son[u].size(); ++i) {
        int v = son[u][i];
        if (v == ban) continue;
        int t = redfs(v, -1, vec);
        int len = dpt[t] - dpt[u] + 1;
        if ((t != v || (multiedge && rand(0, MULTI_P) == 0))
                && (len % 2 == 1 || !onlyOddCircle)
                && (m_limit == -1 || (int)edges.size() < m_limit))
            edges.emplace_back(u, t), maxcir = max(maxcir, len), chong += t == v;
        else if (rand(0, son[u].size()) == 0 || dpt[t] > dpt[res])
            res = t;
    }
    return res;
}

int main() {
    freopen(".\\testdata\\10.in", "w", stdout);
    
    // freopen("yzh", "w", stdout);
    // freopen("in", "w", stdout);
    
    if (n < 1) err("n shouldn't be less than 1");
    if (m_limit != -1 && m_limit < n - 1)
        err("m_limit shouldn't less than n-1");
    if (LEN > n)
        err("LEN too long");
    
    vector<int> id(n);
    for (int i = 0; i < n; ++i) id[i] = i;
    for (int i = 1; i < n; ++i)
        swap(id[i], id[rand(0, i)]);
    
    for (int i = 1; i < LEN; ++i) {
        int fa = i - 1;
        edges.emplace_back(fa, i);
        son[fa].emplace_back(i);
    }
    for (int i = LEN; i < n; ++i) {
        // int fa = rand(0, i - 1);
        int fa = rand(max(0, i - 20), i - 1);
        edges.emplace_back(fa, i);
        son[fa].emplace_back(i);
    }
    if (LEN > 1 && m_limit != n - 1) {
        edges.emplace_back(0, LEN - 1);
    }
    dfs(0);
    vector<int> son[n];
    for (int i = 1; i < LEN; ++i)
        redfs(i - 1, i, son[i - 1]);
    redfs(LEN - 1, -1, son[LEN - 1]);
    
    for (size_t i = 1; i < edges.size(); ++i)
        swap(edges[i], edges[rand(0, i)]);
    
    printf("%d %d\n", n, (int)edges.size());
    for (size_t i = 0; i < edges.size(); ++i) {
        int u = edges[i].first;
        int v = edges[i].second;
        if (rand(0, 1)) swap(u, v);
        u = id[u], v = id[v];
        printf("%d %d\n", u + 1, v + 1);
    }
    
    const int V = 5e8;
    
    for (int i = 1; i <= n; ++i)
        printf("%d%c", rand(-V, V), " \n"[i == n]);
    for (int i = 1; i <= n; ++i)
        printf("%d%c", rand(-V, V), " \n"[i == n]);
    
    printf("%d\n", q);
    for (int i = 1; i <= q; ++i) {
        int op = rand(1, 2);
        if (op == 1) {
            if (rand(0, 100) == 0) {
                int u = rand(1, n);
                int v = rand(1, n);
                printf("1 %d %d\n", u, v);
            } else {
                int uu = rand(0, LEN - 1 - 1);
                int vv = rand(uu + 1, LEN - 1);
                int u = son[uu][rand(0, (int)son[uu].size() - 1)];
                int v = son[vv][rand(0, (int)son[vv].size() - 1)];
                u = id[u] + 1;
                v = id[v] + 1;
                printf("1 %d %d\n", u, v);
            }
        } else {
            int u = rand(1, n);
            int v = rand(-V, V);
            int t = rand(0, 1);
            printf("2 %d %d %d\n", u, v, t);
        }
    }
    
    fprintf(stderr, "Success!\n");
    fprintf(stderr, "n = %d, m = %d\n", n, (int)edges.size());
    fprintf(stderr, "circle = %d\n", (int)edges.size() - (n - 1));
    fprintf(stderr, "maxcir = %d\n", maxcir);
    fprintf(stderr, "chong = %d\n", chong);
    return 0;
}

类型三：静态仙人掌，支持维护链和子仙人掌

回想我们树上树链剖分可以支持什么操作？树链、子树修改，树链、子树查询。那么由于仙人掌具有一定树的形态，我们也可以将仙人掌剖分，实现长链（短链）修改、子仙人掌查询。接下来考虑的信息均是点权。

回顾我们是如何定义仙人掌上的链的，以及不要忘记，在仙人掌中每经过一个奇环时，若始终选择在环上走最长（或最短）的路径，则整条走出的路径即为 \(u, v\) 间的长链（或短链）。

我们不妨先只考虑如何修改 \(u,v\) 间的长链。拆解问题，如果 \(p=\operatorname{lca}(u,v)\) 是个圆点，相当于修改 \(u\rightarrow p\) 和 \(p\rightarrow v\) 两条长链；否则 \(p\) 为方点，除了 \(u\rightarrow u'\) 和 \(v'\rightarrow v\) 这两个和 \(p\) 为圆点时形式相同的子问题，还有一个环上 \(u'\rightarrow v'\) 最长路的问题。

先考虑如何修改一对具有祖先关系的 \(u,v\) 之间的长链。树链剖分后，在圆方树上跳一段重链时，DFS 序上对应的连续一段区间为圆方树上这条重链。树上我们需要的正是一段连续的区间，因为这样我们就可以用数据结构来维护了，但在仙人掌上，这是不对的，我们要修改的不是这样一条圆方交错的圆方树树链，而是需要修改仙人掌上长链的每一个点。

我们不妨修改一下这个 DFS 序，使得对于这样连续一段区间，完整包含了我们需要修改的点。并且显然我们不需要方点出现在 DFS 序上，因为它身上没有我们需要维护的信息。

对于方点，我们先把其轻儿子放到 DFS 序后面，再放其重儿子，接着处理重儿子的子仙人掌，最后处理其他轻儿子的子仙人掌。从 DFS 序的角度上考虑，相当于把一个方点替换成了它的所有轻孩子，那么这个方点对应的环就完整地出现在了我们的区间上。

举个例子，比如 \(1\sim 9\) 这条重链，原先 DFS 序上对应区间为 \(1,7=\{1,16,2,15,5,14,9\}\)。而在修改后，方点 \(15\) 变为了其所有轻儿子 \(\{11,4,3\}\)，\(14\) 同理变成了 \(6\)，修改后的 DFS 序对应区间为 \(1,8=\{1,2,11,4,3,5,6,9\}\)，涵盖了 \(1\sim 9\) 长链上的所有点 \(\{1,2,3,4,5,6,9\}\)。

完整包含了还不够，我们还需要能够精准的修改想要修改的点。例如，例子中 \(11\) 点出现在了区间上，而它不在 \(1\sim 9\) 的长链上，这等价于它不在 \(2\sim 5\) 环上最长路径上。由于重儿子的唯一性，这启示我们将一个方点的所有轻儿子分类，分为「在重儿子到父亲圆点（原图上）的最长路上」和「在重儿子到父亲圆点（原图上）的最短路上」两种类型，这是方便处理出来的。例如，\(11\) 属于后者，而 \(3,4\) 属于前者。现在我们区间上有三种类型的圆点，因为不要忘了重儿子也是一种圆点。每次我们只需要将对应类型的轻孩子，和所有重儿子修改就行了。这个是可以用线段树维护的。

至此，我们通过修改 DFS 序，和使用线段树的区间分类修改操作，完成了「修改一段重链对应原仙人掌上的长 / 短链」。

仔细思考一下，在将其推广到一对具有祖孙关系的节点的链修改时，还有细节没有处理。重链拆分后，对于 \(v\rightarrow u\) 这条重链（\(v\) 是链顶），当 \(u\) 为圆点且 \(v\) 为方点时，根据上面讨论，对应区间为 \(v\) 第一个轻儿子在 DFS 序的位置，到 \(u\) 在 DFS 序中的位置。当 \(v\) 也为圆点时，我们不能将区间左端点设为 \(v\) 在 DFS 序中的位置，如下图：

它的 DFS 序如下：

\x_3,\\colorbox{#409eff}{$ (x_5) $},\\colorbox{#409eff}{$ x_4,v,x_1,x_2,\\colorbox{#e6a23c}{$ (x_2) $},\\colorbox{#e6a23c}{$ (x_4) $},\\colorbox{#e6a23c}{$ ...,u $},\\colorbox{#e6a23c}{$ (x_1) $} $} \\

如果我们取出的区间为：

\v,x_1,x_2,\\colorbox{#e6a23c}{$ (x_2) $},\\colorbox{#e6a23c}{$ (x_4) $},\\colorbox{#e6a23c}{$ ...,u $} \\

就会出错，因为包含了 \((x_2),(x_4)\) 这两个无关的子仙人掌对应的区间，以及 \(x_1,x_2\) 不一定就是我们需要修改的点，如果我们需要修改长链，就需要修改 \(x_4\)，而它却没有出现在我们取出的区间上。

我们可以特殊处理。对于 \(...,u\)，这是链顶为方点的情况，正常处理即可。剩下就是在 \(w\) 对应的环上，修改 \(v\sim x_3\) 的长链 / 短链，这和 LCA 处的问题形式相同。接下来，我们就可以在 \(x_3\) 继续往上跳重链。

如果 \(u\) 为方点呢？注意到，我们上述过程实际保证了 \(u\) 时刻为圆点，就不需要考虑 \(u\) 为方点的情况了。

我们已经可以「修改一对具有祖孙关系 \(v,u\) 间的长 / 短链」。在修改过的 DFS 序上，考虑能不能支持 LCA 处的操作，即修改环上一段连续的链。

以上图为例，我们假设这个点双对应的方点为 \(u\)，\(u\) 的父亲圆点为 \(1\)，重儿子为 \(5\)。按照我们上面的定义，\(2,3,4\) 在 \(5\) 到 \(1\) 的最长路上，是一类轻儿子，\(6,7\) 则是另一类轻儿子。这个环对应 DFS 序可以为 \(1,{\color{red}7},{\color{yellow}2},{\color{yellow}4},{\color{red}6},{\color{yellow}3},5\)，也可以为 \(1,{\color{red}7},{\color{red}6},{\color{yellow}2},{\color{yellow}3},{\color{yellow}4},5\) 或者 \(1,{\color{yellow}4},{\color{yellow}3},{\color{yellow}2},{\color{red}6},{\color{red}7},5\)，上述三种 DFS 序都是符合目前我们要求的，但是为了解决 LCA 处的问题，我们需要环上连续一段链在 DFS 序上被拆分为 \(\mathcal{O}(1)\) 个区间，也就希望 DFS 序为后两者，或类似后两者的形态。很容易在类似后两种 DFS 序的形态中，拆出我们想要的区间。例如考虑 DFS 为 \(1,{\color{red}7},{\color{red}6},{\color{yellow}2},{\color{yellow}3},{\color{yellow}4},5\)，那么 \(3\rightarrow7\) 的长链为 \(3,4,5,6,7\)，对应 DFS 序区间是 \(5,6\cup7,7\cup2,3\)。

剩下只有子仙人掌操作没有解决了，但是我们惊讶地发现，在修改后的 DFS 序上，在一定程度上很好地保留了 DFS 序一段区间对应子树这个性质，而子仙人掌就是圆方树的子树。具体来说，我们发现 \(u\) 的子仙人掌被拆分成了两部分，一部分是 \(u\) 本身这个点，另一部分为它的不包括本身的子仙人掌。那么只需要分别查询这两段区间的信息就行了。

对于代码实现上的细节，请参考例题代码。时间复杂度瓶颈在于线段树。
例七、【清华集训2015】静态仙人掌（UOJ） Problem Statement

一棵 \(n\) 个点、\(m\) 条边的仙人掌，指定 \(1\) 为根。每个结点有一个颜色（黑或白），初始时均为黑色。有 \(q\) 次操作：

1. 将 \(u\) 到根的最短路径 / 最长路径上所有点的颜色取反。
2. 询问点 \(u\) 子仙人掌中的黑点数目。

\(n,q\leq 5\times10^4\)。
Problem Analysis

问题严格弱于前文的分析的模型，可以用线段树方便维护。可以参考示例代码的具体实现。

时间复杂度：\(\mathcal{O}((n+q)\log n)\)。
Solution

#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;

const int N = 5e4 + 10;
const int M = 1e5 + 10;
const int N2 = N << 1;

int n, m, q;

template <size_t _N, size_t _M>
class Graph {
public:
    Graph(): tot(1) {}
    struct node {
        int v, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v) {
        edge[++tot] = { v, head[u] };
        head[u] = tot;
    }
};

Graph<N, M << 1> G;
Graph<N2, N2> T;

int dcc_cnt;

namespace $build {

int dfn[N], low[N], timer;
int stack[N], top;

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                ++dcc_cnt;
                T.add(u, dcc_cnt + n);
                while (true) {
                    int x = stack[top--];
                    T.add(dcc_cnt + n, x);
                    if (x == v) break;
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
        }
    }
}

}

int siz[N2], son[N2];
int fa[N2], top[N2];
int dfn[N], idx[N], L[N2], R[N2], timer;
int dis[N2], typ[N];
/*
dfn：修改后的 DFS 序
对于圆点：
    idx[u]：在 DFS 序上位置
    L[u]~R[u]：子树（不包括本身）在 DFS 序上的一段区间，或 L[u]=R[u]+1 为空
    dis[u]：环上到环首距离
    typ[u]：类型，0 为重儿子，1 为
对于方点：
    L[u]~R[u]：孩子（轻儿子和重儿子）在 DFS 序上的一段区间
    dis[u]：总环长
*/

void dfs(int u) {
    siz[u] = 1;
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        fa[v] = u;
        dfs(v), siz[u] += siz[v];
        if (siz[v] > siz[son[u]])
            son[u] = v;
    }
}

void redfs(int u, int tp) {
    top[u] = tp;
    if (u <= n) {
        L[u] = timer + 1;
        if (son[u]) redfs(son[u], tp);
        for (int i = T.head[u]; i; i = T.edge[i].nxt) {
            int v = T.edge[i].v;
            if (v == son[u]) continue;
            redfs(v, v);
        }
        R[u] = timer;
    } else {
        for (int i = T.head[u]; i; i = T.edge[i].nxt) {
            int v = T.edge[i].v;
            dis[v] = ++dis[u];
        }
        ++dis[u];
        L[u] = timer + 1;
        int t = dis[son[u]] <= dis[u] / 2 ? 1 : 2;
        for (int i = T.head[u]; i; i = T.edge[i].nxt) {
            int v = T.edge[i].v;
            if (v == son[u]) t ^= 3;
            else {
                dfn[idx[v] = ++timer] = v;
                typ[v] = t;
            }
        }
        R[u] = timer;
        dfn[idx[son[u]] = ++timer] = son[u];
        typ[son[u]] = 0;
        redfs(son[u], tp);
        for (int i = T.head[u]; i; i = T.edge[i].nxt) {
            int v = T.edge[i].v;
            if (v == son[u]) continue;
            redfs(v, v);
        }
    }
}

namespace $tree {

#define lson (idx << 1)
#define rson (idx << 1 | 1)

struct node {
    int tot[3], val[3];
    bool lazy[3];
} tr[N2 << 2];

void build(int idx, int l, int r) {
    if (l == r) {
        int u = dfn[l];
        if (u <= n) {
            int t = typ[u];
            tr[idx].tot[t] = tr[idx].val[t] = 1;
        }
        return;
    }
    int mid = (l + r) >> 1;
    build(lson, l, mid);
    build(rson, mid + 1, r);
    for (int i = 0; i < 3; ++i) {
        tr[idx].tot[i] = tr[lson].tot[i] + tr[rson].tot[i];
        tr[idx].val[i] = tr[lson].val[i] + tr[rson].val[i];
    }
}

inline void pushtag(int idx, int o) {
    tr[idx].lazy[o] ^= 1;
    tr[idx].val[o] = tr[idx].tot[o] - tr[idx].val[o];
}

inline void pushdown(int idx) {
    for (int o = 0; o < 3; ++o) {
        if (!tr[idx].lazy[o]) continue;
        pushtag(lson, o);
        pushtag(rson, o);
        tr[idx].lazy[o] = 0;
    }
}

void modify(int idx, int trl, int trr, int l, int r, int o) {
    if (l > r) throw;
    if (l <= trl && trr <= r) {
        if (o == 0) {
            for (int i = 0; i < 3; ++i) pushtag(idx, i);
        } else
            pushtag(idx, o), pushtag(idx, 0);
        return;
    }
    pushdown(idx);
    int mid = (trl + trr) >> 1;
    if (l <= mid) modify(lson, trl, mid, l, r, o);
    if (r >  mid) modify(rson, mid + 1, trr, l, r, o);
    for (int i = 0; i < 3; ++i)
        tr[idx].val[i] = tr[lson].val[i] + tr[rson].val[i];
}

int query(int idx, int trl, int trr, int l, int r) {
    if (l > r) throw;
    if (l <= trl && trr <= r)
        return tr[idx].val[0] + tr[idx].val[1] + tr[idx].val[2];
    pushdown(idx);
    int mid = (trl + trr) >> 1;
    if (r <= mid) return query(lson, trl, mid, l, r);
    if (l >  mid) return query(rson, mid + 1, trr, l, r);
    return query(lson, trl, mid, l, r) + query(rson, mid + 1, trr, l, r);
}

#undef lson
#undef rson

}

void modify(int u, int op) {
    // 在跳重链的时候，需要时刻保持 u 为圆点，这是为了简化讨论
    while (top[u] != 1) {
        int v = top[u];
        if (v > n) {
            $tree::modify(1, 1, n, L[v], idx[u], op);
            u = fa[v];
        } else {
            if (u != v)
                $tree::modify(1, 1, n, L[son[v]], idx[u], op);
            u = fa[v];
            int o = dis[v] <= dis[u] / 2 ? 1 : 2;
            if (o == op) {
                $tree::modify(1, 1, n, L[u], idx[v], 0);
                if (dis[son[u]] <= dis[v])
                    $tree::modify(1, 1, n, idx[son[u]], idx[son[u]], 0);
            } else {
                $tree::modify(1, 1, n, idx[v], R[u], 0);
                if (dis[son[u]] >= dis[v])
                    $tree::modify(1, 1, n, idx[son[u]], idx[son[u]], 0);
            }
            u = fa[u];
        }
    }
    $tree::modify(1, 1, n, idx[1], idx[u], op);
}

int query(int u) {
    int res = 0;
    res += $tree::query(1, 1, n, idx[u], idx[u]);
    if (L[u] <= R[u])
        res += $tree::query(1, 1, n, L[u], R[u]);
    return res;
}

int main() {
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1, u, v; i <= m; ++i) {
        scanf("%d%d", &u, &v);
        G.add(u, v), G.add(v, u);
    }
    $build::tarjan(1, 0);
    dfs(1);
    dfn[idx[1] = ++timer] = 1;
    redfs(1, 1);
    $tree::build(1, 1, n);
    for (int op, u; q--; ) {
        scanf("%d%d", &op, &u);
        if (op <= 2) modify(u, op);
        else printf("%d\n", query(u));
    }
    return 0;
}

类型四：静态仙人掌，求给定点集的整体信息

这类问题每次询问会给出一个点集，求这个点集的整体信息，比如统计一些东西，做一些 DP 什么的，类似于类型一，只不过只关于点集中的点了。

对于树上给定点集的问题，我们可以建出这些点的虚树，在虚树上统计答案，做树形 DP。由于点集 \(S\) 对应虚树结点个数是 \(\mathcal{O}(|S|)\) 的，时间复杂度得到了保证。

唯一需要注意的是，对于方点 \(u\)，其虚树上一个孩子 \(v\)，那么不能想当然地认为 \(v\) 是 \(u\) 的孩子圆点，事实上，\(v\) 并不一定是其孩子圆点，甚至连个圆点都可能不是。所以，我们需要通过一些方法求出 \(v'\)，这个才是 \(u\) 的孩子圆点。
例八、mx 的仙人掌（UOJ） Problem Statement

一棵 \(n\) 个点、\(m\) 条边的仙人掌。

\(q\) 此询问，每次给出一个点集 \(S\)。求出从 \(S\) 中选出两个点 \(u,v\)，他们之间最短路的最大值是多少，\(u,v\) 可以相同。

\(n,\sum|S|\leq3\times10^5\)。
Problem Analysis

每次可以 \(\mathcal{O}(n)\) 类似类型一求直径，做一遍圆方树上的树形 DP。

那么先把虚树建出来。然后考虑在 LCA 处统计答案，即枚举 LCA \(p\)，考虑它两个孩子的子树中的点 \(u,v\) 对答案的贡献。分 \(p\) 为方点、圆点讨论。

1. \(p\) 为圆点：
   此时 \(u,v\) 之间的最短路即为 \(s_u+s_v-2s_p\)，其中 \(s_u\) 表示圆方树边权的树上前缀和。我们只需要求出 \(s_u+s_v\) 的最大值。这个很容易，对于每个点 \(u\) 维护 \(f_u\) 表示子树中 \(s_u\) 的最大值，然后就可以统计了。
2. \(p\) 为方点：
   设 \(u',v'\) 表示 \(p\) 在圆方树上两个孩子，对应为 \(u,v\) 的祖先。\(u',v'\) 可以 kth-kather 求出。此时 \(u,v\) 之间的最短路为 \(s_u-s_{u'}+s_v-s_{v'} + \min\{|d_{v'}-d_{u'}|,\operatorname{sum}(p)-|d_{v'}-d_{u'}|\}\)，其中 \(\operatorname{sum}(p)\) 表示方点 \(p\) 对应的环的总长，\(d_u\) 表示 \(u\) 到环首的距离。相当于 \(p\) 的每个孩子 \(u\) 有一个点权 \(w_u=f_u-s_u\)，要求 \(\max\limits_{u,v\in\operatorname{son}(p)}\Bigg\{w_u+w_v + \min\Big\{|d_v-d_u|,\operatorname{sum}(p)-|d_v-d_u|\Big\}\Bigg\}\)，这个可以拆换成链，再复制一份接在后面，然后就能单调队列做了。

时间复杂度为：\(\mathcal{O}(m+n\log n+\sum|S|(\log|S|+\log n))\)。
Solution

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

using ll = long long;

const int N = 3e5 + 10;
const int M = N * 3 + 10;
const int NN = N << 1;
const int lg2N = __lg(NN) + 1;

int n, m, q;

template <size_t _N, size_t _M, typename T>
class Grpah {
public:
    Grpah(): tot(1) {}
    struct node {
        int v, nxt;
        T w;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v, const T& w) {
        edge[++tot] = { v, head[u], w };
        head[u] = tot;
    }
};
Grpah<N, M << 1, int> G;  // original grpah
Grpah<N << 1, N << 1, ll> T;  // rebuild tree

template <size_t _N, size_t _M>
class Graph_ {
public:
    Graph_(): tot(1) {}
    struct node {
        int v, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v) {
        edge[++tot] = { v, head[u] };
        head[u] = tot;
    }
};
Graph_<N << 1, N << 1> VT;  // virtual tree

int dcc_cnt;
ll cirsum[N], dis[N];

namespace $build {

int dfn[N], low[N], timer;
int stack[M], top;  // 注意这里的边栈的数组大小

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            stack[++top] = i;
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                static int tmp[N];
                int tot = 0;
                ++dcc_cnt;
                while (true) {
                    int j = stack[top--];
                    int uu = G.edge[j ^ 1].v;
                    int vv = G.edge[j].v;
                    int w = G.edge[j].w;
                    cirsum[dcc_cnt] += w;
                    if (j == i) break;
                    dis[uu] = dis[vv] + w;
                    tmp[++tot] = uu;
                }
                if (tot == 0) {
                    tmp[++tot] = v;
                    dis[v] = cirsum[dcc_cnt];
                    cirsum[dcc_cnt] <<= 1;
                }
                T.add(u, dcc_cnt + n, 0);
                for (int j = 1; j <= tot; ++j) {
                    int x = tmp[j];
                    T.add(dcc_cnt + n, x, min(dis[x], cirsum[dcc_cnt] - dis[x]));
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
            if (dfn[v] < dfn[u])
                stack[++top] = i;
        }
    }
}

}

int dpt[NN], fa[NN], timer, kthfa[lg2N][NN];
int idx[NN], st[lg2N][NN];
ll sum[NN];  // tree prefix sum

void dfs(int u) {
    st[0][idx[u] = ++timer] = u;
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        ll w = T.edge[i].w;
        dpt[v] = dpt[u] + 1;
        fa[v] = kthfa[0][v] = u;
        sum[v] = sum[u] + w;
        dfs(v);
    }
}
inline int Min(int a, int b) {
    return dpt[a] < dpt[b] ? a : b;
}
inline int lca(int u, int v) {
    if (u == v) return u;
    if ((u = idx[u]) > (v = idx[v])) swap(u, v);
    int k = __lg(v - u++);
    return fa[Min(st[k][u], st[k][v - (1 << k) + 1])];
}
inline int jump(int u, int k) {
    for (int i = lg2N - 1; ~i; --i)
        if (k & 1 << i) u = kthfa[i][u];
    return u;
}

ll ans, f[NN];
int bl[NN];  // 设 v 为 u 在虚树上的父亲，bl[u] 为 v 的一个在圆方树上的孩子，且为 u 的祖先

void redfs(int u) {
    f[u] = sum[u];
    if (u <= n) {
        for (int i = VT.head[u]; i; i = VT.edge[i].nxt) {
            int v = VT.edge[i].v;
            redfs(v);
            ans = max(ans, f[v] + f[u] - 2 * sum[u]);
            f[u] = max(f[u], f[v]);
        }
    } else {
        for (int i = VT.head[u]; i; i = VT.edge[i].nxt) {
            int v = VT.edge[i].v;
            redfs(v);
            f[u] = max(f[u], f[v]);
        }
        // do algorithm after dfs!
        static int son[N];
        static ll d[NN], w[NN];
        static int Q[NN];
        int cnt = 0;
        for (int i = VT.head[u]; i; i = VT.edge[i].nxt) {
            int v = VT.edge[i].v;
            son[++cnt] = v;
        }
        sort(son + 1, son + cnt + 1, [] (int a, int b) {
            return dis[bl[a]] < dis[bl[b]];
        });
        ll tot = cirsum[u - n];
        for (int i = 1; i <= cnt; ++i) {
            int v = son[i];
            int tv = bl[v];
            d[i] = dis[tv];
            w[i] = f[v] - sum[tv];
            d[cnt + i] = d[i] + tot;
            w[cnt + i] = w[i];
        }
        int head = 0, tail = -1;
        for (int i = 1; i <= cnt << 1; ++i) {
            while (head <= tail && d[Q[head]] < d[i] - tot/2) ++head;
            if (head <= tail) ans = max(ans, w[Q[head]] + w[i] + d[i] - d[Q[head]]);
            while (head <= tail && w[Q[tail]] - d[Q[tail]] <= w[i] - d[i]) --tail;
            Q[++tail] = i;
        }
        
        // for (int i = 1; i <= cnt; ++i)
        //     for (int j = i + 1; j <= cnt; ++j) {
        //         ll D = abs(d[i] - d[j]);
        //         ans = max(ans, w[i] + w[j] + min(D, tot - D));
        //     }
    }
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1, u, v, w; i <= m; ++i) {
        scanf("%d%d%d", &u, &v, &w);
        G.add(u, v, w);
        G.add(v, u, w);
    }
    $build::tarjan(1, 0);
    dfs(1);
    for (int k = 1; k < lg2N; ++k) {
        for (int i = 1; i + (1 << k) - 1 <= n + dcc_cnt; ++i)
            st[k][i] = Min(st[k - 1][i], st[k - 1][i + (1 << (k - 1))]);
        for (int i = 1; i <= n + dcc_cnt; ++i)
            kthfa[k][i] = kthfa[k - 1][kthfa[k - 1][i]];
    }
    scanf("%d", &q);
    for (int k; q--; ) {
        static int st[NN];
        scanf("%d", &k);
        for (int i = 1; i <= k; ++i)
            scanf("%d", &st[i]);
        sort(st + 1, st + k + 1, [] (int a, int b) {
            return idx[a] < idx[b];
        });
        for (int i = 1; i < k; ++i)
            st[k + i] = lca(st[i], st[i + 1]);
        sort(st + 1, st + k * 2, [] (int a, int b) {
            return idx[a] < idx[b];
        });
        int m = unique(st + 1, st + k * 2) - st - 1;
        for (int i = 1; i < m; ++i) {
            int u = st[i + 1], v = lca(st[i], st[i + 1]);
            VT.add(v, u);
            if (v > n) {
                int _u = jump(u, dpt[u] - dpt[v] - 1);
                bl[u] = _u;
            }
        }
        ans = 0;
        redfs(st[1]);
        printf("%lld\n", ans);
        VT.tot = 1;
        for (int i = 1; i <= m; ++i) {
            int u = st[i];
            VT.head[u] = 0;
        }
    }
    return 0;
}

使用 $\\mathcal{O}(1)$ 查找 $u',v'$ 算法(https://www.cnblogs.com/XuYueming/p/18919143)

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <tuple>
using namespace std;

using ll = long long;

const int N = 3e5 + 10;
const int M = N * 3 + 10;
const int NN = N << 1;
const int lg2N = __lg(NN) + 1;

int n, m, q;

template <size_t _N, size_t _M, typename T>
class Grpah {
public:
    Grpah(): tot(1) {}
    struct node {
        int v, nxt;
        T w;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v, const T& w) {
        edge[++tot] = { v, head[u], w };
        head[u] = tot;
    }
};
Grpah<N, M << 1, int> G;  // original grpah
Grpah<N << 1, N << 1, ll> T;  // rebuild tree

template <size_t _N, size_t _M>
class Graph_ {
public:
    Graph_(): tot(1) {}
    struct node {
        int v, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v) {
        edge[++tot] = { v, head[u] };
        head[u] = tot;
    }
};
Graph_<N << 1, N << 1> VT;  // virtual tree

int dcc_cnt;
ll cirsum[N], dis[N];

namespace $build {

int dfn[N], low[N], timer;
int stack[M], top;  // 注意这里的边栈的数组大小

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            stack[++top] = i;
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                static int tmp[N];
                int tot = 0;
                ++dcc_cnt;
                while (true) {
                    int j = stack[top--];
                    int uu = G.edge[j ^ 1].v;
                    int vv = G.edge[j].v;
                    int w = G.edge[j].w;
                    cirsum[dcc_cnt] += w;
                    if (j == i) break;
                    dis[uu] = dis[vv] + w;
                    tmp[++tot] = uu;
                }
                if (tot == 0) {
                    tmp[++tot] = v;
                    dis[v] = cirsum[dcc_cnt];
                    cirsum[dcc_cnt] <<= 1;
                }
                T.add(u, dcc_cnt + n, 0);
                for (int j = 1; j <= tot; ++j) {
                    int x = tmp[j];
                    T.add(dcc_cnt + n, x, min(dis[x], cirsum[dcc_cnt] - dis[x]));
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
            if (dfn[v] < dfn[u])
                stack[++top] = i;
        }
    }
}

}

int dpt[NN], fa[NN], timer;
int idx[NN], st[lg2N][NN];
ll sum[NN];  // tree prefix sum

void dfs(int u) {
    st[0][idx[u] = ++timer] = u;
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        ll w = T.edge[i].w;
        dpt[v] = dpt[u] + 1;
        fa[v] = u;
        sum[v] = sum[u] + w;
        dfs(v);
    }
}
inline int Min(int a, int b) {
    return dpt[a] < dpt[b] ? a : b;
}
inline tuple<int, int, int> lca(int u, int v) {
    if (u == v) return { 0, 0, u };
    int U, V, p, iu = idx[u], iv = idx[v];
    bool F = false;
    if (iu > iv) swap(iu, iv), swap(u, v), F = true;
    int k = __lg(iv - iu);
    V = Min(st[k][iu + 1], st[k][iv - (1 << k) + 1]);
    p = fa[V];
    if (p == u) U = 0;
    else {
        int ip = idx[p];
        k = __lg(iu - ip++);
        U = Min(st[k][ip], st[k][iu - (1 << k) + 1]);
    }
    if (F) swap(U, V);
    return { U, V, p };
}

ll ans, f[NN];
int bl[NN];  // 设 v 为 u 在虚树上的父亲，bl[u] 为 v 的一个在圆方树上的孩子，且为 u 的祖先

void redfs(int u) {
    f[u] = sum[u];
    if (u <= n) {
        for (int i = VT.head[u]; i; i = VT.edge[i].nxt) {
            int v = VT.edge[i].v;
            redfs(v);
            ans = max(ans, f[v] + f[u] - 2 * sum[u]);
            f[u] = max(f[u], f[v]);
        }
    } else {
        for (int i = VT.head[u]; i; i = VT.edge[i].nxt) {
            int v = VT.edge[i].v;
            redfs(v);
            f[u] = max(f[u], f[v]);
        }
        // do algorithm after dfs!
        static int son[N];
        static ll d[NN], w[NN];
        static int Q[NN];
        int cnt = 0;
        for (int i = VT.head[u]; i; i = VT.edge[i].nxt) {
            int v = VT.edge[i].v;
            son[++cnt] = v;
        }
        sort(son + 1, son + cnt + 1, [] (int a, int b) {
            return dis[bl[a]] < dis[bl[b]];
        });
        ll tot = cirsum[u - n];
        for (int i = 1; i <= cnt; ++i) {
            int v = son[i];
            int tv = bl[v];
            d[i] = dis[tv];
            w[i] = f[v] - sum[tv];
            d[cnt + i] = d[i] + tot;
            w[cnt + i] = w[i];
        }
        int head = 0, tail = -1;
        for (int i = 1; i <= cnt << 1; ++i) {
            while (head <= tail && d[Q[head]] < d[i] - tot/2) ++head;
            if (head <= tail) ans = max(ans, w[Q[head]] + w[i] + d[i] - d[Q[head]]);
            while (head <= tail && w[Q[tail]] - d[Q[tail]] <= w[i] - d[i]) --tail;
            Q[++tail] = i;
        }
        
        // for (int i = 1; i <= cnt; ++i)
        //     for (int j = i + 1; j <= cnt; ++j) {
        //         ll D = abs(d[i] - d[j]);
        //         ans = max(ans, w[i] + w[j] + min(D, tot - D));
        //     }
    }
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1, u, v, w; i <= m; ++i) {
        scanf("%d%d%d", &u, &v, &w);
        G.add(u, v, w);
        G.add(v, u, w);
    }
    $build::tarjan(1, 0);
    dfs(1);
    for (int k = 1; k < lg2N; ++k) {
        for (int i = 1; i + (1 << k) - 1 <= n + dcc_cnt; ++i)
            st[k][i] = Min(st[k - 1][i], st[k - 1][i + (1 << (k - 1))]);
    }
    scanf("%d", &q);
    for (int k; q--; ) {
        static int st[NN];
        scanf("%d", &k);
        for (int i = 1; i <= k; ++i)
            scanf("%d", &st[i]);
        sort(st + 1, st + k + 1, [] (int a, int b) {
            return idx[a] < idx[b];
        });
        for (int i = 1; i < k; ++i)
            st[k + i] = get<2>(lca(st[i], st[i + 1]));
        sort(st + 1, st + k * 2, [] (int a, int b) {
            return idx[a] < idx[b];
        });
        int m = unique(st + 1, st + k * 2) - st - 1;
        for (int i = 1; i < m; ++i) {
            int u = st[i + 1];
            auto [_, U, v] = lca(st[i], st[i + 1]);
            VT.add(v, u);
            if (v > n) bl[u] = U;
        }
        ans = 0;
        redfs(st[1]);
        printf("%lld\n", ans);
        VT.tot = 1;
        for (int i = 1; i <= m; ++i) {
            int u = st[i];
            VT.head[u] = 0;
        }
    }
    return 0;
}

例九、【集训队互测2016】火车司机出秦川（UOJ） Problem Statement

一棵 \(n\) 个点、\(m\) 条边的仙人掌，有边权，和 \(2q\) 次操作。

询问，第 \(i\) 次询问有 \(k_i\) 条简单路径，称作「路径」。一条「路径」用三个整数 \((u,v,0/1)\) 表示，其中 \(u,v\) 表示它的端点，\(0\) 表示「路径」为 \(u,v\) 之间所有简单路径中经过最少结点的那条，\(1\) 表示经过最多结点的那条。保证「路径」端点不重复，保证所有环为奇环。求这些「路径」的并的边权和。

每次询问后可能跟着一条边权的修改。

\(n,\sum|k_i|\leq3\times10^5\)。
Problem Analysis

先把这些「路径」的端点在圆方树上的虚树建出来。下称经过最少城市的路径称作最短路，与边权最短路区别，同理最长路。

考虑哪些东西会对答案产生贡献，也就是考虑一条「路径」可能会包含哪些边。LCA \(p\) 若是圆点，就包含了 \(p\rightarrow u\) 和 \(p\rightarrow v\) 的最长 / 最短路。\(p\) 若是方点，就包含了 \(u'\rightarrow u\)，\(v'\rightarrow v\) 的最长 / 最短路，这个和前面的问题形式是相同的，以及 \(p\) 对应环上 \(u'\rightarrow v'\) 的最长 / 最短路。

先不考虑修改，如果只有第一种问题怎么求。一条虚树边对应圆方树上一条方圆交错的路径，在原仙人掌上体现为，若干个简单环被连接成一个链状的结构。差分之后做树上前缀和，就能知道一条虚树边是否需要统计最短 / 最长路。而知道了是否需要统计最短 / 最长路，我们也很方便求出这一条链的贡献了。记 \(s_{0/1}(u)\) 表示 \(u\) 到根的最短 / 最长路路径长度，好像这样可以计算了，对于只需要统计最短 / 最长路，就是 \(s_{0/1}\) 相减，对于两个都需要统计，就是 \(s_0(u)+s_1(u)\) 相减......吗？对于环来说，最短最长路加在一起正好凑成了一个整个环，但是对于一条非环边来说就被重复统计了。所以此时对于「两点被一边相连」这种点双不能再当做一个环考虑了。还需要维护 \(s_2(u)\) 表示 \(u\) 到根的非环边路径长度。两种路径都要统计时，就是 \(s_0(u)+s_1(u)-s_2(u)\) 相减。

考虑如果只有第二种问题怎么求。不妨令在环的顺序下 \(u'\) 在 \(v'\) 之前，那么最短 / 最长路，就是 \(u'\sim v', v'\sim tail\sim head\sim u'\) 这两条路径中较短 / 长的那条。可以用差分完成区间覆盖，然后也能统计了。

如果两种问题同时存在，需要注意，第一种问题的路径可能会经过第二种路径的环，这个在第二个问题里面特殊处理一下，看看需不需要额外添加一些覆盖区间。

如果有了修改呢？如果这是一条环边，会影响到：总环长，这个很好维护；增加环上后缀所有点的到环首距离，所以需要对每个环开一个树状数组；对连续一段子树的 \(s_{0/1}\) 造成影响，这个用树状数组维护 DFS 序，就是区间加。如果这是一条非环边，会对子树的 \(s_{0/1/2}\) 产生增量，这个也用树状数组维护。

时间复杂度：\(\mathcal{O}(m+(n+q+\sum|S|)\log n)\)。
Solution

给出了没有修改的部分分代码，方便理解。
没有修改

#include <cstdio>
#include <iostream>
#include <set>
#include <algorithm>
#include <vector>
using namespace std;

using ll = long long;

const int N = 3e5 + 10;
const int M = N * 2 + 10;
const int NN = N << 1;
const int lg2N = __lg(NN) + 1;

int n, m, q;

template <size_t _N, size_t _M, typename T>
class Grpah {
public:
    Grpah(): tot(1) {}
    struct node {
        int v, nxt;
        T w;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v, const T& w) {
        edge[++tot] = { v, head[u], w };
        head[u] = tot;
    }
};
Grpah<N, M << 1, int> G;  // original grpah
Grpah<N << 1, N << 1, ll> T;  // rebuild tree

template <size_t _N, size_t _M>
class Graph_ {
public:
    Graph_(): tot(1) {}
    struct node {
        int v, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v) {
        edge[++tot] = { v, head[u] };
        head[u] = tot;
    }
};
Graph_<N << 1, N << 1> VT;  // virtual tree

int dcc_cnt;
ll cirSum[N], dis[N];
int cirTot[N], cirDpt[N];

bool notInCir[M];
ll s[3][NN];  // tree prefix sum

namespace $build {

int dfn[N], low[N], timer;
int stack[M], top;

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            stack[++top] = i;
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                static int tmp[N];
                int tot = 0;
                ++dcc_cnt;
                while (true) {
                    int j = stack[top--];
                    int uu = G.edge[j ^ 1].v;
                    int vv = G.edge[j].v;
                    int w = G.edge[j].w;
                    cirSum[dcc_cnt] += w;
                    if (j == i) break;
                    dis[uu] = dis[vv] + w;
                    cirDpt[uu] = cirDpt[vv] + 1;
                    tmp[++tot] = uu;
                }
                cirTot[dcc_cnt] = tot + 1;
                if (tot == 0) {
                    T.add(u, dcc_cnt + n, 0);
                    T.add(dcc_cnt + n, v, -cirSum[dcc_cnt]);  // 负数表示非环边
                    notInCir[i >> 1] = true;
                } else {
                    T.add(u, dcc_cnt + n, 0);
                    for (int j = 1; j <= tot; ++j) {
                        int x = tmp[j];
                        ll len;
                        if (cirDpt[x] < cirTot[dcc_cnt] - cirDpt[x])
                            len = dis[x];
                        else
                            len = cirSum[dcc_cnt] - dis[x];
                        T.add(dcc_cnt + n, x, len);
                    }
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
            if (dfn[v] < dfn[u])
                stack[++top] = i;
        }
    }
}

}

int dpt[NN], fa[NN], timer, kthfa[lg2N][NN];
int idx[NN], st[lg2N][NN];

void dfs(int u) {
    st[0][idx[u] = ++timer] = u;
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        ll w = T.edge[i].w;
        dpt[v] = dpt[u] + 1;
        fa[v] = kthfa[0][v] = u;
        
        if (u <= n) {
            s[0][v] = s[0][u];
            s[1][v] = s[1][u];
            s[2][v] = s[2][u];
        } else if (w > 0) {
            s[2][v] = s[2][u];
            s[0][v] = s[0][u] + w;
            s[1][v] = s[1][u] + (cirSum[u - n] - w);
        } else {
            w = -w;
            s[2][v] = s[2][u] + w;
            s[0][v] = s[0][u] + w;
            s[1][v] = s[1][u] + w;
        }
        
        dfs(v);
    }
}
inline int Min(int a, int b) {
    return dpt[a] < dpt[b] ? a : b;
}
inline int lca(int u, int v) {
    if (u == v) return u;
    if ((u = idx[u]) > (v = idx[v])) swap(u, v);
    int k = __lg(v - u++);
    return fa[Min(st[k][u], st[k][v - (1 << k) + 1])];
}
inline int jump(int u, int k) {
    for (int i = lg2N - 1; ~i; --i)
        if (k & 1 << i) u = kthfa[i][u];
    return u;
}

struct {
    int u, v, tp;
    int _u, _v;
} rd[N];  // Road

int bl[NN];  // 设 v 为 u 在虚树上的父亲，bl[u] 为 v 的一个在圆方树上的孩子，且为 u 的祖先
int cha[2][NN], _cha[2][NN];
vector<int> vec[NN];  // 方点 LCA 处的特殊处理
long long qans;

void redfs(int u) {
    if (u <= n) {
        for (int i = VT.head[u]; i; i = VT.edge[i].nxt) {
            int v = VT.edge[i].v;
            redfs(v);
            int w0 = cha[0][v], w1 = cha[1][v];
            cha[0][u] += w0;
            cha[1][u] += w1;
            long long x0 = s[0][v] - s[0][u];
            long long x1 = s[1][v] - s[1][u];
            long long x2 = s[2][v] - s[2][u];
            if (w0 && w1) {
                qans += x0 + x1 - x2;
            } else if (w0) {
                qans += x0;
            } else if (w1) {
                qans += x1;
            }
        }
    } else {
        for (int i = VT.head[u]; i; i = VT.edge[i].nxt) {
            int v = VT.edge[i].v;
            redfs(v);
            int w0 = cha[0][v], w1 = cha[1][v];
            long long x0 = s[0][v] - s[0][bl[v]];
            long long x1 = s[1][v] - s[1][bl[v]];
            long long x2 = s[2][v] - s[2][bl[v]];
            if (w0 && w1) {
                qans += x0 + x1 - x2;
            } else if (w0) {
                qans += x0;
            } else if (w1) {
                qans += x1;
            }
        }
        vector<pair<ll, int>> tmp;
        for (int id : vec[u]) {
            int uu = rd[id]._u;
            int vv = rd[id]._v;
            int tp = rd[id].tp;
            if (cirDpt[uu] > cirDpt[vv])
                swap(uu, vv);
            int A = cirDpt[vv] - cirDpt[uu];  // uu -> vv
            int B = cirTot[u - n] - A;  // uu -> head -> tail -> vv
            if (tp == (A > B)) {
                // A
                tmp.emplace_back(dis[uu], 1);
                tmp.emplace_back(dis[vv], -1);
            } else {
                // B
                tmp.emplace_back(0, 1);
                tmp.emplace_back(dis[uu], -1);
                tmp.emplace_back(dis[vv], 1);
            }
        }
        for (int i = VT.head[u]; i; i = VT.edge[i].nxt) {
            int v = VT.edge[i].v;
            int vv = bl[v];
            int w0 = cha[0][v], w1 = cha[1][v];
            w0 += _cha[0][vv], w1 += _cha[1][vv];
            cha[0][u] += w0;
            cha[1][u] += w1;
            int L = cirDpt[vv];
            int R = cirTot[u - n] - L;
            if (w0 && w1) {
                tmp.emplace_back(0, 1);
            } else if (w0 || w1) {
                if (bool(w0) == (L < R)) {
                    tmp.emplace_back(0, 1);
                    tmp.emplace_back(dis[vv], -1);
                } else {
                    tmp.emplace_back(dis[vv], 1);
                }
            }
        }
        sort(tmp.begin(), tmp.end());
        int m = tmp.size();
        int sum = 0;
        for (int i = 0, j = -1; i < m; i = j + 1) {
            while (j + 1 < m && tmp[j + 1].first == tmp[i].first)
                sum += tmp[++j].second;
            ll len;
            if (j == m - 1)
                len = cirSum[u - n] - tmp[i].first;
            else
                len = tmp[j + 1].first - tmp[i].first;
            if (sum) {
                qans += len;
            }
        }
    }
}

void query() {
    static int st[NN], _st[NN];
    int k;
    scanf("%d", &k);
    if (!k) {
        puts("0");
        return;
    }
    int m = 0;
    for (int i = 1; i <= k; ++i) {
        scanf("%d%d%d", &rd[i].u, &rd[i].v, &rd[i].tp);
        st[++m] = rd[i].u;
        st[++m] = rd[i].v;
    }
    sort(st + 1, st + m + 1, [] (int a, int b) {
        return idx[a] < idx[b];
    });
    for (int i = 1; i < m; ++i)
        st[m + i] = lca(st[i], st[i + 1]);
    sort(st + 1, st + m * 2, [] (int a, int b) {
        return idx[a] < idx[b];
    });
    m = unique(st + 1, st + m * 2) - st - 1;
    int _m = 0;
    for (int i = 1; i < m; ++i) {
        int u = st[i + 1], v = lca(st[i], st[i + 1]);
        VT.add(v, u);
        if (v > n) {
            int _u = jump(u, dpt[u] - dpt[v] - 1);
            _st[++_m] = _u;
            bl[u] = _u;
        }
    }
    for (int i = 1; i <= k; ++i) {
        int u = rd[i].u, v = rd[i].v, w = rd[i].tp;
        int p = lca(u, v);
        if (p > n) {
            int _u = jump(u, dpt[u] - dpt[p] - 1);
            int _v = jump(v, dpt[v] - dpt[p] - 1);
            ++cha[w][u], --_cha[w][_u];
            ++cha[w][v], --_cha[w][_v];
            rd[i]._u = _u;
            rd[i]._v = _v;
            vec[p].emplace_back(i);
        } else {
            ++cha[w][u], ++cha[w][v];
            cha[w][p] -= 2;
        }
    }
    qans = 0;
    redfs(st[1]);
    printf("%lld\n", qans);
    VT.tot = 1;
    for (int i = 1; i <= m; ++i) {
        int u = st[i];
        VT.head[u] = 0;
        vec[u].clear();
        cha[0][u] = cha[1][u] = 0;
    }
    for (int i = 1; i <= _m; ++i) {
        int u = _st[i];
        _cha[0][u] = _cha[1][u] = 0;
    }
}

void modify() {
    int w, x;
    scanf("%d%d", &w, &x);
    if (!w) return;
    throw;
}

int main() {
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1, u, v, w; i <= m; ++i) {
        scanf("%d%d%d", &u, &v, &w);
        G.add(u, v, w);
        G.add(v, u, w);
    }
    $build::tarjan(1, 0);
    dfs(1);
    for (int k = 1; k < lg2N; ++k) {
        for (int i = 1; i + (1 << k) - 1 <= n + dcc_cnt; ++i)
            st[k][i] = Min(st[k - 1][i], st[k - 1][i + (1 << (k - 1))]);
        for (int i = 1; i <= n + dcc_cnt; ++i)
            kthfa[k][i] = kthfa[k - 1][kthfa[k - 1][i]];
    }
    while (q--) query(), modify();
    return 0;
}

满分做法

#include <cstdio>
#include <iostream>
#include <set>
#include <algorithm>
#include <vector>
#include <cassert>
using namespace std;

using ll = long long;

const int N = 3e5 + 10;
const int M = N * 2 + 10;
const int NN = N << 1;
const int lg2N = __lg(NN) + 1;

int n, m, q;

template <size_t _N, size_t _M, typename T>
class Grpah {
public:
    Grpah(): tot(1) {}
    struct node {
        int v, nxt;
        T w;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v, const T& w) {
        edge[++tot] = { v, head[u], w };
        head[u] = tot;
    }
};
Grpah<N, M << 1, int> G;  // original grpah
Grpah<N << 1, N << 1, ll> T;  // rebuild tree

template <size_t _N, size_t _M>
class Graph_ {
public:
    Graph_(): tot(1) {}
    struct node {
        int v, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v) {
        edge[++tot] = { v, head[u] };
        head[u] = tot;
    }
};
Graph_<N << 1, N << 1> VT;  // virtual tree

template <typename T>
class Bit_Tree {
private:
    vector<T> tree;
    int size() const { return tree.size(); }
    void _modify(int p, T v) {
        for (; p <= size(); p += p & -p)
            tree[p - 1] += v;
    }
    T query(int p) const {
        T res = 0;
        for (; p; p &= p - 1)
            res += tree[p - 1];
        return res;
    }
public:
    void init(int n) {
        tree = vector<T>(n, 0);
    }
    void modify(int l, int r, T v) {
        assert(1 <= l && l <= r && r <= size());
        _modify(l, v);
        _modify(r + 1, -v);
    }
    void modify(int p, T v) {
        assert(1 <= p && p <= size());
        modify(p, p, v);
    }
    T operator [] (int p) const {
        assert(1 <= p && p <= size());
        return query(p);
    }
};

int dcc_cnt;
ll cirSum[N];
Bit_Tree<ll> dis[N];
vector<int> circle[N];
int cirTot[N], cirDpt[N];

bool notInCir[M];

namespace $build {

int dfn[N], low[N], timer;
int stack[M], top;

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            stack[++top] = i;
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                static int tmp[N];
                int tot = 0;
                ++dcc_cnt;
                for (int ttop = top; ; ) {
                    int j = stack[ttop--];
                    int uu = G.edge[j ^ 1].v;
                    if (j == i) break;
                    tmp[++tot] = uu;
                    circle[dcc_cnt].emplace_back(uu);
                }
                dis[dcc_cnt].init(tot);
                while (true) {
                    int j = stack[top--];
                    int uu = G.edge[j ^ 1].v;
                    int vv = G.edge[j].v;
                    int w = G.edge[j].w;
                    cirSum[dcc_cnt] += w;
                    if (j == i) break;
                    cirDpt[uu] = cirDpt[vv] + 1;
                    dis[dcc_cnt].modify(cirDpt[uu], tot, w);
                }
                cirTot[dcc_cnt] = tot + 1;
                if (tot == 0) {
                    T.add(u, dcc_cnt + n, 0);
                    T.add(dcc_cnt + n, v, -cirSum[dcc_cnt]);  // 负数表示非环边
                    notInCir[i >> 1] = true;
                } else {
                    T.add(u, dcc_cnt + n, 0);
                    for (int j = tot; j; --j) {  // attention, reversed
                        int x = tmp[j];
                        ll len;
                        if (cirDpt[x] < cirTot[dcc_cnt] - cirDpt[x])
                            len = dis[dcc_cnt][cirDpt[x]];
                        else
                            len = cirSum[dcc_cnt] - dis[dcc_cnt][cirDpt[x]];
                        T.add(dcc_cnt + n, x, len);
                    }
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
            if (dfn[v] < dfn[u])
                stack[++top] = i;
        }
    }
}

}

Bit_Tree<ll> s[3];  // tree prefix sum
int dpt[NN], fa[NN], timer, kthfa[lg2N][NN];
int idx[NN], st[lg2N][NN];
int L[NN], R[NN];

void dfs(int u) {
    st[0][idx[u] = ++timer] = u;
    L[u] = idx[u];
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        ll w = T.edge[i].w;
        dpt[v] = dpt[u] + 1;
        fa[v] = kthfa[0][v] = u;
        
        dfs(v);
        
        if (u <= n) {
            
        } else if (w > 0) {
            s[0].modify(L[v], R[v], w);
            s[1].modify(L[v], R[v], cirSum[u - n] - w);
        } else {
            w = -w;
            s[0].modify(L[v], R[v], w);
            s[1].modify(L[v], R[v], w);
            s[2].modify(L[v], R[v], w);
        }
    }
    R[u] = timer;
}
inline int Min(int a, int b) {
    return dpt[a] < dpt[b] ? a : b;
}
inline int lca(int u, int v) {
    if (u == v) return u;
    if ((u = idx[u]) > (v = idx[v])) swap(u, v);
    int k = __lg(v - u++);
    return fa[Min(st[k][u], st[k][v - (1 << k) + 1])];
}
inline int jump(int u, int k) {
    for (int i = lg2N - 1; ~i; --i)
        if (k & 1 << i) u = kthfa[i][u];
    return u;
}

struct {
    int u, v, tp;
    int _u, _v;
} rd[N];  // Road

int bl[NN];  // 设 v 为 u 在虚树上的父亲，bl[u] 为 v 的一个在圆方树上的孩子，且为 u 的祖先
int cha[2][NN], _cha[2][NN];
vector<int> vec[NN];  // 方点 LCA 处的特殊处理
long long qans;

void redfs(int u) {
    if (u <= n) {
        for (int i = VT.head[u]; i; i = VT.edge[i].nxt) {
            int v = VT.edge[i].v;
            redfs(v);
            int w0 = cha[0][v], w1 = cha[1][v];
            cha[0][u] += w0;
            cha[1][u] += w1;
            long long x0 = s[0][idx[v]] - s[0][idx[u]];
            long long x1 = s[1][idx[v]] - s[1][idx[u]];
            long long x2 = s[2][idx[v]] - s[2][idx[u]];
            if (w0 && w1) {
                qans += x0 + x1 - x2;
            } else if (w0) {
                qans += x0;
            } else if (w1) {
                qans += x1;
            }
        }
    } else {
        for (int i = VT.head[u]; i; i = VT.edge[i].nxt) {
            int v = VT.edge[i].v;
            redfs(v);
            int w0 = cha[0][v], w1 = cha[1][v];
            long long x0 = s[0][idx[v]] - s[0][idx[bl[v]]];
            long long x1 = s[1][idx[v]] - s[1][idx[bl[v]]];
            long long x2 = s[2][idx[v]] - s[2][idx[bl[v]]];
            if (w0 && w1) {
                qans += x0 + x1 - x2;
            } else if (w0) {
                qans += x0;
            } else if (w1) {
                qans += x1;
            }
        }
        vector<pair<ll, int>> tmp;
        for (int id : vec[u]) {
            int uu = rd[id]._u;
            int vv = rd[id]._v;
            int tp = rd[id].tp;
            if (cirDpt[uu] > cirDpt[vv])
                swap(uu, vv);
            int A = cirDpt[vv] - cirDpt[uu];  // uu -> vv
            int B = cirTot[u - n] - A;  // uu -> head -> tail -> vv
            if (tp == (A > B)) {
                // A
                tmp.emplace_back(dis[u - n][cirDpt[uu]], 1);
                tmp.emplace_back(dis[u - n][cirDpt[vv]], -1);
            } else {
                // B
                tmp.emplace_back(0, 1);
                tmp.emplace_back(dis[u - n][cirDpt[uu]], -1);
                tmp.emplace_back(dis[u - n][cirDpt[vv]], 1);
            }
        }
        for (int i = VT.head[u]; i; i = VT.edge[i].nxt) {
            int v = VT.edge[i].v;
            int vv = bl[v];
            int w0 = cha[0][v], w1 = cha[1][v];
            w0 += _cha[0][vv], w1 += _cha[1][vv];
            cha[0][u] += w0;
            cha[1][u] += w1;
            int L = cirDpt[vv];
            int R = cirTot[u - n] - L;
            if (w0 && w1) {
                tmp.emplace_back(0, 1);
            } else if (w0 || w1) {
                if (bool(w0) == (L < R)) {
                    tmp.emplace_back(0, 1);
                    tmp.emplace_back(dis[u - n][cirDpt[vv]], -1);
                } else {
                    tmp.emplace_back(dis[u - n][cirDpt[vv]], 1);
                }
            }
        }
        sort(tmp.begin(), tmp.end());
        int m = tmp.size();
        int sum = 0;
        for (int i = 0, j = -1; i < m; i = j + 1) {
            while (j + 1 < m && tmp[j + 1].first == tmp[i].first)
                sum += tmp[++j].second;
            ll len;
            if (j == m - 1)
                len = cirSum[u - n] - tmp[i].first;
            else
                len = tmp[j + 1].first - tmp[i].first;
            if (sum) {
                qans += len;
            }
        }
    }
}

void query() {
    static int st[NN], _st[NN];
    int k;
    scanf("%d", &k);
    if (!k) {
        puts("0");
        return;
    }
    int m = 0;
    for (int i = 1; i <= k; ++i) {
        scanf("%d%d%d", &rd[i].u, &rd[i].v, &rd[i].tp);
        st[++m] = rd[i].u;
        st[++m] = rd[i].v;
    }
    sort(st + 1, st + m + 1, [] (int a, int b) {
        return idx[a] < idx[b];
    });
    for (int i = 1; i < m; ++i)
        st[m + i] = lca(st[i], st[i + 1]);
    sort(st + 1, st + m * 2, [] (int a, int b) {
        return idx[a] < idx[b];
    });
    m = unique(st + 1, st + m * 2) - st - 1;
    int _m = 0;
    for (int i = 1; i < m; ++i) {
        int u = st[i + 1], v = lca(st[i], st[i + 1]);
        VT.add(v, u);
        if (v > n) {
            int _u = jump(u, dpt[u] - dpt[v] - 1);
            _st[++_m] = _u;
            bl[u] = _u;
        }
    }
    for (int i = 1; i <= k; ++i) {
        int u = rd[i].u, v = rd[i].v, w = rd[i].tp;
        int p = lca(u, v);
        if (p > n) {
            int _u = jump(u, dpt[u] - dpt[p] - 1);
            int _v = jump(v, dpt[v] - dpt[p] - 1);
            ++cha[w][u], --_cha[w][_u];
            ++cha[w][v], --_cha[w][_v];
            rd[i]._u = _u;
            rd[i]._v = _v;
            vec[p].emplace_back(i);
        } else {
            ++cha[w][u], ++cha[w][v];
            cha[w][p] -= 2;
        }
    }
    qans = 0;
    redfs(st[1]);
    printf("%lld\n", qans);
    VT.tot = 1;
    for (int i = 1; i <= m; ++i) {
        int u = st[i];
        VT.head[u] = 0;
        vec[u].clear();
        cha[0][u] = cha[1][u] = 0;
    }
    for (int i = 1; i <= _m; ++i) {
        int u = _st[i];
        _cha[0][u] = _cha[1][u] = 0;
    }
}

void modify() {
    int w, x;
    scanf("%d%d", &w, &x);
    if (!w) return;
    int u = G.edge[w << 1].v;
    int v = G.edge[w << 1 | 1].v;
    int tw = G.edge[w << 1].w;
    if (dpt[u] > dpt[v]) swap(u, v);
    if (notInCir[w]) {
        s[0].modify(L[v], R[v], x - tw);
        s[1].modify(L[v], R[v], x - tw);
        s[2].modify(L[v], R[v], x - tw);
    } else {
        int o = fa[v] - n;
        int tot = cirTot[o];
        const auto& circle = ::circle[o];
        int lp = circle[tot / 2 - 1];
        int rp = circle[tot / 2];
        int hd = circle[0];
        int tl = circle[tot - 2];
        int whr;  // -1: left, 0: middle, 1: right
        if (u == fa[fa[v]]) {
            if (cirDpt[v] == 1)
                whr = -1;
            else
                whr = 1;
        } else {
            if (cirDpt[u] > cirDpt[v])
                swap(u, v);
            if (u == lp && v == rp) {
                whr = 0;
            } else {
                if (cirDpt[v] <= tot / 2)
                    whr = -1;
                else {
                    whr = 1;
                    swap(u, v);
                }
            }
        }
        if (whr == 0) {
            dis[o].modify(cirDpt[v], tot - 1, x - tw);
            s[1].modify(L[hd], R[lp], x - tw);
            s[1].modify(L[rp], R[tl], x - tw);
        } else if (whr == -1) {
            dis[o].modify(cirDpt[v], tot - 1, x - tw);
            s[0].modify(L[v], R[lp], x - tw);
            if (v != hd)
                s[1].modify(L[hd], R[u], x - tw);
            s[1].modify(L[rp], R[tl], x - tw);
        } else {
            s[0].modify(L[rp], R[v], x - tw);
            if (v != tl) {
                dis[o].modify(cirDpt[u], tot - 1, x - tw);
                s[1].modify(L[u], R[tl], x - tw);
            }
            s[1].modify(L[hd], R[lp], x - tw);
        }
        cirSum[o] += x - tw;
    }
    G.edge[w << 1].w = x;
    G.edge[w << 1 | 1].w = x;
}

int main() {
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1, u, v, w; i <= m; ++i) {
        scanf("%d%d%d", &u, &v, &w);
        G.add(u, v, w);
        G.add(v, u, w);
    }
    $build::tarjan(1, 0);
    for (int i = 0; i < 3; ++i)
        s[i].init(n + dcc_cnt);
    dfs(1);
    for (int k = 1; k < lg2N; ++k) {
        for (int i = 1; i + (1 << k) - 1 <= n + dcc_cnt; ++i)
            st[k][i] = Min(st[k - 1][i], st[k - 1][i + (1 << (k - 1))]);
        for (int i = 1; i <= n + dcc_cnt; ++i)
            kthfa[k][i] = kthfa[k - 1][kthfa[k - 1][i]];
    }
    while (q--) query(), modify();
    return 0;
}

类型五：静态仙人掌，动态维护全局信息

其实就是仙人掌上的 DDP 问题。

我们不妨从一个具体的问题开始思考：支持修改点权，动态维护仙人掌的最大独立集权值。

在树上，我们做过模板题，没有修改时，我们在前文例题一探讨过单次 \(\mathcal{O}(n)\) 求仙人掌最大独立集的算法，我们要做的就是把这两个算法结合起来。

回顾在一个序列上我们如何动态维护独立集的？设 \(f_0,f_1\) 表示选或不选最后一个元素的最大独立集，那么根据定义有 \(f_1'=f_0+a_i,f_0'=\max\{f_0,f_1\}\)，容易写出转移方程的 \((+,\max)\) 矩阵乘法形式：

\\\begin{bmatrix} f_0 \& f_1 \\end{bmatrix} \\times \\begin{bmatrix} 0 \& a_i \\\\ 0 \& -\\infty \\\\ \\end{bmatrix} = \\begin{bmatrix} f_0' \& f_1' \\end{bmatrix} \\

回顾这个东西是如何上树的。我们轻重链剖分后，重链其实就是普通的一条链，但是对于不选择 / 选择 \(u\) 的收益不再是 \(0/a_u\)，而是 \(t_0/t_1+a_u\)，其中 \(t_{0/1}\) 表示轻儿子对它的贡献，\(t_0\) 为所有轻儿子的 \(\max\{f_0,f_1\}\) 之和，\(t_1\) 为所有轻儿子的 \(f_0\) 之和。转移矩阵为：\(\begin{bmatrix} t_0 & t_1+a_u \\ t_0 & -\infty \\ \end{bmatrix}\)。如此，我们实际完成了，通过求一条以 \(u\) 为链顶的重链的矩阵乘法，得到 \(u\) 子树的答案。

这个东西怎么上仙人掌呢？无非就是考虑如何处理环。

目前状态肯定是不够了，想到把扩展状态成 \(f_0,f_1,g_0,g_1\)，分别对应环尾必不选和可能选的 DP 值。但是这是不好做的。如上图，假设这个点双对应的方点为 \(u\)，\(u\) 的父亲圆点为 \(1\)，重儿子为 \(5\)。为了转移顺序，我们也许会想到把 DFS 序设置为：

\7,6,\\colorbox{#409eff}{$ 5,... $},4,3,2 \\

但是 \(5,...\) 得到的是 \(5\) 的子仙人掌的 DP 值，我们并不能将它再乘上某一个矩阵，得到对应在 \(f_0,f_1,g_0,g_1\) 上的转移矩阵。所以这个想法是错误的。

以上想法错误之处，根本在于重儿子不能出现在转移方程的中间，否则无法通过 DP 值得到对应的转移矩阵。那么 \(5\) 作为 DP 的初始位置，应该如何设置转移顺序和状态呢？

我们想到一种「兵分两路」的转移方式，将环拆成两条链：\(5,6,7,1\) 和 \(5,4,3,2\)，并要求 \(5\) 要么同时选，要么同时不选，最后统计答案的时候 \(1,2\) 不能同时选。设 \(f_{a,b}\)，其中 \(a,b\) 分别表示左右两条链，目前考虑到的链顶选或不选的答案。初始矩阵为：

\\\begin{bmatrix} f_{0,0}\&f_{0,1}\&f_{1,0}\&f_{1,1} \\end{bmatrix} = \\begin{bmatrix} t_0\&-\\infty\&-\\infty\&t_1 \\end{bmatrix} \\

其中 \(t_{0/1}\) 表示重儿子 \(5\) 传统的 DP 值。这同时解决了 \(5\) 只能最多选一次的问题。

对于左边这条链上的点 \(u\)，会独立转移 \(f_{0/1,*}\)，即对于 \(p=0,1\)，\(f_{0,p}'=\max\{f_{0,p},f_{1,p}\}+t_0,f_{1,p}'=f_{0,p}+t_1\)，其中 \(t_{0/1}\) 表示 \(u\) 考虑其子仙人掌的传统 DP 值，下文在不引起歧义的前提下，省去了对 \(t_{0/1}\) 的解释。写成转移矩阵的形式就是：

\f(t_0,t_1,1)=\\begin{bmatrix} t_0 \& \& t_1 \& \\\\ \& t_0 \& \& t_1 \\\\ t_0 \& \& \& \\\\ \& t_0 \& \& \\\\ \\end{bmatrix} \\

同理，对于右边那条链上的 \(u\) 的转移为：

\f(t_0,t_1,2)=\\begin{bmatrix} t_0 \& t_1 \& \& \\\\ t_0 \& \& \& \\\\ \& \& t_0 \& t_1 \\\\ \& \& t_0 \& \\\\ \\end{bmatrix} \\

在 \(1\) 点，我们就能求出想要的值，不妨令 \(1\) 在左侧链上，那么 \(t_0=\max\{f_{0,0},f_{0,1}\},t_1=f_{1,0}\)，我们可以写出一个矩阵，通过 \(\begin{bmatrix} f_{0,0}&f_{0,1}&f_{1,0}&f_{1,1} \end{bmatrix}\) 得到 \(\begin{bmatrix} t_0&-\infty&-\infty&t_1 \end{bmatrix}\)，这是正是环上 DP 的初始值，从而形成逻辑上的闭环。

\M=\\begin{bmatrix} 0 \& \& \& \\\\ 0 \& \& \& \\\\ \& \& \& 0 \\\\ \& \& \& \\end{bmatrix} \\

当然，以上所有矩阵都是转移矩阵，我们初始矩阵为：

\M_0=\\begin{bmatrix} 0 \& \& \& 0 \\end{bmatrix} \\

我们已经初步确认，这个问题是可做的，并且粗浅地想出了一种转移的方式。接下来，需要解决遗留下来尚未处理的细节。

1. 如何设计 DFS 序？

   类似类型三的 DFS 序设计，将方点替换为其所有轻孩子，接着是重儿子和它的子树。同时，我们需要左链右链上的节点的相对顺序满足转移顺序。

   

   例如，用不同颜色区分左右链，上图的一个不合法 的 DFS 序为 \({\color{red}1},{\color{red}7},{\color{yellow}2},{\color{yellow}4},{\color{red}6},{\color{yellow}3},5\)，因为右链转移顺序并不是 \(3,4,2\)，而应该是 \(4,3,2\)。一种合法的 DFS 序为 \({\color{red}1},{\color{red}7},{\color{yellow}2},{\color{yellow}3},{\color{red}6},{\color{yellow}4},5\)。当然，我们显然喜欢更简单的 DFS 序 \({\color{red}1},{\color{red}7},{\color{red}6},{\color{yellow}2},{\color{yellow}3},{\color{yellow}4},5\)，它先按照顺序转移完了右链上的 \(4,3,2\)，再转移完左链上 \(6,7,1\)。

2. 如何分配 DFS 序上对应转移矩阵？

   先来明确一下各种 DFS 序区间和其对应矩阵的关系。

   对于一个方点，它对应 DFS 序上的区间求出来的矩阵，是一个环上 DP 未完成的矩阵，因为缺少了链顶的转移。例如，\({\color{red}1},{\color{red}7},{\color{red}6},{\color{yellow}2},{\color{yellow}3},{\color{yellow}4},5\) 中，实际方点对应的 DFS 序为 \({\color{red}7},{\color{red}6},{\color{yellow}2},{\color{yellow}3},{\color{yellow}4},5\)，这缺少了 \({\color{red}1}\) 的转移。

   对于一个重儿子圆点，它对应 DFS 序上的区间求出来的矩阵，已经完成了环上的转移，左乘 \(M_0\) 后形如 \(\begin{bmatrix}t_0&-\infty&-\infty&t_1\end{bmatrix}\)。

   对于一个轻儿子圆点，它没有对应的 DFS 序区间。

   类似树上，维护 \(u\) 所有轻儿子的答案和，记为 \(g_0,g_1\)，以及不妨令 \(g_1\) 中包含 \(u\) 的点权。

   1. \(u\) 为重儿子。

      它在 DFS 序上位置形如：\(...,u,(a),(b_1),(b_2),...\)，其中 \((a)\) 为 \(u\) 的重方儿子对应子树，\((b_i)\) 对应 \(u\) 的轻方儿子的子树，两个 \(...\) 分别对应 \(u\) 的轻儿子兄弟，和这些点的方儿子子树。

      \((a)\) 求出来一个环上 DP 未完成的矩阵，所以要先乘上 \(f(g_0,g_1,1)\) 完成环上 DP，再乘上 \(M\)，得到形如 \(\begin{bmatrix}t_0&-\infty&-\infty&t_1\end{bmatrix}\) 的矩阵。这也就是 \(u,(a)\) 求出的结果。

   2. \(u\) 为轻儿子。

      先将 \(g_0,g_1\) 加上其重儿子的贡献，然后它在 DFS 序上的矩阵即为 \(f(g_0,g_1,\operatorname{type}(u))\)。

3. 如何求答案？

   \(1\) 为链顶的这条重链，对应的区间的矩阵之积，就是转移矩阵，左乘 初始矩阵 \(M_0\) 得到答案矩阵 \(\begin{bmatrix}t_0&-\infty&-\infty&t_1\end{bmatrix}\)，答案即为 \(\max\{t_0,t_1\}\)。

4. 如何修改？

   树上修改的时候，设当前点为 \(u\)，其重链顶为 \(v\)，\(v\) 的父亲为 \(w\)，那么要先在 \(w\) 的矩阵中减去这条重链的贡献，再加上修改后的贡献，接着令 \(u\gets w\)，继续操作，直到 \(v=1\) 停止。上述过程中要求我们维护一个 \(M_{\mathrm{last}}\) 表示以 \(v\) 为链顶的这条重链修改前的矩阵之积。在修改 \(w\) 前要先求出 \(w\) 所在重链的矩阵之积，以赋值给 \(M_{\mathrm{last}}\)。

   仙人掌上，对于 \(v\) 的类型分类讨论。

   1. \(v\) 为圆点。

      我们需要处理 \(v\) 的转移矩阵。\(v\) 的 \(g_0,g_1\) 可以方便维护，那么只需要和初始化的时候一样，求出重儿子的贡献，在线段树上修改即可。发现竟然不需要 \(M_{\mathrm{last}}\) 之类的东西。

   2. \(v\) 为方点。

      我们需要处理 \(w\) 的转移矩阵。\(v\) 作为 \(w\) 的轻儿子，就需要在 \(w\) 的 \(g_0,g_1\) 中，减去原先的贡献，再加上修改后的贡献。于是类似树上 DDP，需要维护 \(M_{\mathrm{last}}\)，接着，按照 \(w\) 为重儿子还是轻儿子，修改其转移矩阵即可。

   如何维护 \(M_{\mathrm{last}}\)？似乎只需要和树上 DDP 类似，当 \(w\) 链顶 \(p\) 为方点时，先查询 \(p\) 对应的转移矩阵，赋值给 \(M_{\mathrm(last)}\) 即可。但这在某种情况下是错误的。当 \(u=v\) 为圆点时，我们查询 \(p\) 的转移矩阵时，会包含 \(u\) 的转移矩阵，我们能够保证这个矩阵是没有更新过的吗？不能，因为可能上一次操作为情况 2「\(v\) 为方点」，而这会更新到 \(u\) 的转移矩阵，所以我们需要在上一次操作，提前判断这种特殊情况，提前赋值 \(M_{\mathrm{last}}\)，在这一次操作就不对 \(M_{\mathrm{last}}\) 赋值。具体可以参考例题代码。

我们至此成功解决了这个问题，时间复杂度 \(\mathcal{O}(nw^3\log n+qw^3\log^2n)\)，其中 \(w=4\) 为矩阵的大小。或许使用全局平衡二叉树可以优化到一只 \(\log\)，但是没有实现。

我们在上文中探讨了一种经典的 DDP 问题在仙人掌上的求解方式，对于其他 DDP 问题，或许可以参考这种方式解决问题。
例十、DDP on cactus（洛谷） Problem Statement

\(n\) 个点 \(m\) 条边的仙人掌，点编号为 \(1\sim n\)，每个结点有一个权值 \(w_u\)。

\(q\) 次点权修改操作，你需要在第一次修改前以及每次修改后，输出这棵仙人掌的最大独立集。

\(2\leq n\leq10^5\)。\(1\leq q\leq 10^5\)。任意时刻 \(0\leq w_i\leq 10^9\)。
Problem Analysis

前文分析的仙人掌上最大独立集问题。给出了一种参考实现。
Solution

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cassert>
using namespace std;

using ll = long long;

const int N = 1e5 + 10;
const int M = 2e5 + 10;
const int N2 = N << 1;
const ll oinf = 0xc1c1c1c1c1c1c1c1;

int n, m, q;
int val[N];

template <size_t _N, size_t _M>
class Graph {
public:
    Graph(): tot(1) {}
    struct node {
        int v, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v) {
        edge[++tot] = { v, head[u] };
        head[u] = tot;
    }
};

Graph<N, M << 1> G;
Graph<N2, N2> T;

int dcc_cnt;

namespace $build {

int dfn[N], low[N], timer;
int stack[N], top;

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                ++dcc_cnt;
                T.add(u, dcc_cnt + n);
                while (true) {
                    int x = stack[top--];
                    T.add(dcc_cnt + n, x);
                    if (x == v) break;
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
        }
    }
}

}

inline ll max(ll a, ll b) {
    return a > b ? a : b;
}
struct Matrix {
    ll v[4][4];
    void init() { memset(v, 0xc1, sizeof(v)); }
    void unit() { v[0][0] = v[1][1] = v[2][2] = v[3][3] = 0; }
    ll* operator [] (int x) { return v[x]; }
    ll const* operator [] (int x) const { return v[x]; }
    friend inline Matrix operator * (const Matrix& a, const Matrix& b) {
        Matrix c;
        c[0][0] = max(oinf, max(max(a[0][0] + b[0][0], a[0][1] + b[1][0]), max(a[0][2] + b[2][0], a[0][3] + b[3][0])));
        c[0][1] = max(oinf, max(max(a[0][0] + b[0][1], a[0][1] + b[1][1]), max(a[0][2] + b[2][1], a[0][3] + b[3][1])));
        c[0][2] = max(oinf, max(max(a[0][0] + b[0][2], a[0][1] + b[1][2]), max(a[0][2] + b[2][2], a[0][3] + b[3][2])));
        c[0][3] = max(oinf, max(max(a[0][0] + b[0][3], a[0][1] + b[1][3]), max(a[0][2] + b[2][3], a[0][3] + b[3][3])));
        c[1][0] = max(oinf, max(max(a[1][0] + b[0][0], a[1][1] + b[1][0]), max(a[1][2] + b[2][0], a[1][3] + b[3][0])));
        c[1][1] = max(oinf, max(max(a[1][0] + b[0][1], a[1][1] + b[1][1]), max(a[1][2] + b[2][1], a[1][3] + b[3][1])));
        c[1][2] = max(oinf, max(max(a[1][0] + b[0][2], a[1][1] + b[1][2]), max(a[1][2] + b[2][2], a[1][3] + b[3][2])));
        c[1][3] = max(oinf, max(max(a[1][0] + b[0][3], a[1][1] + b[1][3]), max(a[1][2] + b[2][3], a[1][3] + b[3][3])));
        c[2][0] = max(oinf, max(max(a[2][0] + b[0][0], a[2][1] + b[1][0]), max(a[2][2] + b[2][0], a[2][3] + b[3][0])));
        c[2][1] = max(oinf, max(max(a[2][0] + b[0][1], a[2][1] + b[1][1]), max(a[2][2] + b[2][1], a[2][3] + b[3][1])));
        c[2][2] = max(oinf, max(max(a[2][0] + b[0][2], a[2][1] + b[1][2]), max(a[2][2] + b[2][2], a[2][3] + b[3][2])));
        c[2][3] = max(oinf, max(max(a[2][0] + b[0][3], a[2][1] + b[1][3]), max(a[2][2] + b[2][3], a[2][3] + b[3][3])));
        c[3][0] = max(oinf, max(max(a[3][0] + b[0][0], a[3][1] + b[1][0]), max(a[3][2] + b[2][0], a[3][3] + b[3][0])));
        c[3][1] = max(oinf, max(max(a[3][0] + b[0][1], a[3][1] + b[1][1]), max(a[3][2] + b[2][1], a[3][3] + b[3][1])));
        c[3][2] = max(oinf, max(max(a[3][0] + b[0][2], a[3][1] + b[1][2]), max(a[3][2] + b[2][2], a[3][3] + b[3][2])));
        c[3][3] = max(oinf, max(max(a[3][0] + b[0][3], a[3][1] + b[1][3]), max(a[3][2] + b[2][3], a[3][3] + b[3][3])));
        return c;
    }
    void output() const {
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                if (v[i][j] <= -10000000)
                    printf("-inf ");
                else
                    printf("%lld ", v[i][j]);
            }
            puts("");
        }
    }
};
using mat_t = Matrix;

int siz[N2], son[N2];
int fa[N2], top[N2], tail[N2];

int dfn[N], idx[N], L[N2], R[N2], timer;
int typ[N];
/**
 * u is yuan:
 *      [L[u], R[u]] = subtree(u)
 *      typ[u] = { 0: son, 1: F, 2: G }
 * u is fang:
 *      [L[u], R[u]] = son(u)
*/

void dfs(int u) {
    siz[u] = 1;
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        fa[v] = u;
        dfs(v), siz[u] += siz[v];
        if (siz[v] > siz[son[u]])
            son[u] = v;
    }
}

const mat_t ans2init = {{
    { 0   , oinf, oinf, oinf },
    { 0   , oinf, oinf, oinf },
    { oinf, oinf, oinf, 0    },
    { oinf, oinf, oinf, oinf },
}};

const mat_t beginst = {{
    { 0   , oinf, oinf, 0    },
    { oinf, oinf, oinf, oinf },
    { oinf, oinf, oinf, oinf },
    { oinf, oinf, oinf, oinf },
}};

inline mat_t getmat(ll t0, ll t1, int c) {
    mat_t m;
    m.init();
    if (c == 1) {
        m[0][0] = m[1][1] = m[2][0] = m[3][1] = t0;
        m[0][2] = m[1][3] = t1;
    } else {
        m[0][0] = m[1][0] = m[2][2] = m[3][2] = t0;
        m[0][1] = m[2][3] = t1;
    }
    return m;
}

namespace $yzh {

#define ls (u << 1)
#define rs (u << 1 | 1)

mat_t tr[N << 2];

void _upd(int u, int l, int r, int p, const mat_t& mat) {
    if (l == r) {
        tr[u] = mat;
        return;
    }
    int mid = (l + r) >> 1;
    if (p <= mid) _upd(ls, l, mid, p, mat);
    else _upd(rs, mid + 1, r, p, mat);
    tr[u] = tr[rs] * tr[ls];
}

mat_t _qry(int u, int trl, int trr, int l, int r) {
    if (l <= trl && trr <= r) return tr[u];
    int mid = (trl + trr) >> 1;
    if (r <= mid) return _qry(ls, trl, mid, l, r);
    if (l >  mid) return _qry(rs, mid + 1, trr, l, r);
    return _qry(rs, mid + 1, trr, l, r) * _qry(ls, trl, mid, l, r);
}

void upd(int p, const mat_t& mat) { _upd(1, 1, n, p, mat); }
mat_t query(int l, int r) { return _qry(1, 1, n, l, r); }

#undef ls
#undef rs

}

ll f[2][N];

void redfs(int u, int tp) {
    top[u] = tp;
    tail[tp] = u;
    if (u <= n) {
        L[u] = timer + 1;
        ll f0 = 0, f1 = val[u];
        if (son[u]) redfs(son[u], tp);
        for (int i = T.head[u]; i; i = T.edge[i].nxt) {
            int v = T.edge[i].v;
            if (v == son[u]) continue;
            redfs(v, v);
            mat_t res = beginst * $yzh::query(L[v], idx[tail[v]]);
            res = res * getmat(0, 0, 1) * ans2init;
            f0 += res[0][0];
            f1 += res[0][3];
        }
        f[0][u] = f0;
        f[1][u] = f1;
        if (typ[u] != 0) {
            if (son[u]) {
                mat_t res = beginst * $yzh::query(L[son[u]], idx[tail[u]]);
                res = res * getmat(0, 0, 1) * ans2init;
                f0 += res[0][0], f1 += res[0][3];
            }
            /*
            also:
            mat_t res = beginst;
            if (son[u])
                res = res * $yzh::query(L[son[u]], idx[tail[u]]);
            res = res * getmat(f0, f1, 1) * ans2init;
            f0 = res[0][0], f1 = res[0][3];
            */
            
            $yzh::upd(idx[u], getmat(f0, f1, typ[u]));
        } else {
            $yzh::upd(idx[u], getmat(f0, f1, 1) * ans2init);
        }
        R[u] = timer;
    } else {
        L[u] = timer + 1;
        static int stk[N];
        int top = 0, i;
        for (i = T.head[u]; i; i = T.edge[i].nxt) {
            int v = T.edge[i].v;
            if (v == son[u]) break;
            dfn[idx[v] = ++timer] = v;
            typ[v] = 2;
        }
        for (i = T.edge[i].nxt; i; i = T.edge[i].nxt) {
            int v = T.edge[i].v;
            stk[++top] = v;
        }
        while (top) {
            int v = stk[top--];
            dfn[idx[v] = ++timer] = v;
            typ[v] = 1;
        }
        dfn[idx[son[u]] = ++timer] = son[u];
        typ[son[u]] = 0;
        R[u] = timer;
        redfs(son[u], tp);
        for (int i = T.head[u]; i; i = T.edge[i].nxt) {
            int v = T.edge[i].v;
            if (v == son[u]) continue;
            redfs(v, v);
        }
    }
}

void solve() {
    mat_t res = beginst * $yzh::query(idx[1], idx[tail[1]]);
    ll t0 = res[0][0], t1 = res[0][3];
    ll ans = max(t0, t1);
#ifdef XuYueming
    printf(">>>>>>>>>>>>>> ");
#endif
    printf("%lld\n", ans);
}

void modify(int u, int w) {
    mat_t lst;
    bool flag = false;
    {
        f[1][u] += w - val[u], val[u] = w;
        int v = top[u];
        if (v > n)
            lst = $yzh::query(L[v], idx[tail[v]]);
        else if (u == v) {
            int p = top[fa[v]];
            if (p > n)
                lst = $yzh::query(L[p], idx[tail[p]]), flag = true;
        }
        ll f0 = f[0][u], f1 = f[1][u];
        if (typ[u] != 0) {
            mat_t res = beginst;
            if (son[u])
                res = res * $yzh::query(L[son[u]], idx[tail[u]]);
            res = res * getmat(f0, f1, 1) * ans2init;
            $yzh::upd(idx[u], getmat(res[0][0], res[0][3], typ[u]));
        } else {
            $yzh::upd(idx[u], getmat(f0, f1, 1) * ans2init);
        }
    }
    while (top[u] != 1) {
        int v = top[u];
        int w = fa[v];
        
        if (v > n) {
            assert(flag == false);
            ll &f0 = f[0][w], &f1 = f[1][w];
            {
                mat_t res = beginst * lst;
                res = res * getmat(0, 0, 1) * ans2init;
                f0 -= res[0][0];
                f1 -= res[0][3];
            }
            {
                mat_t res = beginst * $yzh::query(L[v], idx[tail[v]]);
                res = res * getmat(0, 0, 1) * ans2init;
                f0 += res[0][0];
                f1 += res[0][3];
            }
            int p = top[w];
            if (p > n)
                lst = $yzh::query(L[p], idx[tail[p]]);
            else if (w == p) {
                p = top[fa[p]];
                if (p > n) {
                    lst = $yzh::query(L[p], idx[tail[p]]), flag = true;
                }
            }
            if (typ[w] != 0) {
                mat_t res = beginst;
                if (son[w])
                    res = res * $yzh::query(L[son[w]], idx[tail[w]]);
                res = res * getmat(f0, f1, 1) * ans2init;
                $yzh::upd(idx[w], getmat(res[0][0], res[0][3], typ[w]));
            } else {
                $yzh::upd(idx[w], getmat(f0, f1, 1) * ans2init);
            }
        } else {
            ll f0 = f[0][v], f1 = f[1][v];
            assert(typ[v] != 0);
            int p = top[w];
            if (p > n) {
                assert(flag == (u == v));
                if (flag) flag = false;
                else lst = $yzh::query(L[p], idx[tail[p]]);
            }
            mat_t res = beginst;
            if (son[v])
                res = res * $yzh::query(L[son[v]], idx[tail[v]]);
            res = res * getmat(f0, f1, 1) * ans2init;
            f0 = res[0][0], f1 = res[0][3];
            $yzh::upd(idx[v], getmat(f0, f1, typ[v]));
        }
        u = w;
    }
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1, u, v; i <= m; ++i) {
        scanf("%d%d", &u, &v);
        G.add(u, v), G.add(v, u);
    }
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &val[i]);
    }
    $build::tarjan(1, 0);
    dfs(1);
    dfn[idx[1] = ++timer] = 1;
    typ[1] = 0;
    redfs(1, 1);
    
    scanf("%d", &q);
    solve();
    for (int u, w; q--; ) {
        scanf("%d%d", &u, &w);
        modify(u, w);
        solve();
    }
    return 0;
}

/*
15:25        static tree
day2 10:11   static cactus
day2 20:55   dynamic cactus
*/

Gen

#include <cstdio>
#include <iostream>
#include <vector>
#include <random>
#include <chrono>
using namespace std;

/* =========== Parameter =========== */

const int SEED = chrono::system_clock::now().time_since_epoch().count();

bool multiedge = true;
bool onlyOddCircle = false;

int MULTI_P = 50;

// int LEN = 1e4;
// int LEN = 4;

/* =========== Parameter =========== */

void _err(const char* msg, int lineNum) {
    fprintf(stderr, "Error at line #%d: %s\n", lineNum, msg);
    exit(1);
}
#define err(msg) _err(msg, __LINE__)

inline int rand(int l, int r) {
    static mt19937 rnd(SEED);
    if (l > r) err("invalid range");
    return l + rnd() % (r - l + 1);
}

int n = rand(99990, 100000);
int q = 100000;
int ROUND = 5;
int LEN = rand(1000, 1314);

// int n = rand(9500, 10000);
// // int n = 20;
// int q = 100000;
// int ROUND = 5;

// int LEN = rand(3, 1314);

int m_limit = -1;  // -1 for not limit

vector<pair<int, int>> edges;
vector<vector<int>> son(n, vector<int>());
vector<int> dpt(n);

int maxcir = LEN;
int chong = 0;

void dfs(int u) {
    for (size_t i = 0; i < son[u].size(); ++i) {
        int v = son[u][i];
        dpt[v] = dpt[u] + 1;
        dfs(v);
    }
}

int redfs(int u, int ban) {
    int res = u;
    int cnt = 0;
    for (size_t i = 0; i < son[u].size(); ++i) {
        int v = son[u][i];
        dpt[v] = dpt[u] + 1;
        if (v == ban) continue;
        int t = redfs(v, -1);
        int len = dpt[t] - dpt[u] + 1;
        if ((t != v || (multiedge && cnt < 2 && rand(0, MULTI_P) == 0))
                && (len % 2 == 1 || !onlyOddCircle)
                && (m_limit == -1 || (int)edges.size() < m_limit))
            edges.emplace_back(u, t), cnt += t == v, maxcir = max(maxcir, len), chong += t == v;
        else if (rand(0, son[u].size()) == 0 || dpt[t] > dpt[res])
            res = t;
    }
    return res;
}

int main() {
    // freopen(".\\testdata\\4.in", "w", stdout);
    
    // freopen("yzh", "w", stdout);
    // freopen("in", "w", stdout);
    
    if (n < 1) err("n shouldn't be less than 1");
    if (m_limit != -1 && m_limit < n - 1)
        err("m_limit shouldn't less than n-1");
    if (LEN > n)
        err("LEN too long");
    
    vector<int> id(n);
    for (int i = 0; i < n; ++i) id[i] = i;
    for (int i = 1; i < n; ++i)
        swap(id[i], id[rand(0, i)]);
    
    for (int i = 1; i < LEN; ++i) {
        int fa = i - 1;
        edges.emplace_back(fa, i);
        son[fa].emplace_back(i);
    }
    for (int i = LEN; i < n; ++i) {
        int fa = rand(0, i - 1);
        edges.emplace_back(fa, i);
        son[fa].emplace_back(i);
    }
    if (LEN > 1 && m_limit != n - 1) {
        edges.emplace_back(0, LEN - 1);
    }
    dfs(0);
    for (int i = 1; i < LEN; ++i)
        redfs(i - 1, i);
    redfs(LEN - 1, -1);
    
    for (size_t i = 1; i < edges.size(); ++i)
        swap(edges[i], edges[rand(0, i)]);
    
    printf("%d %d\n", n, (int)edges.size());
    for (size_t i = 0; i < edges.size(); ++i) {
        int u = edges[i].first;
        int v = edges[i].second;
        if (rand(0, 1)) swap(u, v);
        u = id[u], v = id[v];
        printf("%d %d\n", u + 1, v + 1);
    }
    
    const int maxV = 1e9;
    const int minV = 100;
    
    for (int i = 1; i <= n; ++i)
        printf("%d%c", rand(0, minV), " \n"[i == n]);
    
    printf("%d\n", q);
    if (ROUND) {
        if (q % (ROUND * 2)) throw;
        int t = q / (ROUND * 2);
        vector<int> vec;
        while (t--) {
            for (int i = 1; i <= ROUND; ++i) {
                int u = rand(1, n);
                printf("%d %d\n", u, rand(0, maxV));
                vec.emplace_back(u);
            }
            for (int i = 1; i <= ROUND; ++i) {
                if (rand(0, 1000) && !vec.empty()) {
                    int u = vec.back();
                    vec.pop_back();
                    printf("%d %d\n", u, rand(0, minV));
                } else {
                    int u = rand(1, n);
                    printf("%d %d\n", u, rand(0, maxV));
                    vec.emplace_back(u);
                }
            }
        }
    } else {
        for (int i = 1; i <= q; ++i) {
            printf("%d %d\n", rand(1, n), rand(0, maxV));
        }
    }
    
    fprintf(stderr, "Success!\n");
    fprintf(stderr, "n = %d, m = %d\n", n, (int)edges.size());
    fprintf(stderr, "circle = %d\n", (int)edges.size() - (n - 1));
    fprintf(stderr, "maxcir = %d\n", maxcir);
    fprintf(stderr, "chong = %d\n", chong);
    return 0;
}

#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
#include <random>
#include <chrono>
using namespace std;

const int SEED = chrono::system_clock::now().time_since_epoch().count();

inline int rand(int l, int r) {
    static mt19937 rnd(SEED);
    if (l > r) throw "invalid range";
    return l + rnd() % (r - l + 1);
}

int q = 1e5;
int ROUND = 5;

int n = 1e5, pts;
vector<pair<int, int>> edges;

int solve(int tot) {
    if (tot == 1)
        return ++pts;
    --tot;
    int du;
    if (rand(0, 4)) du = 2;
    else if (rand(0, 3)) du = 3;
    else du = 4;
    if (du > tot) du = tot;
    int one = tot / du;
    int u = ++pts;
    vector<int> son;
    for (int i = 1; i <= du - 1; ++i) {
        int v = solve(one);
        son.emplace_back(v);
    }
    {
        int v = solve(tot - (du - 1) * one);
        son.emplace_back(v);
    }
    edges.emplace_back(u, son.front());
    edges.emplace_back(son.back(), u);
    for (int i = 1; i < (int)son.size(); ++i)
        edges.emplace_back(son[i - 1], son[i]);
    return u;
}

int main() {
    solve(n);
    if (pts != n) throw;
    
    int m = edges.size();
    assert(n - 1 <= m && m <= 2 * (n - 1));
    
    for (size_t i = 1; i < edges.size(); ++i) {
        swap(edges[i], edges[rand(0, i)]);
    }
    
    vector<int> id(n);
    for (int i = 0; i < n; ++i) id[i] = i;
    for (int i = 1; i < n; ++i) {
        swap(id[i], id[rand(0, i)]);
    }
    
    printf("%d %d\n", n, (int)edges.size());
    for (size_t i = 0; i < edges.size(); ++i) {
        int u = edges[i].first;
        int v = edges[i].second;
        if (rand(0, 1)) swap(u, v);
        u = id[u - 1], v = id[v - 1];
        printf("%d %d\n", u + 1, v + 1);
    }
    
    const int maxV = 1e9;
    const int minV = 100;
    
    for (int i = 1; i <= n; ++i)
        printf("%d%c", rand(0, minV), " \n"[i == n]);
    
    printf("%d\n", q);
    if (q % (ROUND * 2)) throw;
    int t = q / (ROUND * 2);
    vector<int> vec;
    while (t--) {
        for (int i = 1; i <= ROUND; ++i) {
            int u = rand(1, n);
            printf("%d %d\n", u, rand(0, maxV));
            vec.emplace_back(u);
        }
        for (int i = 1; i <= ROUND; ++i) {
            if (rand(0, 1000) && !vec.empty()) {
                int u = vec.back();
                vec.pop_back();
                printf("%d %d\n", u, rand(0, minV));
            } else {
                int u = rand(1, n);
                printf("%d %d\n", u, rand(0, maxV));
                vec.emplace_back(u);
            }
        }
    }
    
    fprintf(stderr, "Success!\n");
    fprintf(stderr, "n = %d, m = %d\n", n, (int)edges.size());
    fprintf(stderr, "circle = %d\n", (int)edges.size() - (n - 1));
    return 0;
}

类型六：动态仙人掌

删边连边，保证操作前后都是森林，这类动态树问题，我们使用 LCT，SATT 等方式维护原树。

删边连边，保证操作前后都是沙漠，这类动态仙人掌问题，我们使用 LCT，SATT 等方式维护圆方树。

笔者能力有限，以后有时间再来补这一部分。

拓展：多层仙人掌

既然仙人掌的形态很像把树上节点替换成环，我们可以尝试把树上每个节点换成一棵仙人掌，如此进行下去，得到多层仙人掌的结构。

熟悉了仙人掌，其实这种结构无非是仙人掌的小拓展罢了，可以使用类似的算法解决。

圆方树在「一般无向图」上的应用

相信你已经掌握了如何使用圆方树解决仙人掌的问题，接下来我们将更进一步，学习如何在一般无向图上应用圆方树。

相比仙人掌而言，一般无向图并没有许多良好的性质，问题并不难于仙人掌上对应类型的问题。

类型一：单次询问整体信息

例十一、APIO2018 铁人两项（洛谷） Problem Statement

给你一张有 \(n\) 个点和 \(m\) 条边的无向图，你需要统计有序三元组 \((s,c,f)\) 的个数，且需要满足存在一条简单路径依次经过 \(s,c,f\)。简单路径指不重复经过点的路径。

\(n\leq 10^5\)，\(m\leq 2\times 10^5\)。
Problem Analysis

考虑在树上统计三元组的个数。不妨将 \(s,f\) 视为地位相等的「端点」，最后答案乘以二即可。设 \(g_u\) 表示 \(u\) 子树中选出一个端点的方案数，其实就是 \(u\) 为根的子树大小。再设 \(f_u\) 表示 \(u\) 子树中选出一个端点 \(v\)，再在 \(v\sim u\) 这条路径上选出中间点 \(c\) 的方案数。\(g\) 的转移显然。\(f\) 的转移也很简单，分为选不选择 \(u\) 为 \(c\) 两种情况讨论。对于一个 \(v\in \operatorname{son}(u)\)，若选择，\(f_u\Leftarrow g_v\)；若不选择，\(f_u\Leftarrow f_v\)。其中 \(a\Leftarrow b\) 表示 \(a\gets a+b\)。那么如何统计答案呢？我们考虑不断合并子树的过程，\(f_u,g_u\) 的含义为 \(u\) 和已经考虑过的子树，构成的一棵以 \(u\) 为根子树的信息。注意这个子树和传统意义上以 \(u\) 为根的子树之间的区别。考虑这个子树和一个没被合并进来的，以 \(v\) 为根的子树，它们之间对答案产生的贡献。显然就是 \(f_u\cdot g_v+f_v\cdot g_u\)，加号前表示 \(c\) 落在以 \(u\) 为根的子树中，加号后表示 \(c\) 落在以 \(v\) 为根的子树中，然后运用加法原理即可，这是不重不漏的。

放到无向图上呢？我们考虑无非就是选取 \(c\) 的这一步变得有些复杂------在一个点双中选点而不是在一个点上选点。分为如何转移和如何统计答案两部分思考。记这个点双大小为 \(m\)。转移很不难想到，设方点的父亲圆点为 \(u\)，某一个孩子圆点为 \(v\)，\(g_u\Leftarrow g_v\)，\(f_u\Leftarrow f_v + (m-1)g_v\)，这里 \(m-1\) 的系数表示，\(c\) 可以选择除了 \(v\) 以外任意一个点双中的点，对于 \(c=v\) 的情况已经统计在 \(f_v\) 内了。我们先考虑暴力统计答案，枚举 \(m\) 个圆点中两个不同的圆点 \(u,v\)，然后一样按照 \(c\) 放在哪里分类讨论。\(c\) 在 \(u\) 那一边，\(ans\Leftarrow g_u\cdot f_v\)；\(c\) 在 \(v\) 那一边，\(ans\Leftarrow g_v\cdot f_u\)；\(c\) 在点双中除了 \(u,v\) 其他的点上，\(ans\Leftarrow g_u\cdot g_v \cdot(m-2)\)。优化到线性也很简单，用类似前缀和的方法维护 \(\sum f_v\) 和 \(\sum g_v\) 即可。

时空复杂度 \(\mathcal{O}(n+m)\)。

注意此题坑点：图可能不连通，对每一个连通块做一遍即可。
Solution

#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;

const int N = 1e5 + 10;
const int M = 2e5 + 10;

int n, m;

struct node {
    int v, nxt;
} edge[M << 1];
int head[N], tot = 1;
void add(int u, int v) {
    edge[++tot] = { v, head[u] };
    head[u] = tot;
}

int dfn[N], low[N], timer;
int stack[N], top;

long long f[N], g[N], ans;

void tarjan(int u, int fr) {
    g[u] = 1;
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = head[u]; i; i = edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = edge[i].v;
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                vector<int> scc;
                while (true) {
                    int x = stack[top--];
                    scc.emplace_back(x);
                    if (x == v) break;
                }
                scc.emplace_back(u);
                int m = scc.size();
                
                long long sf = 0, sg = 0;
                for (int j = 0; j < m; ++j) {
                    int u = scc[j];
                    ans += g[u] * sf + sg * f[u];
                    ans += (m - 2) * g[u] * sg;
                    sf += f[u], sg += g[u];
                }
                // for (int a = 0; a < m; ++a)
                //     for (int b = a + 1; b < m; ++b) {
                //         int u = scc[a], v = scc[b];
                //         ans += g[u] * f[v] + g[v] * f[u];
                //         ans += (m - 2) * g[u] * g[v];
                //     }
                
                for (int j = 0; j < m - 1; ++j) {
                    int v = scc[j];
                    g[u] += g[v];
                    f[u] += f[v] + (m - 1) * g[v];
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
        }
    }
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1, u, v; i <= m; ++i) {
        scanf("%d%d", &u, &v);
        add(u, v), add(v, u);
    }
    for (int u = 1; u <= n; ++u)
        if (!dfn[u])
            tarjan(u, 0);
    printf("%lld", ans << 1);
    return 0;
}

类型二：维护点对间所有简单路径信息

先来看一道经典的问题。
例十二、必经点个数（洛谷，类似问题 UVA，类似问题 hydro-bzoj-3331 压力） Problem Statement

给你一张有 \(n\) 个点和 \(m\) 条边的无向图，有 \(q\) 次询问，给出点对 \((u,v)\)，求从 \(u\) 经过一条简单路径到 \(v\)，必须经过的节点数。

\(n,q\leq 5\times10^5\)，\(m\leq10^6\)。
Problem Analysis

放到圆方树上，均被包含的点，就是圆方树上路径上的圆点。这是因为对于非端点的一个圆点，它作为割点是必定会被经过的。于是可以简单求解。

时间复杂度 \(\mathcal{O}(m+n+q\log n)\)，尽管可以优化到完全线性。
Solution

#include <cstdio>
#include <iostream>
using namespace std;

const int N = 5e5 + 10;
const int M = 1e6 + 10;
const int lg2N = __lg(N << 1) + 1;

int n, m, q;

template <size_t _N, size_t _M>
class Graph {
public:
    Graph(): tot(1) {}
    struct node {
        int v, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v) {
        edge[++tot] = { v, head[u] };
        head[u] = tot;
    }
};

Graph<N, M << 1> G;
Graph<N << 1, N << 1> T;  // 圆方树

int dfn[N], low[N], timer;
int stack[N], top;

int dcc_cnt;
int pre[N << 1];

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                ++dcc_cnt;
                T.add(u, dcc_cnt + n);
                while (true) {
                    int x = stack[top--];
                    T.add(dcc_cnt + n, x);
                    if (x == v) break;
                }
            }
        } else {
            low[u] = min(low[u], dfn[v]);
        }
    }
}

int fa[N << 1], dpt[N << 1];
int idx[N << 1], st[lg2N][N << 1];
void dfs(int u) {
    pre[u] = pre[fa[u]] + (u <= n);
    st[0][idx[u] = ++timer] = u;
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        fa[v] = u;
        dpt[v] = dpt[u] + 1;
        dfs(v);
    }
}
inline int Min(int u, int v) {
    return dpt[u] < dpt[v] ? u : v;
}
inline int lca(int u, int v) {
    if (u == v) return u;
    if ((u = idx[u]) > (v = idx[v]))
        swap(u, v);
    int k = __lg(v - u++);
    return fa[Min(st[k][u], st[k][v - (1 << k) + 1])];
}
// O(n log n) ~ O(1) LCA

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1, u, v; i <= m; ++i) {
        scanf("%d%d", &u, &v);
        G.add(u, v), G.add(v, u);
    }
    tarjan(1, 0);
    timer = 0, dfs(1);
    for (int k = 1; k < lg2N; ++k)
        for (int i = 1; i + (1 << k) - 1 <= timer; ++i)
            st[k][i] = Min(st[k - 1][i], st[k - 1][i + (1 << (k - 1))]);
    scanf("%d", &q);
    for (int u, v; q--; ) {
        scanf("%d%d", &u, &v);
        int p = lca(u, v);
        int ans = pre[u] + pre[v] - pre[p] - pre[fa[p]];
        printf("%d\n", ans);
    }
    return 0;
}

接下来看一道典型的圆方树维护点对间所有简单路径信息的问题。
例十三、ZJOI2022 简单题（洛谷、UOJ） Problem Statement

一张 \(n\) 个点、\(m\) 条边的无重边无自环连通无向图，带有正整数边权。

一开始图上任意两个简单环的边权和相等。后来其中一部分边的权值改成了新的权值，因此，修改后的图可能没有这个性质。

现在给出修改后的图，同时给出多组询问，每次询问两点 \(S, T\) 间所有简单路径权值和对 \(998244353\) 取模的结果。

简单环和简单路径指不包含重复节点。

\(1 \le n, q \le 5 \times {10}^5\)，\(n - 1 \le m \le 6.4 \times {10}^5\)。
Problem Analysis

一道好题，关键在于分析出图的性质，否则无从下手。
这张图一开始任意两个简单环的边权和相等，这对这张图的形态做了限制，也就是说存在一种赋边权的方式，满足这个条件。

对于每一个点双考虑，因为简单环显然不会横跨两个点双，所以只会对点双内部的结构产生约束。接下来由简单到复杂，确定一个点双可能的形态。

1. 这个点双没有简单环。

   也即两个点被一条边连接的情况，显然合法。

2. 这个点双是一个简单环。

   显然合法。

3. 这个点双在一个简单环的基础上多了一条简单链。

   我们假设多出的一条链的两端是 \(S, T\)。那么他们之间就被三条简单路径连接。为了方便起见，我们把这三条链看做是连接 \(S, T\) 的三条边，边权对应简单链的边权和。

   

   我们只需要说明，存在一种给 \(w_1, w_2, w_3\) 赋权的方式，使得任意两个简单环的边权和相等。

   图上有三个简单环，设边权和分别为 \(s_1, s_2, s_3\)，有：

   \\\begin{cases} s_1=w_1+w_2 \\\\ s_2=w_1+w_3 \\\\ s_3=w_2+w_3 \\end{cases} \\

   只需令 \(w_1=w_2=w_3=k\)，其中 \(k\) 为任意正整数，就能使 \(s_1=s_2=s_3\)。

4. 这个点双在一个简单环的基础上，多了若干条以 \(S,T\) 为端点的简单链。

   类比 case 3 的推导，只需令 \(w_1=w_2=\cdots=w_t=k\)，其中 \(k\) 为任意正整数，就能使 \(s_1=s_2=\cdots=s_t\)。

5. 这个点双在一个简单环的基础上，多了两条不共端点的平行简单链。

   形如：

   

   类似地，这里存在六个环：

   \\\begin{cases} s_1=w_1+w_2 \\\\ s_2=w_3+w_4 \\\\ s_3=w_2+w_3+w_5+w_6 \\\\ s_4=w_2+w_3+w_5+w_6 \\\\ s_5=w_1+w_3+w_5+w_6 \\\\ s_6=w_2+w_4+w_5+w_6 \\\\ \\end{cases} \\

   令 \(w_1=w_2=w_3=w_4=w_5=w_6\)，看看能不能导出什么矛盾。手玩一会后发现，由 \(s_1+s_2=s_5+s_6\)，得到 \(w_5+w_6=0\)，而我们的边权都是正整数，所以这是不合法的。

   也就是说，一个点双的结构不可能是这样。有趣的是，如果我们令 \(w_5=w_6=0\)，那么这张图相当于退化成了 case 4 中 \(4\) 条链的情况，这似乎在暗示我们 case 4 或许就是我们要找的性质。

6. 这个点双在一个简单环的基础上，多了若干条不共端点的平行简单链。

   一定能得到类似 case 5 中的若干条等式，从而导出不可能。

7. 这个点双在一个简单环的基础上，多了两条不共端点的相交简单链。

   形如：

   

   这里同样存在六个环：

   \\\begin{cases} s_1=w_1+w_2+w_5 \\\\ s_2=w_1+w_3+w_6 \\\\ s_3=w_3+w_4+w_5 \\\\ s_4=w_2+w_4+w_6 \\\\ s_5=w_1+w_4+w_5+w_6 \\\\ s_6=w_2+w_3+w_5+w_6 \\\\ \\end{cases} \\

   类似根据 \(s_1+s_2=s_5+s_6\) 得到 \(w_6=0\)，根据对称性同样有 \(w_5=0\)，这也是不合法的，而且退化后的图也是 case 4 中 \(4\) 条链的情况。

8. 这个点双在一个简单环的基础上，多了若干条不共端点的相交简单链。

   一定能得到类似 case 7 中的若干条等式，从而导出不可能。

9. 这个点双在一个简单环的基础上，多了若干条不共端点的平行简单链，或相交简单链。

   一定能得到类似 case 5 或 case 7 中的若干条等式，从而导出不可能。

从而，我们证明了，只有 case 1、case 2、case 3、case 4 这几种点双的形态是合法的，进一步全部都可以归纳到 case 4 中：存在两个点 \(S,T\)，他们之间连了若干条简单链。\(1,2,3\) 条链分别退化到 case 1、case 2、case 3。

每个点双的形态就是确定的了：

这种图似乎被称作「杏仁」，无论如何，这是一个关键的性质。

肯定需要上圆方树了。

根据经验，不难想到把 \((c,s)\) 这样的二元组作为所求信息，其中 \(c\) 表示简单路径条数，\(s\) 表示这些简单路径的边权总和。两个信息 \((c_1,s_1),(c_2,s_2)\) 合并后的结果即为 \((c_1c_2,c_1s_2+c_2s_1)\)。单位元即为 \((1,0)\)。

考虑 \(u\rightarrow v\) 的原子信息怎么求。记这个点双中 \(S,T\) 间有 \(c\) 条简单路径，边权和为 \(s\)，对于不为 \(S,T\) 的点 \(u\)，定义 \(\operatorname{from}(u)\) 表示 \(u\) 在 \(c\) 条简单路径中的哪一条上，\(\operatorname{disS}(u)\) 表示 \(S\) 通过 \(\operatorname{from}(u)\) 到 \(u\) 的距离，\(\operatorname{depthS}(u)\) 类似表示 \(S\) 通过 \(\operatorname{from}(u)\) 到 \(u\) 的边的条数，类似定义 \(\operatorname{disT}(u),\operatorname{depthT}(u)\)。接下来分类讨论。

1. \(u=S,v=T\)：

   信息即为 \((c,s)\)。

2. \(u=S,v\neq T\)：
   

   信息为 \(\Big(c,s+\operatorname{disT}(v)\cdot(c-1-1)\Big)\)，\(c-1-1\) 表示 \(v\rightarrow T\) 这条边被 \(c-1\) 条路径经过，但是已经在 \(s\) 中贡献了一次，所以是 \(c-1-1\)。

3. \(u,v\not\in\{S,T\},\operatorname{from}(u)=\operatorname{from}(v),\operatorname{depthS}(u)\leq\operatorname{depthS}(v)\)：
   

   信息为 \(\Big(c,s+(\operatorname{disT}(v)+\operatorname{disS}(u))\cdot(c-1-1)\Big)\)。

4. \(u,v\not\in\{S,T\},\operatorname{from}(u)\neq\operatorname{from}(v)\)：
   

   信息为 \(\Big(2c-2, 2s + (\operatorname{disS}(u)+\operatorname{disT}(u))\cdot(c-1-2) + (\operatorname{disS}(v)+\operatorname{disT}(v))\cdot(c-1-2)\Big)\)。

剩下的情况都是对称的，此略去。

至于如何求出这些信息，只需要把点双的子图建出来，这就是前文仙人掌部分提到的弹边栈的方式，在弹出一条边的时候，在另一张图上加边。这另一张图就是这个点双的子图，根据度数找出 \(S,T\) 后，就可以方便处理出其他信息了。

于是我们可以套用圆方树多次询问点对信息的模式方便求解。

这个信息显然满足交换律，所以不需要考虑合并信息的顺序。

在了解圆方树后，这份代码实现起来并不困难。

时间复杂度 \(\mathcal{O}(m+n\log n+q\log n)\)。
Solution 圆方树

#include <cstdio>
#include <iostream>
using namespace std;

const int mod = 998244353;
const int N = 5e5 + 10;
const int M = 6.4e5 + 10;
const int N2 = N << 1;
const int lg2N = __lg(N2) + 1;

int n, m, q;

inline int add(int a, int b) {
    return a += b, a >= mod ? a - mod : a;
}
inline int mul(int a, int b) {
    return 1ll * a * b % mod;
}

struct node {
    int cnt, sum;
    friend node operator * (const node& a, const node& b) {
        return {
            mul(a.cnt, b.cnt),
            add(mul(b.cnt, a.sum), mul(a.cnt, b.sum))
        };
    }
};

template <size_t _N, size_t _M, typename T = int>
class Grpah {
public:
    Grpah(): tot(1) {}
    struct node {
        int v, nxt;
        T w;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v, const T& w) {
        edge[++tot] = { v, head[u], w };
        head[u] = tot;
    }
};
Grpah<N, M << 1> G;  // original grpah
Grpah<N << 1, N << 1, node> T;  // rebuild tree
Grpah<N, M << 1> SG;  // sub graph

int dfn[N], low[N], timer;
int est[N], etp;
int sccno[N], scc_cnt, scc_siz[N];
int _du[N], _scc[N], _siz;

int A[N], B[N];
int esum[N];
int pathCnt[N];
int from[N], dptS[N];
int disT[N], disS[N];

void getFromDisS(int x, int T, int fr) {
    for (int i = SG.head[x]; i; i = SG.edge[i].nxt) {
        int v = SG.edge[i].v;
        int w = SG.edge[i].w;
        if (v == fr || v == T) continue;
        disS[v] = add(disS[x], w);
        dptS[v] = dptS[x] + 1;
        from[v] = from[x];
        getFromDisS(v, T, x);
    }
}

void getDisT(int x, int S, int fr) {
    for (int i = SG.head[x]; i; i = SG.edge[i].nxt) {
        int v = SG.edge[i].v;
        int w = SG.edge[i].w;
        if (v == fr || v == S) continue;
        disT[v] = add(disT[x], w);
        getDisT(v, S, x);
    }
}

node getdis(int u, int v, int s) {
    if (u == v) return { 1, 0 };
    int frU = from[u], frV = from[v];
    int disSU = disS[u], disSV = disS[v];
    int disTU = disT[u], disTV = disT[v];
    int du = dptS[u], dv = dptS[v];
    int S = A[s], T = B[s];
    int sum = esum[s];
    int pcnt = pathCnt[s];
    if (u == S && v == T)
        return { pcnt, sum };
    if (v == S && u == T)
        return { pcnt, sum };
    if (u == S)
        return { pcnt, add(sum, mul(disTV, pcnt - 1 - 1)) };
    if (u == T)
        return { pcnt, add(sum, mul(disSV, pcnt - 1 - 1)) };
    if (v == S)
        return { pcnt, add(sum, mul(disTU, pcnt - 1 - 1)) };
    if (v == T)
        return { pcnt, add(sum, mul(disSU, pcnt - 1 - 1)) };
    if (frU == frV) {
        if (du < dv)
            return { pcnt, add(sum, mul(add(disSU, disTV), pcnt - 1 - 1)) };
        else
            return { pcnt, add(sum, mul(add(disSV, disTU), pcnt - 1 - 1)) };
    }
    return { (pcnt - 1) * 2, add(mul(sum, 2), add(mul(add(disSU, disTU), pcnt - 1 - 2), mul(add(disSV, disTV), pcnt - 1 - 2))) };
}

void deal(int p) {
    A[p] = B[p] = -1;
    for (int i = 0; i < _siz; ++i) {
        int u = _scc[i];
        if (_du[u] <= 2) continue;
        if (A[p] == -1)
            A[p] = u;
        else {
            B[p] = u;
            break;
        }
    }
    if (A[p] == -1)
        A[p] = _scc[0], B[p] = _scc[1];
    int S = A[p], T = B[p];
    disS[S] = 0;
    dptS[S] = 0;
    for (int i = SG.head[S]; i; i = SG.edge[i].nxt) {
        ++pathCnt[p];
        int v = SG.edge[i].v;
        int w = SG.edge[i].w;
        if (v == T) continue;
        dptS[v] = 1;
        disS[v] = w;
        from[v] = v;
        getFromDisS(v, T, S);
    }
    disT[T] = 0;
    getDisT(T, S, 0);
}

int _vis[N], _vis_tim;
void insert(int u) {
    if (_vis[u] == _vis_tim) return;
    _vis[u] = _vis_tim;
    _scc[_siz++] = u;
}

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            est[++etp] = i;
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                ++scc_cnt, ++_vis_tim, _siz = 0;
                SG.tot = 1;
                while (true) {
                    int x = est[etp--];
                    int u = G.edge[x    ].v;
                    int v = G.edge[x ^ 1].v;
                    int w = G.edge[x    ].w;
                    insert(u), insert(v);
                    ++_du[u], ++_du[v];
                    esum[scc_cnt] = add(esum[scc_cnt], w);
                    SG.add(u, v, w);
                    SG.add(v, u, w);
                    if (x == i) break;
                }
                deal(scc_cnt);
                for (int i = 0; i < _siz; ++i) {
                    int x = _scc[i];
                    if (x == u) continue;
                    T.add(scc_cnt + n, x, getdis(u, x, scc_cnt));
                }
                T.add(u, scc_cnt + n, { 1, 0 });
                
                _du[u] = SG.head[u] = 0;
            }
        } else {
            low[u] = min(low[u], dfn[v]);
            if (dfn[v] < dfn[u])
                est[++etp] = i;
        }
    }
}

int fa[lg2N][N << 1], dpt[N << 1];
node val[lg2N][N << 1];

void dfs(int u) {
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        fa[0][v] = u;
        val[0][v] = T.edge[i].w;
        dpt[v] = dpt[u] + 1;
        dfs(v);
    }
}

int query(int u, int v) {
    if (dpt[u] < dpt[v]) swap(u, v);
    node res = { 1, 0 };
    for (int i = lg2N - 1; ~i; --i)
        if (fa[i][u] && dpt[fa[i][u]] >= dpt[v]) {
            res = res * val[i][u];
            u = fa[i][u];
        }
    if (u == v) return res.sum;
    for (int i = lg2N - 1; ~i; --i)
        if (fa[i][u] != fa[i][v]) {
            res = res * val[i][u] * val[i][v];
            u = fa[i][u], v = fa[i][v];
        }
    if (fa[0][u] > n)
        res = res * getdis(u, v, fa[0][u] - n);
    else
        res = res * val[0][u] * val[0][v];  // this is not necessary
    return res.sum;
}

int main() {
#ifndef XuYueming
    // freopen("simple.in", "r", stdin);
    // freopen("simple.out", "w", stdout);
#endif
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1, u, v, w; i <= m; ++i) {
        scanf("%d%d%d", &u, &v, &w);
        G.add(u, v, w);
        G.add(v, u, w);
    }
    tarjan(1, 0);
    dfs(1);
    for (int k = 1; k < lg2N; ++k)
        for (int u = 1; u <= n + scc_cnt; ++u) {
            fa[k][u] = fa[k - 1][fa[k - 1][u]];
            if (fa[k][u])
                val[k][u] = val[k - 1][u] * val[k - 1][fa[k - 1][u]];
        }
    for (int u, v; q--; ) {
        scanf("%d%d", &u, &v);
        printf("%d\n", query(u, v));
    }
    return 0;
}

圆树

#include <cstdio>
#include <iostream>
using namespace std;

const int mod = 998244353;
const int N = 5e5 + 10;
const int M = 6.4e5 + 10;
const int lgN = __lg(N) + 1;

int n, m, q;

inline int add(int a, int b) {
    return a += b, a >= mod ? a - mod : a;
}
inline int mul(int a, int b) {
    return 1ll * a * b % mod;
}

struct node {
    int cnt, sum;
    friend node operator * (const node& a, const node& b) {
        return {
            mul(a.cnt, b.cnt),
            add(mul(b.cnt, a.sum), mul(a.cnt, b.sum))
        };
    }
};

template <size_t _N, size_t _M, typename T = int>
class Grpah {
public:
    Grpah(): tot(1) {}
    struct node {
        int v, nxt;
        T w;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v, const T& w) {
        edge[++tot] = { v, head[u], w };
        head[u] = tot;
    }
};
Grpah<N, M << 1> G;  // original grpah
Grpah<N, N, node> T;  // rebuild tree
Grpah<N, M << 1> SG;  // sub graph

int dfn[N], low[N], timer;
int est[N], etp;
int sccno[N], scc_cnt, scc_siz[N];
int _du[N], _scc[N], _siz;

int A[N], B[N];
int esum[N];
int pathCnt[N];
int from[N], dptS[N];
int disT[N], disS[N];

void getFromDisS(int x, int T, int fr) {
    for (int i = SG.head[x]; i; i = SG.edge[i].nxt) {
        int v = SG.edge[i].v;
        int w = SG.edge[i].w;
        if (v == fr || v == T) continue;
        disS[v] = add(disS[x], w);
        dptS[v] = dptS[x] + 1;
        from[v] = from[x];
        getFromDisS(v, T, x);
    }
}

void getDisT(int x, int S, int fr) {
    for (int i = SG.head[x]; i; i = SG.edge[i].nxt) {
        int v = SG.edge[i].v;
        int w = SG.edge[i].w;
        if (v == fr || v == S) continue;
        disT[v] = add(disT[x], w);
        getDisT(v, S, x);
    }
}

node getdis(int u, int v, int s) {
    if (u == v) return { 1, 0 };
    int frU = from[u], frV = from[v];
    int disSU = disS[u], disSV = disS[v];
    int disTU = disT[u], disTV = disT[v];
    int du = dptS[u], dv = dptS[v];
    int S = A[s], T = B[s];
    int sum = esum[s];
    int pcnt = pathCnt[s];
    if (u == S && v == T)
        return { pcnt, sum };
    if (v == S && u == T)
        return { pcnt, sum };
    if (u == S)
        return { pcnt, add(sum, mul(disTV, pcnt - 1 - 1)) };
    if (u == T)
        return { pcnt, add(sum, mul(disSV, pcnt - 1 - 1)) };
    if (v == S)
        return { pcnt, add(sum, mul(disTU, pcnt - 1 - 1)) };
    if (v == T)
        return { pcnt, add(sum, mul(disSU, pcnt - 1 - 1)) };
    if (frU == frV) {
        if (du < dv)
            return { pcnt, add(sum, mul(add(disSU, disTV), pcnt - 1 - 1)) };
        else
            return { pcnt, add(sum, mul(add(disSV, disTU), pcnt - 1 - 1)) };
    }
    return { (pcnt - 1) * 2, add(mul(sum, 2), add(mul(add(disSU, disTU), pcnt - 1 - 2), mul(add(disSV, disTV), pcnt - 1 - 2))) };
}

void deal(int p) {
    A[p] = B[p] = -1;
    for (int i = 0; i < _siz; ++i) {
        int u = _scc[i];
        if (_du[u] <= 2) continue;
        if (A[p] == -1)
            A[p] = u;
        else {
            B[p] = u;
            break;
        }
    }
    if (A[p] == -1)
        A[p] = _scc[0], B[p] = _scc[1];
    int S = A[p], T = B[p];
    disS[S] = 0;
    dptS[S] = 0;
    for (int i = SG.head[S]; i; i = SG.edge[i].nxt) {
        ++pathCnt[p];
        int v = SG.edge[i].v;
        int w = SG.edge[i].w;
        if (v == T) continue;
        dptS[v] = 1;
        disS[v] = w;
        from[v] = v;
        getFromDisS(v, T, S);
    }
    disT[T] = 0;
    getDisT(T, S, 0);
}

int _vis[N], _vis_tim;
void insert(int u) {
    if (_vis[u] == _vis_tim) return;
    _vis[u] = _vis_tim;
    _scc[_siz++] = u;
    sccno[u] = scc_cnt;
}

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            est[++etp] = i;
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                ++scc_cnt, ++_vis_tim, _siz = 0;
                SG.tot = 1;
                while (true) {
                    int x = est[etp--];
                    int u = G.edge[x    ].v;
                    int v = G.edge[x ^ 1].v;
                    int w = G.edge[x    ].w;
                    insert(u), insert(v);
                    ++_du[u], ++_du[v];
                    esum[scc_cnt] = add(esum[scc_cnt], w);
                    SG.add(u, v, w);
                    SG.add(v, u, w);
                    if (x == i) break;
                }
                deal(scc_cnt);
                for (int i = 0; i < _siz; ++i) {
                    int x = _scc[i];
                    if (x == u) continue;
                    T.add(u, x, getdis(u, x, scc_cnt));
                }
                _du[u] = SG.head[u] = 0;
            }
        } else {
            low[u] = min(low[u], dfn[v]);
            if (dfn[v] < dfn[u])
                est[++etp] = i;
        }
    }
}

int fa[lgN][N], dpt[N];
node val[lgN][N];

void dfs(int u) {
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        fa[0][v] = u;
        val[0][v] = T.edge[i].w;
        dpt[v] = dpt[u] + 1;
        dfs(v);
    }
}

int query(int u, int v) {
    if (dpt[u] < dpt[v]) swap(u, v);
    node res = { 1, 0 };
    for (int i = lgN - 1; ~i; --i)
        if (fa[i][u] && dpt[fa[i][u]] >= dpt[v]) {
            res = res * val[i][u];
            u = fa[i][u];
        }
    if (u == v) return res.sum;
    for (int i = lgN - 1; ~i; --i)
        if (fa[i][u] != fa[i][v]) {
            res = res * val[i][u] * val[i][v];
            u = fa[i][u], v = fa[i][v];
        }
    if (sccno[u] == sccno[v])
        res = res * getdis(u, v, sccno[u]);
    else
        res = res * val[0][u] * val[0][v];  // this is now necessary
    return res.sum;
}

int main() {
#ifndef XuYueming
    // freopen("simple.in", "r", stdin);
    // freopen("simple.out", "w", stdout);
#endif
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1, u, v, w; i <= m; ++i) {
        scanf("%d%d%d", &u, &v, &w);
        G.add(u, v, w);
        G.add(v, u, w);
    }
    tarjan(1, 0);
    dfs(1);
    for (int k = 1; k < lgN; ++k)
        for (int u = 1; u <= n; ++u) {
            fa[k][u] = fa[k - 1][fa[k - 1][u]];
            if (fa[k][u])
                val[k][u] = val[k - 1][u] * val[k - 1][fa[k - 1][u]];
        }
    for (int u, v; q--; ) {
        scanf("%d%d", &u, &v);
        printf("%d\n", query(u, v));
    }
    return 0;
}

接下来我们来看一道特殊的带修改的问题。
例十四、Tourists（Codeforces） Problem Statement

一张 \(n\) 个点、\(m\) 条边的连通无向图，带有点权。你需要支持：

1. 修改点权。
2. 询问 \(u,v\) 为端点的所有简单路径中，点权最小值的最小值。

\(1\leq n,m,q\leq 10^5\)。
Problem Analysis

方点在圆方树上的点权为，它的所有孩子圆点在原图上的点权的最小值。圆点的在圆方树上的点权为最小值的单位元，即 \(\infty\)。

给出树链剖分维护圆方树的实现方式。
Solution

#include <cstdio>
#include <iostream>
#include <set>
using namespace std;

const int N = 1e5 + 10;
const int M = 1e5 + 10;
const int NN = N << 1;
const int lg2N = __lg(NN) + 1;
const int inf = 0x3f3f3f3f;

int n, m, q, w[N];

template <size_t _N, size_t _M>
class Grpah {
public:
    Grpah(): tot(1) {}
    struct node {
        int v, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v) {
        edge[++tot] = { v, head[u] };
        head[u] = tot;
    }
};
Grpah<N, M << 1> G;  // original grpah
Grpah<N << 1, N << 1> T;  // rebuild tree

multiset<int> sss[N];  // 每个方点的数据结构
int scc_cnt;

namespace $build {

int dfn[N], low[N], timer;
int stack[N], top;

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                ++scc_cnt;
                while (true) {
                    int x = stack[top--];
                    T.add(scc_cnt + n, x);
                    sss[scc_cnt].insert(w[x]);
                    if (x == v) break;
                }
                T.add(u, scc_cnt + n);
            }
        } else {
            low[u] = min(low[u], dfn[v]);
        }
    }
}

}

namespace TREE {

#define lson (idx << 1)
#define rson (idx << 1 | 1)

int mi[NN << 2];

void build(int idx, int l, int r) {
    mi[idx] = inf;
    if (l == r) return;
    int mid = (l + r) >> 1;
    build(lson, l, mid);
    build(rson, mid + 1, r);
}

void modify(int idx, int trl, int trr, int p, int v) {
    if (trl == trr) return mi[idx] = v, void();
    int mid = (trl + trr) >> 1;
    if (p <= mid) modify(lson, trl, mid, p, v);
    else modify(rson, mid + 1, trr, p, v);
    mi[idx] = min(mi[lson], mi[rson]);
}

int query(int idx, int trl, int trr, int l, int r) {
    if (l <= trl && trr <= r) return mi[idx];
    int mid = (trl + trr) >> 1;
    if (r <= mid) return query(lson, trl, mid, l, r);
    if (l >  mid) return query(rson, mid + 1, trr, l, r);
    return min(query(lson, trl, mid, l, r), query(rson, mid + 1, trr, l, r));
}

#undef lson
#undef rson

}

int siz[NN], son[NN], top[NN];
int fa[NN], dpt[NN];
int idx[NN], timer;

void dfs(int u) {
    siz[u] = 1;
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        fa[v] = u;
        dpt[v] = dpt[u] + 1;
        dfs(v);
        siz[u] += siz[v];
        if (siz[v] > siz[son[u]])
            son[u] = v;
    }
}

void redfs(int u, int tp) {
    top[u] = tp;
    idx[u] = ++timer;
    if (u <= n)
        TREE::modify(1, 1, n + scc_cnt, idx[u], inf);  // 圆点设置为单位元
    else
        TREE::modify(1, 1, n + scc_cnt, idx[u], *sss[u - n].begin());
    if (son[u]) redfs(son[u], tp);
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        if (v == son[u]) continue;
        redfs(v, v);
    }
}

int query(int u, int v) {
    int res = inf;
    while (top[u] != top[v]) {
        if (dpt[top[u]] < dpt[top[v]])
            swap(u, v);
        res = min(res, TREE::query(1, 1, n + scc_cnt, idx[top[u]], idx[u]));
        u = fa[top[u]];
    }
    if (dpt[u] > dpt[v])
        swap(u, v);
    res = min(res, TREE::query(1, 1, n + scc_cnt, idx[u], idx[v]));
    if (u <= n) {
        res = min(res, w[u]);
    } else {
        if (fa[u])
            res = min(res, w[fa[u]]);
    }
    return res;
}

void modify(int u, int ww) {
    if (fa[u]) {
        int x = fa[u] - n;
        sss[x].erase(sss[x].find(w[u]));
        sss[x].insert(ww);
        TREE::modify(1, 1, n + scc_cnt, idx[x + n], *sss[x].begin());
    }
    w[u] = ww;
}

int main() {
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1; i <= n; ++i)
        scanf("%d", &w[i]);
    for (int i = 1, u, v; i <= m; ++i) {
        scanf("%d%d", &u, &v);
        G.add(u, v);
        G.add(v, u);
    }
    $build::tarjan(1, 0);
    TREE::build(1, 1, n + scc_cnt);
    dfs(1), redfs(1, 1);
    for (int u, v; q--; ) {
        char op[2];
        scanf("%s%d%d", op, &u, &v);
        if (*op == 'C')
            modify(u, v);
        else
            printf("%d\n", query(u, v));
    }
    return 0;
}

类型三：求给定点集的整体信息

来看一道没有显式建出虚树，而是利用虚树结构解决的问题。
例十五、SDOI2018 战略游戏（洛谷） Problem Statement

一张 \(n\) 个点、\(m\) 条边的连通无向图。

\(q\) 此询问，每次给出一个点集 \(S\)。你可以选择一个不在 \(S\) 中的点，如果存在 \(S\) 中两个点，在不经过你选择的这个点的前提下，不能够到达对方，那么这个方案就是合法的。求你有多少种选点的方案。

\(2\leq n\leq10^5\)，\(n-1\leq m\leq2\times10^5\)，\(1\leq q\leq10^5\)，\(\sum|S|\leq2\times10^5\)。
Problem Analysis

圆方树上，如果存在一个圆点，删去它之后的若干个连通块中，如果至少有两个连通块中都有 \(S\) 中的点，那么不在同一个连通块里的点就不能够互相到达，这个圆点就是合法的。

显然需要建出圆方树的虚树。观察下图，为 \(\{2,7,10\}\) 对应的虚树：

其中紫色圈出来的点表示贡献到答案里的点。我们不妨把 \(S\) 中的点先看做合法的，最后再减去他们。这样，我们就可以确定哪些圆点需要贡献到答案中去了。对于一条虚树上的树边 \((u,v)\)，圆方树上 \(u\rightarrow v\) 这条简单路径上的所有圆点都是合法的。正确性也十分显然。计数的话只需要做一遍树上前缀和就能单次 \(\mathcal{O}(1)\) 求出路径上有多少圆点。端点可能会重复统计？只需要在统计时，不统计父亲即可，因为父亲会恰好作为一次孩子被统计到，当然，除了根，那么最后看一下根是不是一个圆点即可。

时间复杂度 \(\mathcal{O}(m+n\log n+\sum|S|\log|S|)\)。

或者可以离线下来，配合 \(\mathcal{O}(n)\sim\mathcal{O}(1)\) LCA，做到 \(\mathcal{O}(|S|)\) 建立虚树，总的时间复杂度是线性 \(\mathcal{O}(m+n+\sum|S|)\)。
Solution

#include <cstdio>
#include <iostream>
#include <set>
#include <algorithm>
using namespace std;

const int N = 1e5 + 10;
const int M = 2e5 + 10;
const int NN = N << 1;
const int lg2N = __lg(NN) + 1;

int n, m, q;

template <size_t _N, size_t _M>
class Grpah {
public:
    Grpah(): tot(1) {}
    struct node {
        int v, nxt;
    } edge[_M];
    int head[_N], tot;
    void add(int u, int v) {
        edge[++tot] = { v, head[u] };
        head[u] = tot;
    }
};
Grpah<N, M << 1> G;  // original grpah
Grpah<N << 1, N << 1> T;  // rebuild tree

int scc_cnt;

namespace $build {

int dfn[N], low[N], timer;
int stack[N], top;

void tarjan(int u, int fr) {
    dfn[u] = low[u] = ++timer;
    stack[++top] = u;
    for (int i = G.head[u]; i; i = G.edge[i].nxt) {
        if (i == (fr ^ 1)) continue;
        int v = G.edge[i].v;
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v] >= dfn[u]) {
                ++scc_cnt;
                while (true) {
                    int x = stack[top--];
                    T.add(scc_cnt + n, x);
                    if (x == v) break;
                }
                T.add(u, scc_cnt + n);
            }
        } else {
            low[u] = min(low[u], dfn[v]);
        }
    }
}

}

int dpt[NN], fa[NN], timer;
int idx[NN], st[lg2N][NN];
int sum[NN];  // tree prefix sum, how many circle point

void dfs(int u) {
    st[0][idx[u] = ++timer] = u;
    for (int i = T.head[u]; i; i = T.edge[i].nxt) {
        int v = T.edge[i].v;
        dpt[v] = dpt[u] + 1;
        fa[v] = u;
        sum[v] = sum[u] + (v <= n);
        dfs(v);
    }
}
inline int Min(int a, int b) {
    return dpt[a] < dpt[b] ? a : b;
}
inline int lca(int u, int v) {
    if (u == v) return u;
    if ((u = idx[u]) > (v = idx[v])) swap(u, v);
    int k = __lg(v - u++);
    return fa[Min(st[k][u], st[k][v - (1 << k) + 1])];
}

void solve() {
    scanf("%d%d", &n, &m);
    for (int i = 1, u, v; i <= m; ++i) {
        scanf("%d%d", &u, &v);
        G.add(u, v);
        G.add(v, u);
    }
    $build::tarjan(1, 0);
    dfs(1);
    for (int k = 1; k < lg2N; ++k)
        for (int i = 1; i + (1 << k) - 1 <= n + scc_cnt; ++i)
            st[k][i] = Min(st[k - 1][i], st[k - 1][i + (1 << (k - 1))]);
    scanf("%d", &q);
    for (int i = 1, k; i <= q; ++i) {
        static int st[N << 1];
        scanf("%d", &k);
        for (int i = 1; i <= k; ++i)
            scanf("%d", &st[i]);
        sort(st + 1, st + k + 1, [] (int a, int b) {
            return idx[a] < idx[b];
        });
        for (int i = 1; i < k; ++i)
            st[k + i] = lca(st[i], st[i + 1]);
        sort(st + 1, st + k * 2, [] (int a, int b) {
            return idx[a] < idx[b];
        });
        int m = unique(st + 1, st + k * 2) - st - 1;
        int ans = 0;
        for (int i = 1; i < m; ++i) {
            int u = lca(st[i], st[i + 1]);
            int v = st[i + 1];
            ans += sum[v] - sum[u];
        }
        ans += st[1] <= n;
        ans -= k;
        printf("%d\n", ans);
    }
    for (int i = 1; i <= n; ++i) G.head[i] = 0, $build::dfn[i] = 0;
    for (int i = 1; i <= n + scc_cnt; ++i) T.head[i] = 0;
    G.tot = T.tot = 1;
    $build::top = $build::timer = 0;
    timer = scc_cnt = 0;
}

int main() {
    int t;
    scanf("%d", &t);
    while (t--) solve();
    return 0;
}

其他想讲的题目

例十五、同一点双？ Problem Statement

给你一个有 \(n\) 个点和 \(m\) 条边的无向图，和 \(q\) 组询问，每次询问两点 \(u,v\) 是否在同一点双内。

\(n\leq 10^5\)，\(m\leq 10^6\)，\(q\leq 10^6\)。
Problem Analysis

在经历了种种难题的洗礼，这一题就显得十分简单了。

两个点在同一个点双中，当且仅当存在一个连接他们的方点。

分类讨论可知，情况只有两种：其中一个是另一个的爷爷、其中一个是另一个的兄弟。前一种情况对应于一个是方点的父亲，一个是方点的孩子；后一种情况对应于两个都是方点的孩子。

于是每次可以 \(\mathcal{O}(1)\) 判断。

---

之所以有这一道水题，是因为《POI1999 Store-keeper 题解》中，本人采用「用来弹栈的割点」来理解此问题。事实上，在学习圆方树后，可以更清晰地理解这个问题：最终我们标记出来每个点所属的点双，和其在圆方树上的父亲是等价的。「用来弹栈的割点」便是方点的父亲圆点。

总结

通过本文的学习，我们深入探讨了圆方树这一结构在图论问题中的建模价值，特别是在仙人掌图及一般无向图中的实践应用。我们探究了树形 DP、点分治、树上启发式合并（DSU on tree）、树链剖分、虚树、动态 DP（DDP）、动态树等多种算法技巧，在这些图结构上的适用性和实现方法。同时，我们也厘清了一个核心问题：如何在这些图中高效维护点对之间所有简单路径的信息，从而为我们提供一种解决问题的全新的视角。

习题

这里总结了一些习题，大家可以练练手。

1. 例一、静态仙人掌最大独立集（小 C 的独立集，黑暗爆炸、洛谷、Hydro）
2. 例二、静态仙人掌直径（SHOI2008 仙人掌图，黑暗爆炸、洛谷、Hydro）
3. 例三、persistent DSU on cactus（洛谷）
4. 例四、GAME on cactus（洛谷）
5. 例五、仙人掌点对间最短路长度（【模板】静态仙人掌，洛谷）
6. 例六、BUY on cactus（洛谷）
7. 例七、【清华集训2015】静态仙人掌（UOJ）
8. 例八、mx 的仙人掌（UOJ）
9. 例九、【集训队互测2016】火车司机出秦川（UOJ）
10. 例十、DDP on cactus（洛谷）
11. 例十一、APIO2018 铁人两项（洛谷）
12. 例十二、必经点个数（洛谷，类似问题 UVA，类似问题 hydro-bzoj-3331 压力）
13. 例十三、ZJOI2022 简单题（洛谷、UOJ）
14. 例十四、Tourists（Codeforces）
15. 例十五、SDOI2018 战略游戏（洛谷）

欢迎补充。

编辑历史

• 2024-7-21：初版发布。
• 2025-3-19：开始重构。
• 2025-5-4：完成初稿。
• 2025-6-7：进一步整理重写，完成二稿。
• 2025-6-13：完成语言润色。
• 2025-7-19：学考后继续完善。新增仙人掌上换根 DP。
• 2025-7-19：检查审稿，发布终稿，投稿博客园首页。

原版博客

原版博客

前言

圆方树学习笔记，从一道例题讲起。

题目链接：Hydro & bzoj。

题意简述

仙人掌上求两点距离。

题目分析

为了把仙人掌的性质发挥出来，考虑将其变成一棵树。圆方树就是这样转换的工具。

先讲讲圆方树的概念：原图上的点为圆点，每个点双对应一个方点，树边都是方点连向点双内的圆点。

具体代码实现也十分简单，就是在 tarjan 求点双的时候，弹栈的时候，新建结点，并和点双内的点连边即可。或者在处理最后连边即可。

注意，对于孤立点的处理，是保持原样不动，还是变为一对方点和圆点，视情况讨论。以下代码按照上述定义，即对于孤立点，在圆方树上体现为一对方点和白点。

void tarjan(int now, int fa){
    dfn[now] = low[now] = ++timer, stack[++top] = now;
    int son = 0;
    for (int i = head[now]; i; i = edge[i].nxt){
        int to = edge[i].to;
        if (!dfn[to]){
            tarjan(to, now), low[now] = min(low[now], low[to]), ++son;
            if (low[to] >= dfn[now]){
                scc[++scc_cnt].push_back(now);
                do scc[scc_cnt].push_back(stack[top--]); while (stack[top + 1] != to);
            }
        } else if (to != fa) low[now] = min(low[now], dfn[to]);
    }
    if (!son && !fa) scc[++scc_cnt].push_back(now);
}
for (int i = 1; i <= scc_cnt; ++i)
    for (const auto& u: scc[i]) {
        yzh.add(i + n, u);
        yzh.add(u, i + n);
    }

void tarjan(int now, int fa){
    dfn[now] = low[now] = ++timer, stack[++top] = now;
    int son = 0;
    for (int i = head[now]; i; i = edge[i].nxt){
        int to = edge[i].to;
        if (!dfn[to]){
            tarjan(to, now), low[now] = min(low[now], low[to]), ++son;
            if (low[to] >= dfn[now]){
                ++scc_cnt;
                yzh.add(now, scc_cnt + n);
                yzh.add(scc_cnt + n, now);
                do {
                    int u = stack[top--];
                    yzh.add(u, scc_cnt + n);
                    yzh.add(scc_cnt + n, u);
                } while (stack[top + 1] != to);
            }
        } else if (to != fa) low[now] = min(low[now], dfn[to]);
    }
    if (!son && !fa) {
        ++scc_cnt;
        yzh.add(now, scc_cnt + n);
        yzh.add(scc_cnt + n, now);
    }
}

注意到，有时候，我们需要根据题意记录树边的边权。就比如例题。

思考我们建出树的意义是什么------原仙人掌上，不好求两点间的距离，而在树上，我们可以轻松利用 LCA 等方法求得两点间的距离。所以树的边权应该和距离有关。

我们发现，仙人掌中，原来的环都变成了菊花。原图上的距离是环上的最短距离，而在树上是从花瓣到花心，再从花心到花瓣。这样似乎没看出些什么。我们不妨把比较特殊的 LCA 处放在最后讨论，接下来只考虑往上跳 LCA 的过程。

发现，只会存在花瓣到花心，再到花顶端的那个花瓣。我们不妨设花心到顶端花瓣的距离为 \(0\)，而其余花瓣到花心的距离设置成原图环上到顶点的距离。这样就可以很好转化边权了。

至于 LCA 处，也很简单。如果 LCA 是圆点，那么不用处理；反之是方点，就要算其对应的原图上环的两点间的距离，这两点是来自询问两点不超过 LCA 的最浅祖先。这很好理解。

其实分析到这里，代码已经可以打出来了，但是在建树的时候注意如何优雅地处理边权，并精简代码。

那么再来模一模样例加深印象。

这里加粗的是原图的圆点，其他是方点。左图是圆仙人掌，右图是建出来的圆方树。

\(\operatorname{dist}(5, 7)\)：由于 \(\operatorname{LCA}(5, 7) = 1\) 是圆点，所以直接路径和相加，即 \(\operatorname{dist}(5, 7) = 3 + 0 + 1 + 0 + 2 + 0 = 6\)。

\(\operatorname{dist}(4, 8)\)：由于 \(\operatorname{LCA}(4, 8) = 14\) 是方点，所以要先跳到差一步到 \(14\) 的地方，即 \(4\) 和 \(3\)，环上距离为 \(\min \lbrace 1, 4 - 1 \rbrace = 1\)，\(\operatorname{dist}(4, 8) = 2 + 0 + 1 + 0 + 1 = 4\)。

代码

略去了快读快写，使用树剖求树上距离、LCA、和跳 father。

时间复杂度：\(\Theta(n + m + q \log n)\)，瓶颈在树剖查询的 \(\log\)。

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;

struct Graph{
    struct node{
        int to, nxt, len;
    } edge[1000010 << 1];
    int eid = 1, head[20010];
    inline void add(int u, int v, int w){
        edge[++eid] = {v, head[u], w};
        head[u] = eid;
    }
    inline node & operator [] (const int x){
        return edge[x];
    }
} xym, yzh;

int n, m, q;

int dfn[20010], low[20010], timer, cnt;
int dis[20010], re[20010];
int sum[20010], stack[20010], stop;
bool onleft[20010];

void tarjan(int now, int fr) {
    dfn[now] = low[now] = ++timer, stack[++stop] = now;
    for (int i = xym.head[now], to; to = xym[i].to, i; i = xym[i].nxt) if (i ^ fr ^ 1) {
        if (!dfn[to]) {
            dis[to] = dis[now] + xym[i].len;
            re[to] = xym[i].len;  // 如果这是一条非环边，那么把它看做 now -> to -> now 的环，所以这里要设置初值
            tarjan(to, i), low[now] = min(low[now], low[to]);
            if (low[to] >= dfn[now]) {
                ++cnt, sum[cnt] = re[stack[stop]] + dis[stack[stop]] - dis[now];  // 记录环的总长
                yzh.add(cnt, now, 0), yzh.add(now, cnt, 0);
                do {
                    int u = stack[stop--];
                    int len = min(dis[u] - dis[now], sum[cnt] - dis[u] + dis[now]);
                    onleft[u] = len == dis[u] - dis[now];
                    yzh.add(u, cnt, len);
                    yzh.add(cnt, u, len);
                } while (stack[stop + 1] != to);
            }
        } else if (dfn[to] < dfn[now]) {
            re[now] = xym[i].len;  // 环的闭环那条边的长度
            low[now] = min(low[now], dfn[to]);
        }
    }
}

int siz[20010], top[20010], son[20010];
int line[20010], tfa[20010], dpt[20010];

void dfs(int now, int fa) {
    tfa[now] = fa, siz[now] = 1, dpt[now] = dpt[fa] + 1;
    for (int i = yzh.head[now], to; to = yzh[i].to, i; i = yzh[i].nxt) {
        if (to == fa) continue;
        dis[to] = dis[now] + yzh[i].len;
        dfs(to, now), siz[now] += siz[to];
        if (siz[to] > siz[son[now]]) son[now] = to;
    }
}

void redfs(int now, int tp) {
    line[dfn[now] = ++timer] = now;
    top[now] = tp;
    if (son[now]) redfs(son[now], tp);
    for (int i = yzh.head[now], to; to = yzh[i].to, i; i = yzh[i].nxt) {
        if (to == tfa[now]) continue;
        if (to == son[now]) continue;
        redfs(to, to);
    }
}

inline int lca(int u, int v) {
    while (top[u] != top[v]) {
        if (dpt[top[u]] < dpt[top[v]]) swap(u, v);
        u = tfa[top[u]];
    }
    if (dpt[u] < dpt[v]) swap(u, v);
    return v;
}

inline int jump(int now, int ed) {
    int res = 0;
    while (top[now] != top[ed])
        res = top[now], now = tfa[top[now]];
    return now == ed ? res : line[dfn[ed] + 1];
}

inline int query(int u, int v) {
    int p = lca(u, v);
    if (p <= n)
        return dis[u] + dis[v] - 2 * dis[p];
    int fu = jump(u, p), fv = jump(v, p);
    int d1 = dis[fu] - dis[p], d2 = dis[fv] - dis[p];
    if (!onleft[fu]) d1 = sum[p] - d1;
    if (!onleft[fv]) d2 = sum[p] - d2;
    return dis[u] - dis[fu] + dis[v] - dis[fv] + min(abs(d1 - d2), sum[p] - abs(d1 - d2));
}

signed main() {
    fread(buf, 1, MAX, stdin);
    read(n), read(m), read(q);
    for (int i = 1, u, v, w; i <= m; ++i) {
        read(u), read(v), read(w);
        xym.add(u, v, w);
        xym.add(v, u, w);
    }
    cnt = n;
    for (int i = 1; i <= n; ++i) if (!dfn[i]) tarjan(i, 0);
    timer = dis[1] = 0, dfs(1, 0), redfs(1, 1);
    for (int i = 1, u, v; i <= q; ++i) {
        read(u), read(v);
        write(query(u, v)), putchar('\n');
    }
    fwrite(obuf, 1, o - obuf, stdout);
    return 0;
}

后记

不用圆方树亦可解此题，但是要多一些讨论、不如圆方树的直观。据说圆方树能在一般无向图上使用？我太蒻了啊。

// run
sidebarToggle();
window.cancelDetailsAnimation = true;