树上最长链

最新推荐文章于 2023-01-14 16:17:01 发布
原创 最新推荐文章于 2023-01-14 16:17:01 发布 · 419 阅读 · 1 ·
CC 4.0 BY-SA版权
复制代码可以，但一定要独立思考啊啊啊啊啊啊啊！！！！

给定一棵带权重的树，本文介绍了如何以O(n)的时间复杂度计算树上的最长链。通过定义f[i]表示以i为根的子树最长链，并结合g[i]表示从i节点向下最远能走多少距离，来求解最长链问题。

树上最长链

给定一棵树，每条边有权值，计算一条最长链，时间复杂度为O(n)
设f[i]表示以i为根的子树的最长链，显然f[i]=max(f[i],f[j])其中j是i的子节点，但是这样就值考虑了不经过i的路径，也就是不包括i
要想考虑经过i的路径，就需要选择两个子节点（随便在图上画画就能知道）
把两个子节点往下走的最长路相加，再加它们到i的路径和，去更新f[i]
定义g[i]表示i往下走最远能走多少
g[i]=max(g[i],g[j]+w[i][j])其中j是i的子节点
叶子节点f=g=0

void dfs(int u)
{
   
   
	f[u]=g[u]=0//假设当前点是叶子节点
	int maxg1=
最低0.47元/天 解锁文章
算法学习——树形DP——多叉树的最长路径
Blackoutdragon的博客
08-19 1526
这个树形DP算是全部总结完毕了，下次谁再来问我，说树形DP是什么，我狠狠打打他的脸！
由POJ-1383简析《树的最长链》两次DFS/BFS算法的证明
Macuilxochitl
02-13 2284
无意中看到一道水题，也就是POJ 1383 题目中给出了一个无环的迷宫，求出其中最长的一条路 我们知道无环图本质上可以认为就是树，所以此题完全可以使用树的最长链算法   即：随便从某个节点C开始DFS或BFS找到最远的一个点A，再从点A开始DFS或BFS找到最远的一点B，那么路径A->B必然是树上的最长路径。 这个算法很多人都知道并且当做结论使用，但很少看到有人给出正确性证明 所以
树的最长链
weixin_30407613的博客
01-21 464
最长链，就是最长的一条路径 1 / \ \ 2 3 4 / \ \ 5 6 7 ==\ ...
树上最长链 （树形dp 或 两次dfs ）
qhq889的博客
05-30 1261
带权树上最长链 （可能负权 ） 最长链：（树上直径，树上两点距离最大值，树上距离最远的两点 ）。 最长链 = 以某一结点为端点的最长链+次长链。 mx1: 以 i 节点为根的子树中，i 节点到叶子节点的最长距离（不含 i 节点）即最长链 mx2: 以 i 节点为根的子树中，i 节点到叶子节点的次长距离（不含 i 节点）即次长链 #define first f #define second s #define ll long long #define pb push_back #define pii pair
20191028 专题：基环树最长链
hongkongreporter
10-28 402
先上模板题 （黑的？？？） 自己 做的第一道 黑题，先祭一波~~~ 做了3h …毕竟我还是太弱了。 T1 P4381 [IOI2008]Island （洛谷P4381） 题目描述 你准备浏览一个公园，该公园由 NN 个岛屿组成，当地管理部门从每个岛屿 ii 出发向另外一个岛屿建了一座长度为LiL_iLi​的桥，不过桥是可以双向行走的。同时，每对岛屿之间都有一艘专用的往来两岛之间的渡船。相对于乘船而...
树形dp（二叉苹果树，选课，最长链，战略游戏）
avenLJY的博客
05-18 409
树形dp 【例1】二叉苹果树 题意：有一棵苹果树，如果树枝有分叉，一定是分2叉（就是说没有只有1个儿子的结点）。这棵树共有N个结点（叶子点或者树枝分叉点），编号为1–N,树根编号一定是1。我们用一根树枝两端连接的结点的编号来描述一根树枝的位置。现在这颗树枝条太多了，需要剪枝。但是一些树枝上长有苹果。给定需要保留的树枝数量，求出最多能留住多少苹果。 step1:把边权转为点权，记在儿子处 step...
树的最长路径【树形DP】
lppppppppps的博客
03-31 983
Date：2022.03.29 题意描述： 给定一棵树，树中包含 n 个结点（编号1~n）和 n−1 条无向边，每条边都有一个权值。 现在请你找到树中的一条最长路径。 换句话说，要找到一条路径，使得使得路径两端的点的距离最远。 注意：路径中可以只包含一个点。 输入格式 第一行包含整数 n。 接下来 n−1 行，每行包含三个整数 ai,bi,ci，表示点 ai 和 bi 之间存在一条权值为 ci 的边。 输出格式 输出一个整数，表示树的最长路径的长度。 数据范围 1≤n≤10000, 1≤ai,bi≤n, −
[技巧]求树上最长链(原题TYVJ)[二星~]
Loi_Seavot的博客
10-25 2245
原题目是TYVJ的，但是现在tyvj评测机莫名鬼畜，于是我就把数据弄了下来，并且附上评测工具~ 题目及数据地址——————–>百度网盘 评测工具（柠檬Lemon）——–>同样是百度网盘呢 先说一下Lemon的配置吧，选择本地的g++路径之后，创建本地的一个测试文件夹，其他的就和cena差不多啦~，lemon没有cena的一些bug，比cena好用呢~ 不过lemon默认逐字比较，需要手动设置
bzoj1912 [Apio2010]patrol 巡逻（dp求树上最长链）
Icefox的博客
03-05 548
显然答案一开始是n-1<<1，每条边都要走两遍。 如果K=1，可以新建一条道路，那么应该把树上最长链的两端连起来，这样就不用走两遍树上最长链了，而是只需要走一遍，(通过新边直接过去，不需要再返回了)。因此答案就是减去树上最长链+1。 如果K=2，还可以再新建一条，那么我们发现如果这次选择的链和上次选择的最长链有交集，则这一部分的边还是要走两遍，因此我们把最长链上的边权均变为-1，再求树上最长链，
BZOJ 2657 （ZJOI 2012 旅游） 求树上最长链（树的直径） MAP建树+BFS/DFS
Sky
08-29 1210
这道题是挺简单，求树上一条最长的路径（后来才知道这叫树的直径），而麻烦的是如何建树，这是这道题略恶心的地方。 数据的给出方式是每个节点给3个值（1~n），如果两个节点间有两个值相同，那么这两个点就是有一条边相连。题目中的描述什么凸多边形，三角形的顶点什么的一开始看确实被吓到了，其实就是两个三角形如果有公共边，那么这三角形代表的节点之间就有一条边，三角形的三个顶点就是前面所说的三个值。又因
树的最长路径
qq_45832461的博客
03-21 4638
树的最长路径 题目描述 样例解释 前置知识 树的直径，又称树的最长链，定义为一棵树上最远的两个节点的路径，即树上一条不重复经过某一条边的最长的路径。树的直径也可以代指这条路径的长度。 求树的直径有两种比较常用的方法：树形DP和搜索。 如何找树的直径呢？ 任取一点作为起点，找到距离该点最远的一个点u。 这一步可以用DFS或者BFS来解决。 再找到距离点u最远的一个点v。这一步可以用DFS或者BFS来解决。 那么点u到点v之间的路径就是一条直径了。 如何证明点u到点v之间的路径就是一条直径了呢？ 要
POJ 1985 树的直径（最长链）
java开发指南博客 【转载】
08-15 421
题目大意就是求一棵树上距离最远的两个顶点的距离 说是一棵树是因为之前1984题面上说过 然后据说2631跟此题一样 可以随便选择一个点开始进行bfs或者dfs，从而找到离该点最远的那个点（可以证明，离树上任意一点最远的点一定是树的某条直径的两端点之一；树的直径：树上的最长简单路径）。再从找到的点出发，找到据该点的最远点，那么这两点就确定了树的一条直径，两点间距即为所求距离。 这个用反证法可...
[BZOJ1912][Apio2010]patrol 巡逻（树上最长链）
ADP+Pi==ATP
08-20 765
zyf2000说如果我搭博客她就把草稿箱里的题解发出来嘿嘿嘿嘿嘿嘿嘿嘿嘿
[hihocoder 1050]求树的最长链
weixin_30767921的博客
10-14 187
题目链接：http://hihocoder.com/problemset/problem/1050 两种方法： 1.两遍dfs，第一次随便找一个根，找到距离这个根最远的点，这个点必然是最长链的一端。第二次就用这个端点做一遍dfs，最远的点就是另一端。 #include<bits/stdc++.h> using namespace std; const in...
【bzoj1912】[Apio2010]patrol 巡逻（树上最长链）
薇小薇
09-14 412
有些东西并不是越浓越好，要恰到好处。深深的话我们浅浅地说，长长的路我们慢慢地走。——毕淑敏
hdu 4460 Friend Chains
libing923的专栏
11-08 716
Friend Chains Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 96    Accepted Submission(s): 41 Problem Description For a group of peo
【图论进阶】树的最长链（树型动态规划）
xuyixin2022的博客
01-14 529
这是一道树形动态规划题，d[i][1]表示以i为起点的最大值，d[i][0]表示次大值，因为可以走两边，所以要两个值；d[i][1]=max(d[i][1] ，子节点的最大值+子节点到i的距离)，递归每一层子节点，找出最大的(d[i][1]+d[i][0])。乌托邦有n个城市，某些城市之间有公路连接。表示城市a和城市b之间有公路直接连接，并且公路的长度是c(c
最长链点权和
最新发布
07-26
<think>首先，用户的问题是关于计算树中最长路径的节点权重之和。路径是节点序列，每个节点有一个权重，我需要找到权重和最大的路径。 关键点： - 树是无环连通图，所以没有环。 - 路径可以是任意两个节点之间的路径。 - 我需要最大化节点权重之和。 在树中，最长路径（权重和最大）通常称为"diameter"，但diameter通常指边的数量最多，这里是节点权重之和最大。所以，我需要处理带权节点。 从引用中： - 引用[1]：提到了二叉树的最长路径长度和最大路径和。公式：sum(high_node) = max(sum(left), sum(right)) + value，以及路径和 path_sum = sum(left) + sum(right) + value。这似乎是针对二叉树，计算从根到叶的路径或类似。 - 引用[2]：讨论了最短和最长路径算法，提到了负权重和NP难题，但树中没有环，所以可能不是NP难题。 对于树，由于没有环，我们可以用动态规划或DFS来高效解决。 算法思路： 1. 对于树，任意两个节点之间的路径是唯一的。 2. 最长路径（最大权重和）可能涉及两个叶子节点或通过根节点。 3. 一个常见的方法是：对于每个节点，计算以该节点为根的子树中，从该节点到叶子节点的最大权重和路径（单一路径）。 4. 同时，计算以该节点为顶点的路径的最大权重和，这可以是左子树最大路径 + 节点权重 + 右子树最大路径（对于二叉树）。 5. 然后，全局最大值就是树中最大路径和。 对于一般的树（不一定是二叉树），类似： - 我们可以用DFS遍历树。 - 对于每个节点u，维护两个值： - max_single[u]：以u为起点的向下路径（到叶子）的最大权重和。 - max_path[u]：以u为顶点的路径的最大权重和（即路径在u处转折）。 - 然后，全局最大路径和是max over all u of max_path[u]。 步骤： 1. 从根节点开始DFS。 2. 对于叶节点：max_single[leaf] = weight[leaf]，max_path[leaf] = weight[leaf]（因为只有一个节点）。 3. 对于内部节点u： - 计算所有子节点v的max_single[v]。 - max_single[u] = weight[u] + max( max_single[v] for v in children )，或者如果所有子树的max_single[v]都负，可能只取weight[u]。 - max_path[u] = weight[u] + sum of two largest max_single[v] for v in children（如果有两个或更多孩子），或者如果只有一个孩子，max_path[u] = weight[u] + max_single[v]（但路径需要两个方向，所以可能不准确）。 - 更精确：max_path[u] 表示以u为顶点的路径的最大和，即路径从u的一个子树下来，经过u，再到另一个子树。所以对于u，取两个最大的max_single[v]值，加上weight[u]。 - 如果只有一个孩子，那么以u为顶点的路径只能是u到叶子，但这不是一个“转折”路径；然而，全局最大路径可能只是单一路径。 - 因此，max_path[u] 应该包括所有可能：单一路径或转折路径。 - 定义：max_path[u] 是子树u中以某节点为顶点的路径的最大和（包括单一路径）。 - 所以，max_path[u] = max( weight[u] + max_single[v] for some v, # 单一路径 weight[u] + max_single[v1] + max_single[v2] for v1 != v2 # 转折路径 ) - 但由于路径可能不经过u，但在子树中，所以我们需要比较： - 候选1：以u为端点的单一路径：weight[u] + max( max_single[v] for v in children ) 或者 weight[u] 如果无孩子 - 候选2：以u为顶点的转折路径：如果有至少两个孩子，weight[u] + max_single[v1] + max_single[v2] 其中v1和v2是不同孩子 - 候选3：子树中已有的最大路径，即 max( max_path[v] for v in children ) - 因此，max_path[u] = max( weight[u] + max(0, max_single[v1]) , # 单一路径，考虑可能只取u weight[u] + max_single[v1] + max_single[v2] if exist two children, # 转折路径 max_path[v] for v in children # 子树中的最大路径 ) - 但为了简化，在计算max_single[u]时，max_single[u] = weight[u] + max( {0} ∪ { max_single[v] for v in children } )，因为如果所有子树路径和负，可以只取u。 - 然后max_path[u] = max( max_single[u], # 以u为端点的路径 weight[u] + sum of two largest max_single[v] for v in children, # 转折路径，如果有两个孩子 max( max_path[v] for v in children ) # 子树中的最大路径 ) - 如果只有一个孩子，转折路径项无效。 4. 最后，全局最大路径和是 max_path[root]，但root可能不是路径的一部分，所以我们需要在DFS中维护全局最大值。 在实现中，最好在DFS过程中更新一个全局变量 max_sum。 算法伪代码： - 初始化 global_max = -infinity - DFS(u): - 如果 u 是叶子节点： - max_single = weight[u] - candidate_max = weight[u] # 局部最大路径，这里就是单个节点 - 更新 global_max = max(global_max, candidate_max) - 返回 max_single - 否则： - 对于每个子节点 v，递归计算 max_single_v = DFS(v) - 计算所有子节点的 max_single 值 - 设 child_max_single 为所有 max_single_v 的列表 - 排序 child_max_single 降序，或找最大两个值 - max_single[u] = weight[u] + max( child_max_single ) # 如果 child_max_single 非空，否则 weight[u] - 现在，以 u 为顶点的可能路径： - 单一路径：max_single[u] - 转折路径：如果有至少两个孩子，weight[u] + 两个最大的 child_max_single 值之和 - candidate_max = max_single[u] # 至少是单一路径 - 如果子节点数 >= 2： - 设 top_two = child_max_single 中最大的两个值 - candidate_max = max(candidate_max, weight[u] + top_two[0] + top_two[1]) - 此外，子树中的最大路径已经由 global_max 在递归中更新，但我们需要考虑以 u 为顶点的路径 - 更新 global_max = max(global_max, candidate_max, 以及递归调用中的最大值，但递归调用已经更新了 global_max 对于子树) - 在 DFS 中，当我们返回时，我们更新当前节点的 candidate_max，但子树的最大路径在递归调用中已经更新了 global_max。 - 所以，在 DFS(u) 中，我们计算以 u 为顶点的路径，并更新 global_max，同时子树路径在递归调用中被处理。 标准做法是： - 在 DFS 中，对于每个节点，计算 max_single[u]（从 u 向下到叶子的最大路径和） - 同时，计算以 u 为顶点的最大路径和，并更新全局最大值。 - 返回 max_single[u] 用于父节点。 伪代码： function dfs(u): max_single = weight[u] // 从u开始，只包含u local_max = weight[u] // 以u为根的子树的局部最大路径和，初始为只含u 对于每个子节点 v of u: child_single = dfs(v) // 从v向下到叶子的最大路径和 // 但我们需要所有子节点的 child_single 来计算 // 收集所有子节点的 child_single child_singles = [] for each child v: child_singles.append(dfs(v)) if child_singles 不为空: // 计算 max_single[u]：u + 最大子路径 max_child_single = max(child_singles) max_single[u] = weight[u] + max_child_single // 对于 local_max：可能包含转折路径 // 对 child_singles 排序，取最大的两个 对 child_singles 降序排序 top_two = child_singles[0] 和 child_singles[1] 如果存在 // 单一路径：max_single[u] 已经包含 path_through_u = weight[u] if len(child_singles) >= 1: path_through_u += child_singles[0] // 单一路径 if len(child_singles) >= 2: path_through_u += child_singles[1] // 转折路径，但只加一次权重[u] // 权重[u] 只加一次，因为路径经过 u // 转折路径：u + 左边路径 + 右边路径，所以是 weight[u] + child_singles[0] + child_singles[1] // 所以 local_candidate = max( max_single[u], weight[u] + sum of top two ) // 但 max_single[u] 是 weight[u] + max_child，对于单一路径 // 对于转折路径，如果至少有两个孩子，则是 weight[u] + top_two[0] + top_two[1] // 此外，子树中的最大路径可能出现在子节点中，但我们在递归调用中更新了 global_max // 所以对于 local_max at u, 我们只关心以 u 为顶点的路径 local_max = max_single[u] // 单一路径 if len(child_singles) >= 2: local_max = max(local_max, weight[u] + child_singles[0] + child_singles[1]) // 但 local_max 可能比子树中的小，但子树的最大值已经通过递归调用考虑了 else: // 没有子节点 max_single[u] = weight[u] local_max = weight[u] // 更新全局最大值 global_max = max(global_max, local_max) // 返回 max_single[u] 给父节点 return max_single[u] 在递归调用中，global_max 在每次访问节点时更新。 在开始时，设置 global_max = -infinity。 在叶子节点，local_max 就是 weight[u]，所以更新 global_max。 在内部节点，我们计算 local_max 作为以 u 为顶点的最大路径（单边或转折），并更新 global_max。 子树中的最大路径在递归调用中被捕获，因为当我们访问子节点时，我们更新了 global_max。 例如，如果最大路径完全在某个子树中，那么当 DFS 到该子树的节点时，它会被更新。 所以这个方法是正确的。 对于一般树，有多个子节点，我们取两个最大的 child_singles 来获得转折路径。 权重：在路径总和中，我们只对节点求和一次，所以对于转折路径，是 weight[u] + 左路径 + 右路径，其中左路径和右路径是来自不同子节点的 max_single。 max_single[v] 包括 v 的权重，所以当我们添加时，不会重复计算。 在 max_single[u] = weight[u] + max_child_single 中，max_child_single 是从子节点开始的最大路径，其中包含该子节点的权重。 在转折路径中，weight[u] + child_singles[0] + child_singles[1]，child_singles[0] 包括第一个子节点的权重，等等，所以节点 u 被计算一次，子节点在它们各自的路径中被计算。 路径不包含重复节点。 现在，对于用户：我需要用中文回答，结构清晰。 首先，解释问题：在树中，每个节点有一个权重，找到一条路径，使得路径上节点权重之和最大。 然后，描述算法：使用深度优先搜索（DFS）和动态规划。 提供伪代码或步骤。 最后，生成相关问题。 引用：用户提供了引用，但可能不直接相关。引用[1]是关于二叉树的，类似。引用[2]是关于图中的最长路径，但树中没有环，所以更简单。 在回答中，如果适用，可以提及引用，但这里可能不需要。 系统指令：在末尾添加引用标识，但用户没有提供具体引用，所以可能不需要，或者使用给定的引用。 用户说：“上述引用仅供参考”，所以我可以忽略或简要提及。 在回答中，自然地添加引用标识。 例如，在提到二叉树时，可以说如引用[1]所述。 但用户的问题是关于一般树的，我认为。 用户说：“计算树中最长路径的节点权重之和”，所以是树，不一定是二叉树。 算法适用于一般树。 伪代码：由于用户可能想要实现，提供清晰的描述。 最终答案结构： 1. 问题解释 2. 算法描述 3. 伪代码或步骤 4. 复杂度分析 5. 相关问题 使用中文。</think>### 树中最长路径的节点权重之和算法 在树结构（无环连通图）中，每个节点有一个权重（可为正、负或零），目标是找到一条路径（任意两个节点之间的简单路径），使得路径上所有节点权重之和最大。这个问题在树中可以通过高效的动态规划算法解决，时间复杂度为 $O(n)$，其中 $n$ 为节点数。由于树的无环特性，最长路径问题不会像一般图那样是 NP-难问题（如引用[2]所述）[^2]。 #### 算法核心思想 算法的核心是使用**深度优先搜索（DFS）** 结合**动态规划**，遍历树中的每个节点，并维护两个关键值： - **`max_single[u]`**：以节点 $u$ 为起点的向下路径（到叶子节点）的最大权重和（包括 $u$ 自身的权重）。 - 在遍历过程中，计算以 $u$ 为顶点的路径（可能为单一路径或转折路径）的最大权重和，并更新全局最大值。 关键点： - **单一路径**：从 $u$ 向下到叶子节点的路径（例如，$u \to v$）。 - **转折路径**：路径经过 $u$ 并向两个不同子树延伸（例如，$v_1 \to u \to v_2$），这需要至少两个子节点。 - 全局最大权重和会在 DFS 过程中被动态更新。 #### 算法步骤 1. **初始化**： - 设置全局变量 `global_max = -∞`，用于记录最大路径和。 - 选择一个根节点（任意节点，树的结构确保结果不受根选择影响）。 2. **DFS 遍历函数**（递归实现）： - **输入**：当前节点 $u$。 - **输出**：`max_single[u]`（以 $u$ 为起点的向下路径最大权重和）。 - 过程： - 如果 $u$ 是叶子节点： - `max_single[u] = weight[u]`（权重和仅为自身）。 - 更新 `global_max = max(global_max, weight[u])`。 - 返回 `max_single[u]`。 - 如果 $u$ 有子节点： - 初始化 `max_single[u] = weight[u]`（至少包含自身）。 - 初始化一个列表 `child_singles`，存储所有子节点 $v$ 的 `max_single[v]`（通过递归调用 DFS 计算）。 - 计算 `max_single[u] = weight[u] + max( { max_single[v] for v in children } ∪ \{0\} )`（如果所有子路径和为负，则只取 $u$ 自身）。 - 计算以 $u$ 为顶点的路径最大和 `local_max`： - 单一路径候选：`max_single[u]`。 - 转折路径候选（如果子节点数 ≥ 2）：对 `child_singles` 降序排序，取两个最大值，计算 `weight[u] + top_two[0] + top_two[1]`。 - `local_max = max( max_single[u], weight[u] + top_two[0] + top_two[1] )`（如果子节点数 ≥ 2）。 - 更新 `global_max = max(global_max, local_max)`。 - 返回 `max_single[u]`。 3. **执行和结果**： - 从根节点启动 DFS。 - 最终 `global_max` 即为树的最大路径权重和。 #### 伪代码示例 ```python global_max = float('-inf') # 初始化全局最大值 def dfs(u, weight, children): global global_max # 处理叶子节点 if not children[u]: max_single = weight[u] global_max = max(global_max, max_single) return max_single # 递归计算所有子节点的 max_single child_singles = [] for v in children[u]: child_single = dfs(v, weight, children) child_singles.append(child_single) # 计算 max_single[u]：u 自身 + 最大子路径（或 0 如果为负） max_child = max(child_singles) if child_singles else 0 max_single_u = weight[u] + max_child # 计算以 u 为顶点的路径最大和（单边或转折） local_max = max_single_u # 单一路径候选 if len(child_singles) >= 2: sorted_singles = sorted(child_singles, reverse=True) turn_path = weight[u] + sorted_singles[0] + sorted_singles[1] # 转折路径 local_max = max(local_max, turn_path) # 更新全局最大值 global_max = max(global_max, local_max) return max_single_u # 主函数 def max_path_sum(root, weight, children): dfs(root, weight, children) return global_max ``` #### 算法分析 - **时间复杂度**：$O(n)$，每个节点仅访问一次，每个节点的处理时间为 $O(\text{degree}(u))$，总时间为 $O(\sum \text{degree}(u)) = O(n)$（树中边数为 $n-1$）。 - **空间复杂度**：$O(n)$，用于递归栈和存储子节点列表。 - **正确性**：基于树的无环特性，DFS 确保所有路径被覆盖；动态规划通过 `max_single` 和转折路径计算，避免重复计算。 - **权重处理**：算法支持正、负或零权重。如果所有权重为负，最大路径和即为最大权重节点自身（如引用[1]中公式的推广）[^1]。 #### 示例说明 假设树结构如下（节点标注为 `节点:权重`）： ``` 1:5 / \ 2:10 3:-2 / \ 4:8 5:4 ``` - 最大路径：节点 2 → 1 → 3 → 4，权重和 = 10 + 5 + (-2) + 8 = 21。 - 算法过程： - 节点 4：`max_single=8`, `global_max=8`。 - 节点 5：`max_single=4`, `global_max=8`。 - 节点 3：`child_singles=[8,4]`，`max_single= -2 + max(8,4) = 6`，转折路径 = -2 + 8 + 4 = 10，`local_max=max(6,10)=10`，`global_max=max(8,10)=10`。 - 节点 2：`max_single=10`, `global_max=10`。 - 节点 1：`child_singles=[10,6]`，`max_single=5 + max(10,6)=15`，转折路径 = 5 + 10 + 6 = 21，`local_max=max(15,21)=21`，`global_max=21`。 - 结果：21。 此算法高效且易于实现，适用于二叉树或一般树（通过子节点列表处理多叉情况）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值