洛谷4180 【模板】严格次小生成树（最小生成树+树链剖分）

最新推荐文章于 2025-05-29 09:08:02 发布
原创 最新推荐文章于 2025-05-29 09:08:02 发布 · 564 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

该博客主要介绍了如何求解严格次小生成树问题，强调了它与最小生成树的区别仅在于一条边，并提供了利用最小生成树和树链剖分的解题思路。博主通过枚举边并处理环来找到次小生成树，同时讨论了如何处理边权相等的情况。

传送门

【题目分析】

首先明确一点：严格次小生成树与最小生成树有且只有一条边不同。

证明比较显然，自己画画图就行了，因为能替换的一定会构成一个环，依据这个就可以推出来。

同样，根据上面这个结论，我们可以枚举所有边，如果这条边不在生成树上，那么如果将这条边加入生成树中一定就会构成一个环，这时候只用将环上最大边删去即可，但考虑到严格次小生成树并且最大边可能与当前边权值相同，所以还要记录次大值。

所以相当于我们要询问最小生成树上两点之间路径的最大值或次大值，直接树剖即可。

【代码~】

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int MAXN=1e5+10;
const int MAXM=3e5+10;
const int INF=0x3f3f3f3f;

int n,m,cnt=1;
LL val;
int fat[MAXN],a[MAXN];
int head[MAXN],depth[MAXN],fa[MAXN],son[MAXN],siz[MAXN],top[MAXN];
int nxt[MAXM],to[MAXM];
int w[MAXM];
int dfn[MAXN],ys[MAXN],tot;
struct Edge{
	int u,v,w;
	int used;
	friend inline bool operator<(const Edge &a,const Edge &b){
		return a.w<b.w;
	}
}edge[MAXM];
struct
最低0.47元/天 解锁文章
PCL 点云最小生成树（MST，Dijkstra算法）
dayuhaitang1的博客
12-23 1338
PCL 点云最小生成树（MST，Dijkstra算法）
luogu1967：[noip2013提高组]货车运输（最小生成树+lca（倍增））或者（最小生成树+树链剖分）
liusu201601的博客
02-03 724
题目传送门超级好题，完美考核了2个算法：（最小生成树+lca）；当然，也可以用“树链剖分”来替代“lca”。如果想学树链剖分，请拉到最后！题目大意：n个点的无向图内，m次询问：x 点到 y 点的路径中，最大值是多少？如果 x与y不连通，输出-1；解法分析： 1、在无向图中，求两点的连通性，还要求两点之间道路的最值，应该先建树（最小生成树）；2、多次询问 x与 y之间的道路最值，就是树上的两点的关系...
Poj2831 树链剖分||次小生成树
zhangliwei的专栏
03-09 634
因为开的树链剖分专题，一看题目，第一思路就是： 让找出一个最小生成树，然后将这棵生成树进行链剖，再维护两点间边的最大值，只有查询询问，很好写，然后由于太急躁，以致Find()函数明显的错误居然没有发现，（在dep比较时，我居然交换了dep，而不是交换两个点），然后找了好久，开始怀疑自己的想法，找了好久没找到反例，最后百度了一下，发现可链剖可次小生成树，然后发现思路是对了，于是我试了一发次小生成树（
洛谷P4180 【模板】严格次小生成树[BJWC2010]（BZOJ1977）
forezxl的博客
04-18 1512
次小生成树 洛谷题目传送门 BZOJ题目传送门 次小生成树裸题。 先求出最小生成树，然后写个倍增算出最小生成树边的最大和次大值。最后求LCA的时候更新答案就好了。 次小生成树一定是最小生成树换了一条边。 代码： #include&lt;cctype&gt; #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;alg...
严格次小生成树
ID246783的博客
03-19 737
严格次小生成树   板子题传送门：luogu P4180 定义   严格次小生成树就是说我们设最小生成树选择的边集是 EME_MEM​，严格次小生成树选择的边集是 ESE_SES​，那么需要满足（value(e)value(e)value(e) 表示这个边的边权）： ∑e∈EMvalue(e)<∑e∈ESvalue(e) \sum_{e \in E_M}value(e) < \sum_{e \in E_S}value(e) e∈EM​∑​value(e)<e∈ES​∑​value(e) 分
bzoj1977: [BeiJing2010组队]次小生成树 Tree(严格次小生成树 树链剖分+线段树)
Karshilov的博客
08-03 360
1977: [BeiJing2010组队]次小生成树 Tree Time Limit: 10 Sec  Memory Limit: 512 MB Submit: 4005  Solved: 1161 [Submit][Status][Discuss] Description 小 C 最近学了很多最小生成树的算法，Prim 算法、Kurskal 算法、消圈算法等等。 正当小 C 洋洋得意之时，...
最小生成树+树链剖分+线段树维护区间最值
Xing_ke的博客
05-30 311
【代码】最小生成树+树链剖分+线段树维护区间最值。
3、GPU并行欧几里得最小生成树算法解析
y7z8a9的博客
05-29 36
本文介绍了基于GPU并行计算的欧几里得最小生成树（EMST）算法，重点解析了切片螺旋搜索、K-d搜索以及GPU双向并行BFS等关键技术。通过利用数据并行性和复杂度优化策略，该算法在2D及高维空间中的最近邻搜索和最小生成树构建中展现出显著的性能优势。文章还讨论了其在计算机图形学、数据挖掘、地理信息系统等领域的广泛应用前景，并对未来的优化方向进行了展望。
2018.09.15 bzoj1977:次小生成树 Tree（次小生成树+树剖）
weixin_30468137的博客
09-15 158
传送门 一道比较综合的好题。 由于是求严格的次小生成树。 我们需要维护一条路径上的最小值和次小值。 其中最小值和次小值不能相同。 由于不喜欢倍增我选择了用树链剖分维护。 代码： #include<bits/stdc++.h> #define N 100005 #define M 300005 #define lc (p&...
BZOJ 1977/洛谷P4180 - 次小生成树 Tree（严格次小生成树）
weixin_30409849的博客
09-18 177
题目链接 https://www.luogu.org/problemnew/show/P4180 【题意】 小C最近学了很多最小生成树的算法，Prim算法、Kurskal算法、消圈算法等等。正当小C洋洋得意之时，小P又来泼小C冷水了。小P说，让小C求出一个无向图的次小生成树，而且这个次小生成树还得是严格次小的，也就是说：如果最小生成树选择的边集是EM...
洛谷 P4180 【模板】严格次小生成树[BJWC2010] LCT
EM LGH
12-07 255
首次采用了压行，感觉还不错。 Code: // luogu-judger-enable-o2 #include &lt;cstdio&gt; #include &lt;algorithm&gt; #include &lt;cstring&gt; #include &lt;string&gt; using namespace std; void setIO(string a){ ...
洛谷p4180严格次小生成树
agyohust791263的博客
07-10 212
题意：求严格的次小生成树 严格次小生成树：(value(e)表示边e的权值)∑e∈EM​​value(e)<∑e∈ES​​value(e)（EM为最小生成树边集，ES为次小生成树边集） 就是次小生成树边权和一定要小于最小生成树， 而非严格的就不一定，也可能等于。 非严格次小生成树求法：是在最小生成树边集外 找到一条边（假设两点为u,v）（一定大于等于最小生...
专题·次小生成树【including 八中生成树， 洛谷·【模板】严格次小生成树[BJWC2010]
樱狸✨愿携清风归来处
05-20 493
初见安~本篇前置知识:：最小生成树，最近公共祖先 1.次小生成树 次小生成树——说白了就是选的边与最小生成树不同并且满足边权和最小。这里的不同是指只要不是最小生成树选的边刚好都是次小生成树的边就可以了。 具体题目描述大概是这样的：【题目选择某入门OJ：八中生成树 Description 八中有N个建筑物，某两点间有一条边存在。上一任Boss建立了个最小生成树出来，这样全校就可以电话联系了...
洛谷-4180 【模板】严格次小生成树[BJWC2010]
mkopvec的博客
08-15 221
题目描述 小C最近学了很多最小生成树的算法，Prim算法、Kurskal算法、消圈算法等等。正当小C洋洋得意之时，小P又来泼小C冷水了。小P说，让小C求出一个无向图的次小生成树，而且这个次小生成树还得是严格次小的，也就是说：如果最小生成树选择的边集是EM，严格次小生成树选择的边集是ES，那么需要满足：(value(e)表示边e的权值) ∑e∈EMvalue(e)&lt;∑e∈ESvalu...
次小生成树模板
aiweiluan5095的博客
09-18 196
次小生成树模板 【例题】 传送门 【做法】 先用最小生成树做出这棵树，然后DFS建树，插入一条非树边，肯定在树上形成了环，所以在环上找一个最大的删去，加入这条边。最后从所有情中选一个最小的就是答案。(首先得知道这个次小指的是什么次小，是值次小还是值从小到大排序后排名第二的，也就是涉及到次小是否能等于最小的问题) 贴上代码(Kruskal) ...
图论——次小生成树
jiahonghao2002的博客
08-15 300
图论——次小生成树 我们定义一个图的次小生成树（如果存在）为边权之和大于等于最小生成树的第二小生成树。 由于次小生成树和最小生成树之间只差一个边的改动，我们可以先求一边最小生成树，遍历所有未添加的边(u,v)(u,v)(u,v)，并计算路径u→vu \to vu→v中的最大边权，用这个边去替换最大边。在所有方案中取最小即可。 这样求的生成树是不严格次小生成树，如果要求严格次小生成树，我们必须维护路径上最大和次大边权，在所有方案中取最小即可。可以通过树链剖分，倍增，ST表实现。 P4180 #include
洛谷 P 4180 次小生成树
日拱一卒,功不唐捐
10-13 2726
题目描述 小C最近学了很多最小生成树的算法，Prim算法、Kurskal算法、消圈算法等等。正当小C洋洋得意之时，小P又来泼小C冷水了。小P说，让小C求出一个无向图的次小生成树，而且这个次小生成树还得是严格次小的，也就是说：如果最小生成树选择的边集是EM，严格次小生成树选择的边集是ES，那么需要满足：(value(e)表示边e的权值)\sum_{e \in E_M}value(e)<\s...
洛谷P4180 次小生成树学习
qq_30798083的博客
11-30 395
题目链接[BJWC2010]严格次小生成树 - 洛谷 严格次小生成树是指第二小的生成树 总的思路是先求最小生成树（设最小生成树的总花费sum），把每条边都标记，再遍历没被标记的边，此时这条边加进去肯定会形成一个环，这时候去掉除这条边(设权值为w)环上一条最大的边(设权值为wm)，则取min(sum+w-wm) 即可 但这样其实是有漏洞的，因为去除这条边可能环上最大边和这条边权值一样，这时候就是原来的最小生成树的sum，如图 此时加入4-5这条权值为10的边，形成一条环，却发现除这条边环上最大值还是.
树结构不变，使用线段树+树链剖分解决问题
最新发布
08-10
<think>我们使用树链剖分（重链剖分）将树分割成链，然后利用DFS序（实际上是剖分后的DFS序）将树结构转化为线性序列，然后使用线段树维护序列上的权值。这样，子树查询就转化为区间查询，节点更新就转化为单点更新。 树链剖分的DFS序：在剖分DFS中，我们优先遍历重儿子，这样保证重链上的节点在DFS序中是连续的。同时，每个子树在DFS序中也是连续的（因为DFS遍历子树时是连续的）。因此，子树查询可以转化为区间查询。 步骤： 1. 第一次DFS：计算每个节点的父节点、深度、重儿子、子树大小。 2. 第二次DFS：确定DFS序（时间戳），同时记录每个节点所在链的顶端节点（用于路径查询，但本题只需要子树查询，所以这一步可以简化，但我们还是按标准剖分来做）。 3. 建立线段树：在DFS序上建立线段树，支持单点更新和区间求和。 子树查询：对于节点u，其子树对应的区间为[in[u], out[u]]（即DFS进入和退出的时间戳）。注意：在树链剖分中，由于优先遍历重儿子，子树节点在DFS序中仍然是连续的。 因此，我们可以使用线段树来维护这个区间和。 伪代码（Python风格）如下： ```python import sys sys.setrecursionlimit(200000) class SegmentTree: def __init__(self, data): self.n = len(data) self.size = 1 while self.size < self.n: self.size *= 2 self.tree = [0] * (2 * self.size) # 构建线段树，初始数据 for i in range(self.n): self.tree[self.size + i] = data[i] for i in range(self.size - 1, 0, -1): self.tree[i] = self.tree[2*i] + self.tree[2*i+1] def update(self, index, value): # 单点更新：将位置index的值改为value（注意：这里是直接赋值，如果是增加则需要调整） # 但通常我们支持增加一个差值，这里按需求，我们假设是更新为新的值，所以需要知道旧值？或者我们设计为增加一个增量？ # 根据问题，节点改变权值，我们可以用增量更新。但为了通用，这里我们实现为单点设置值，但需要知道原值？或者我们设计为传入增量（更符合动态更新）。 # 这里我们实现为增量更新（delta） # index: 原始数组中的位置（0-indexed） pos = index + self.size self.tree[pos] += value # 增加一个增量 while pos > 1: pos //= 2 self.tree[pos] = self.tree[2*pos] + self.tree[2*pos+1] def query(self, l, r): # 区间查询 [l, r] (闭区间) l += self.size r += self.size res = 0 while l <= r: if l % 2 == 1: res += self.tree[l] l += 1 if r % 2 == 0: res += self.tree[r] r -= 1 l //= 2 r //= 2 return res # 树链剖分部分 n = 100000 graph = [[] for _ in range(n+1)] # 第一次DFS：计算父节点、深度、子树大小、重儿子 parent = [0] * (n+1) depth = [0] * (n+1) size = [0] * (n+1) heavy = [-1] * (n+1) # 重儿子，初始化为-1 def dfs1(u, p, d): parent[u] = p depth[u] = d size[u] = 1 max_size = 0 for v in graph[u]: if v == p: continue dfs1(v, u, d+1) size[u] += size[v] if size[v] > max_size: max_size = size[v] heavy[u] = v # 第二次DFS：确定DFS序（时间戳）和重链的顶端 head = [0] * (n+1) # 链的顶端节点 pos = [-1] * (n+1) # 节点在DFS序中的位置（时间戳） cur_time = 0 def dfs2(u, h): global cur_time head[u] = h pos[u] = cur_time cur_time += 1 # 如果有重儿子，先遍历重儿子 if heavy[u] != -1: dfs2(heavy[u], h) for v in graph[u]: if v == parent[u] or v == heavy[u]: continue dfs2(v, v) # 轻儿子，自己作为新链的顶端 # 初始化 def init_tree(root): dfs1(root, 0, 0) dfs2(root, root) # 初始化一个长度为n（节点数）的数组，初始权值，假设为0，或者根据实际输入 arr = [0] * n # 注意：节点从1开始，时间戳从0到n-1 seg_tree = SegmentTree(arr) return seg_tree, pos, head # 返回线段树和位置数组 # 更新节点u的权值（增加delta） def update_node(seg_tree, u, delta): idx = pos[u] # 节点u在线段树中的位置 seg_tree.update(idx, delta) # 查询子树u的权值和：子树u对应的区间为 [pos[u], pos[u]+size[u]-1] ？注意：在树链剖分的DFS序中，子树u的节点在区间[pos[u], pos[u]+size[u]-1]内吗？ # 实际上，在第二次DFS中，我们优先遍历重儿子，然后轻儿子。子树u的DFS序区间是连续的，因为递归完子树后才会遍历下一个子树。所以子树u的区间为 [pos[u], pos[u] + size[u] - 1]。 def query_subtree(seg_tree, u): l = pos[u] r = pos[u] + size[u] - 1 return seg_tree.query(l, r) # 注意：这里线段树的区间是[0, n-1]，所以直接使用pos[u]和pos[u]+size[u]-1即可。 ``` ### 注意点： - 树链剖分的DFS序保证了每个子树是连续的，所以我们可以用区间[pos[u], pos[u]+size[u]-1]表示子树。 - 线段树支持区间求和和单点更新（增量更新）。如果节点权值改变为新的值，则需要计算增量（新值-旧值）然后更新。 ### 时间复杂度： - 预处理：两次DFS，O(n) - 更新：O(log n) - 查询：O(log n) ### 与树状数组+DFS序的对比： - 树状数组+DFS序（普通DFS序）同样可以做到，且树状数组常数更小，代码更简单。 - 树链剖分的主要优势在于可以同时支持路径查询（而不仅仅是子树查询）。如果问题需要查询路径上的权值和，树链剖分就更有优势。 ### 总结： 对于子树查询，树状数组+普通DFS序已经足够高效。树链剖分+线段树也可以实现，但代码稍复杂，但扩展性强（支持路径查询）。本题要求子树查询，两种方法均可，但树链剖分在这里有点“大材小用”。 §§相关问题§§ 1. 树链剖分中重链和轻链的作用是什么？为什么优先遍历重儿子？ 2. 除了子树查询，树链剖分还能支持哪些类型的查询和操作？ 3. 如果树的结构是动态变化的（如添加或删除边），如何维护树链剖分？ 4. 线段树和树状数组在实现子树查询时各自的优缺点是什么？</think>对于树结构不变、节点数不超过 100,000 的场景，使用 **线段树 + 树链剖分** 是高效支持子树权值查询和节点权值更新的解决方案。树链剖分将树结构转化为线性序列，线段树则提供高效的区间查询和单点更新能力。 ### 解决方案步骤： 1. **树链剖分预处理**： - **第一次 DFS**：计算每个节点的父节点、深度、子树大小（`size[u]`）和重儿子（子树最大的子节点） - **第二次 DFS**：生成 DFS 序（优先遍历重儿子），记录节点入序时间戳 `dfn[u]` 和子树结束时间 `end[u]`（子树节点在 DFS 序中连续） 2. **线段树构建**： - 基于 DFS 序构建线段树，叶子节点存储原始节点权值 - 支持单点更新（节点权值修改）和区间查询（子树权值和） ### 代码实现（Python 风格） ```python import sys sys.setrecursionlimit(200000) class SegmentTree: def __init__(self, n): self.n = n self.size = 1 while self.size < n: self.size *= 2 self.tree = [0] * (2 * self.size) def update(self, index, delta): """单点更新：位置 index 增加 delta""" i = index + self.size self.tree[i] += delta while i > 1: i //= 2 self.tree[i] = self.tree[2*i] + self.tree[2*i+1] def query(self, l, r): """区间查询 [l, r] 的和""" l += self.size r += self.size res = 0 while l <= r: if l % 2 == 1: res += self.tree[l] l += 1 if r % 2 == 0: res += self.tree[r] r -= 1 l //= 2 r //= 2 return res # 树链剖分预处理 n = 100000 # 最大节点数 graph = [[] for _ in range(n+1)] parent = [0] * (n+1) # 父节点 depth = [0] * (n+1) # 深度 size = [0] * (n+1) # 子树大小 heavy = [-1] * (n+1) # 重儿子 dfn = [0] * (n+1) # DFS 入序时间戳 end = [0] * (n+1) # 子树结束时间戳 cur_time = 0 def dfs1(u, p, d): """第一次 DFS：计算 size/heavy""" parent[u] = p depth[u] = d size[u] = 1 max_size = 0 for v in graph[u]: if v == p: continue dfs1(v, u, d+1) size[u] += size[v] if size[v] > max_size: max_size = size[v] heavy[u] = v def dfs2(u, head): """第二次 DFS：生成 DFS 序""" global cur_time dfn[u] = cur_time cur_time += 1 # 优先遍历重儿子 if heavy[u] != -1: dfs2(heavy[u], head) # 重儿子继承当前链头 for v in graph[u]: if v == parent[u] or v == heavy[u]: continue dfs2(v, v) # 轻儿子作为新链头 end[u] = cur_time - 1 # 子树结束时间 # 初始化树链剖分 def init_tree(root=1): dfs1(root, 0, 0) dfs2(root, root) # 根节点作为第一条链的链头 return SegmentTree(cur_time) # 创建线段树 # 更新节点 u 的权值 (新值 new_val) def update_node(seg_tree, u, new_val, old_val): delta = new_val - old_val seg_tree.update(dfn[u], delta) # 查询子树 u 的权值和 def query_subtree(seg_tree, u): return seg_tree.query(dfn[u], end[u]) # 使用示例 if __name__ == "__main__": # 假设树已构建在 graph 中，root=1 seg_tree = init_tree() # 初始化节点权值 (假设存储在 node_val 数组) for u in range(1, n+1): seg_tree.update(dfn[u], node_val[u]) # 示例：更新节点 5 权值为 10 (旧值假设为 7) update_node(seg_tree, 5, 10, 7) # 示例：查询子树 3 的权值和 print(query_subtree(seg_tree, 3)) ``` ### 时间复杂度分析 | 操作 | 时间复杂度 | 说明 | |--------------|------------|--------------------------| | 树链剖分预处理 | O(n) | 两次 DFS 遍历 | | 单点权值更新 | O(log n) | 线段树单点更新 | | 子树权值查询 | O(log n) | 线段树区间查询 | ### 优势与适用场景 1. **树链剖分优势**： - 将子树查询转化为 **连续区间查询**（`[dfn[u], end[u]]`） - DFS 序连续性由重链优先遍历保证 2. **线段树优势**： - O(log n) 高效区间求和 - 支持动态点更新 3. **扩展性**： - 可扩展支持路径查询（通过跳链查询） - 可支持其他聚合操作（最大值、最小值等） 此方案在节点数 100,000 时完全可行，预处理 O(n)，每次操作 O(log n)。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值