<think>嗯，我现在得仔细看看这个
问题。题目是说，给定一个N个顶点、N-1条边的带权无向连通图，这说明原图是一棵树啊，因为边数刚好是顶点数减一，而且连通。然后有Q个查询，每个查询添加一条边，然后求当前图的最小生成树的权重总和。每个查询之后都要输出总和。
那
问题来了，每次添加边之后，怎么高效计算新的MST的总权重呢？因为每次加边可能替换掉原来MST中的某条边。那如果直接每次用Kruskal或者Prim算法的话，时间复杂度肯定太高了，因为Q和N都是2e5级别的，这样总时间复杂度会是O(Q*(M log M))，这里的M每次都是O(N)的，这显然不可行。
那需要想更高效的方法。首先，原图是一棵树，所以初始的MST就是这棵树的总权重总和。每次添加一条边之后，新的图中可能会形成一个环。这时候，MST可能会选择这条新边，或者保持原来的边中的最大边，这取决于新边的权重是否比环中的最大边更小。
所以，对于每个查询，当添加一条边u-v，权重w时，我们需要找到原树中u到v路径上的最大边权。如果这个最大边权比w大，那么替换这条边后的总权重会是原总权重减去最大边权，加上w。否则，总权重不变。
这样，
问题的关键就转化为如何快速查询树中两点之间的路径上的最大边权，以及如何维护总权重。
那如何高效查询两点路径上的最大边权呢？这可能需要用到一些树的结构，比如用倍增法（LCA的变种）来预处理每条路径的最大边权，或者在每条边上记录一些信息。比如，可以用树链剖分或者LCA结合每个节点到祖先路径上的最大边权。
比如，对于每个节点，我们可以用倍增法预处理每个节点向上2^k步的最大边权。这样，在查询u和v之间的路径的最大边权时，可以通过找到它们的LCA，然后分解路径为u到LCA和v到LCA两部分，取这两部分的最大值即可。
这需要预处理每个节点的父节点以及各个跳跃层数的最大边权。预处理的时间复杂度是O(N log N)，每次查询的时间是O(log N)。这样的话，每个查询的处理时间是O(log N)，总时间复杂度是O(N log N + Q log N)，这应该可以通过题目给定的约束条件。
那具体步骤如下：
1. 初始时，原图是一棵树，计算初始MST的总权重sum（也就是原树所有边的权重之和）。
2. 对于每个查询(u_i, v_i, w_i)，添加边u_i-v_i，权重w_i。此时，原树加上这条边会形成一个环。环中的边包括原树中u到v的路径上的所有边，以及新加的这条边。
3. 计算原树中u到v路径上的最大边权max_edge。如果w_i < max_edge，则新的MST的总权重是sum - max_edge + w_i。否则，总权重不变。然后，sum需要更新为这个新的总权重。
4. 输出新的sum。
但需要注意，替换后的边可能影响后续的查询。比如，原树的结构可能改变？但这里每次添加的边只是临时添加到图中，并没有实际修改原树的结构。或者说，原树的结构始终是固定的，而每次添加的边只是临时存在的。因此，在后续的查询中，每次添加的边都是独立处理的？
这可能需要明确
问题的处理方式。例如，当处理完一个查询后，图会包含之前所有添加的边吗？或者每个查询是独立的，添加边之后图被修改，后续查询是在这个基础上进行的？
根据题目描述，每个查询是在G中添加边之后处理。所以，每个查询之后，这条边会被保留在图中，之后的查询的图包含之前所有添加的边。但这样的话，每次添加的边都会导致图中的边越来越多，原来的树结构可能被改变。这个时候，MST的计算会越来越复杂，因为需要考虑所有之前添加的边。这时候，
问题就变得困难了，因为每次都要考虑所有现有的边。
但这样的话，时间复杂度会很高，因为每次都要处理O(N + Q)条边，对于Q次查询来说，总时间是O(Q*(N+Q) log(N+Q)))，这显然无法处理2e5的数据量。
这说明，我之前的
问题理解可能有误。必须重新仔细看题目。
问题描述中的每个查询是依次处理的。每个查询添加一条边到G中，然后求此时G的最小生成树的权值和。所以，每个查询之后，这条边会被保留在G中，后续查询的图包含之前添加的所有边。
这时候，
问题变得非常棘手，因为每次添加边后，整个图的边集合逐渐增加。而每次求MST都需要考虑所有存在的边，这显然对于Q次查询来说，无法用常规方法处理。
那这显然需要找到一个更高效的处理方式。那有没有办法将
问题转化为每次添加边后，只需要比较当前边和原树中的某些边？
或者，是否有某个性质可以利用？
比如，原图是一棵树，之后每次添加边，形成多个环。对于MST来说，当添加一条边时，这条边是否会被包含到MST中，取决于它是否是所在环中的最小边。
但是，每次添加边之后，整个图的结构可能变得复杂，但原树的边可能被后续添加的边所替代。那么，如何维护这些可能被替代的边？
这时候，或许可以考虑离线处理所有查询。但题目要求依次处理每个查询，所以必须在线处理。
或者，我们可以发现，每个新添加的边u-v的权重是w。而原树中u到v的路径上的最大边的权重max_edge。如果w < max_edge，那么在MST中，这条新边会替换掉原来的最大边。否则，这条新边不会被选入MST。但这里的
问题是，当后续添加更多的边时，是否会影响之前的替换？
比如，假设第
一次添加边e1，替换了原树中的边e_max1。第二次添加边e2，可能替换原树中的边e_max2。这时候，整个MST的结构已经被改变，原来的某些边可能已经被替换，因此后续的查询可能需要重新计算某些路径的最大边。
但这样看来，维护这样的信息似乎非常困难，因为每次添加边后，可能会改变树的结构，进而影响到后续路径的最大边查询。
这似乎回到了原
问题如何处理的
问题。那这个时候，有没有可能，每次添加的边只有在某些情况下才会对当前的MST产生影响？
比如，假设我们已经维护了一个动态的MST结构。每次添加一条边，这条边可能替换掉当前MST中的一个边，当且仅当这条边的权重小于当前MST中对应的环中的最大边的权重。这样，总权重的更新只需要减去这个最大边的权重，加上新边的权重。同时，在动态MST结构中维护这些信息。
但如何高效维护动态MST结构呢？这可能需要用到一些高级数据结构，比如Link-Cut Tree（动态树），或者使用其他方式维护树中的边的最大值。
这似乎比较复杂，但对于本题来说，可能有一种更简单的方法。因为原树的结构是固定的，每次添加的边只在原树中的u-v路径上进行比较，而不管之前添加的其他边。这可能吗？
或者，是否每次添加的边与原树中的边形成的环，其处理方式独立于其他已添加的边？
比如，每次添加的边是否
只能替换原树中的边，而不能替换之前添加的边？或者，是否所有已添加的边都可能被后续的边替换？
这可能需要分析MST的性质。例如，当多个边被添加后，MST的结构可能由原树中的边和部分添加的边组成。此时，每次添加边时，新边和原树中的边以及其他添加的边共同构成环，替换其中最大的边。这时候，动态维护这个MST的总权重可能变得非常困难。
这时候，必须寻找一种不同的思路。例如，原题的初始MST总和sum是原树的总权重。每次添加的边u-v的权重为w。此时，如果这条边的权重w比原树中u到v路径上的最大边权max_edge小，则sum会减少max_edge - w。否则，sum不变。并且，后续的添加边操作，是否
只能与原树中的边进行比较？
如果这样的话，那么每次查询的处理，只需要考虑当前添加的边和原树中的对应路径的最大边权。而不管之前添加的其他边是否已经被加入到MST中。这可能吗？
比如，假设每次添加的边e是否被包含到MST中，仅取决于它是否比原树中u-v路径的最大边更小，而不管其他添加的边。这样，每次处理查询时，只需要计算当前添加的边的w和原树中的路径的最大边权max_edge。如果w < max_edge，则sum -= (max_edge - w)，否则sum不变。然后，将sum作为当前结果输出。
但这样的处理方式是否正确？
假设原树的MST是sum。添加一条边e1，u1-v1，权重w1。此时，形成的环是u1到v1在原树中的路径加上e1。此时，如果w1 < max_edge1，则替换后的sum是sum - max_edge1 + w1。此时，新的MST中的边可能包含e1。
当添加第二条边e2，u2-v2，权重w2。此时，形成的环是u2到v2在原树中的路径加上e2，以及可能其他之前添加的边。假设此时，原来的MST已经替换掉原树中的某些边，那么现在形成的环可能包含这些已经被替换的边。这时候，比较e2的权重和原树中的路径的最大边权是否合理？
例如，假设原树中的路径的最大边是max_edge2。如果在之前的操作中，这条边已经被替换掉（比如被某个更小的边替代），那么此时原树中的路径的最大边可能已经不是max_edge2。那么，这时候用原树中的路径的最大边来比较，就会得出错误的结果。
这说明，这种处理方式只有在每次添加的边仅与原树中的边进行比较的情况下才是正确的。否则，当之前添加的边已经被包含到MST中时，后续的添加边操作可能需要比较其他边，而不仅仅是原树中的边。
因此，这种情况下，这种处理方式是不正确的。所以，这样的思路是错误的。
那这个时候，
问题变得复杂起来。必须找到另一种方法。
那我们需要想，每次添加边后，整个图中的边集合为原树的边加上之前所有添加的边。这个时候，求MST的总权重。
然而，对于这样的动态
问题，常规的Kruskal算法无法高效处理，因为每次都要重新计算。必须寻找一种更高效的方式。
有没有可能，每次添加的边的权重较小，因此可能替换原树中的某些边？
或者，由于原树的边的权重和添加的边的权重都在1到10之间，可能可以利用这一点？
比如，原树中的边的权重可能有很多较大的值，而添加的边的权重可能更小，从而不断替换原树中的边。但由于权重范围很小，可能可以预先处理某些信息。
或者，原树的边的权重可能已经被预先处理，每次添加边时，只需要比较是否比原树中的路径的最大边更小，不管之前添加的边的情况。这样，结果是否正确？
例如，假设原树的MST总和是sum。每次添加一条边e，它能否进入新的MST，当且仅当e的权重小于原树中u到v路径的最大边。这似乎只有当原树中的边是唯一可能的候选时才会成立。然而，当之前添加的边已经被包含到MST中时，这条新的边e可能形成一个环，其中包含之前添加的边，这时候就需要比较这些边的权重。
例如，假设之前添加了一条边e1，权重w1，比原树中的某个边max_edge1小，那么原sum被更新为sum - max_edge1 + w1。此时，这条e1边已经被包含到MST中。当添加第二条边e2，其u2和v2的路径可能经过e1边，那么此时形成的环可能包括e1和e2，以及原树中的其他边。这时候，需要比较这些边的最大值来决定是否替换。
这样看来，每次添加边的影响可能不仅限于原树的边，还可能涉及之前添加的边。这时候，无法仅通过原树的路径的最大边来决定替换与否，导致之前的思路不正确。
那这
问题是否有更巧妙的解法？
可能，这时候正确的做法是：每次添加的边e（u, v, w），我们比较这条边的权重w与当前MST中u到v路径上的最大边的权重。如果w更小，则替换，否则不替换。此时，
问题转化为动态维护MST中的路径最大值，并支持边的替换。
这需要动态维护一个树结构，其中边可以被替换，同时能够快速查询两点之间的路径上的最大边权。这可以通过动态树结构（比如Link-Cut Tree）来实现。每次添加新边时，找到当前MST中u到v的路径的最大边权，如果新边更小，则替换，并更新总和。
这样，每次查询的处理时间为O(log N)，对于Q次查询，总时间为O(Q log N)，这应该是可行的。
但如何实现这个思路？
具体来说，初始的MST是原树，总和是sum。之后，每次处理一个查询：
1. 添加边u-v，权重w。此时，当前的MST结构可能包含之前添加的一些边。
2. 找到当前MST中u到v的路径的最大边权max_current。
3. 如果w < max_current，则用新边替换这条最大边，sum -= (max_current - w)，否则sum不变。
4. 输出sum。
这样，每次添加边时，只需要考虑当前MST中的u-v路径的最大边，而不管原树中的情况。这时候，只要能够动态维护MST结构，并支持查询两点间路径的最大边权，那么就可以高效处理每个查询。
这种方法的关键在于，每次添加的边是否能够替代当前MST中的某个边，从而形成新的MST。而动态维护MST结构，需要能够高效查询和替换边。
那么，如何用数据结构来实现这一点？
这时候，Link-Cut Tree（LCT）可能是一个可行的选择。LCT可以维护动态树结构，并支持路径查询最大值，以及边的替换等操作。具体来说，每个边可以被视为一个节点，或者通过适当的处理，将边权存储在节点中，并维护路径上的最大值。
但实现LCT可能比较复杂，尤其对于编程竞赛来说，需要较高的代码能力。不过，在本题的约束下，这是否可行？
假设我们可以用LCT来维护当前MST的树结构，其中每个边有一个权值，并且每个节点维护子树中的最大边权。每次查询u到v的路径的最大边权时，可以通过LCT的路径查询操作得到。如果新边的权值比这个最大值小，则切断原最大边所在的边，并将新边加入树中。这样，总和sum会相应变化。
这似乎是一个可行的方案。但具体实现需要考虑以下几点：
1. 如何将原树的边转化为LCT的结构，并支持动态替换。
2. 每次添加边时，找到u和v在LCT中的路径的最大边权。
3. 如果新边的权重更小，则删除该最大边，并添加新边，同时更新总和sum。
这样，每次处理查询的时间是O(log N)的，总时间复杂度是O((N + Q) log N)，这应该可以满足题目的时间限制。
那
问题的关键现在转化为如何实现这个动态维护MST的结构。这可能需要使用LCT来维护树的动态结构，并且每条边都有一个权值，同时支持路径上的最大权值查询，以及边的替换。
现在，如何将原树的边插入到LCT中？
初始时，原树是MST。每条边可以视为LCT中的一个节点，或者将边的权值存储在节点中。在LCT中，通常每个节点代表树中的一个顶点，而边的信息可以存储在子节点与父节点之间。例如，每个节点可以保存该节点到父节点的边的权值，并在Splay Tree的节点中维护路径上的最大值。
这样，当查询路径u到v的最大边权时，可以通过LCT中的路径操作，将u到v的路径提取出来，然后查询该路径上的最大边权。
在实现时，每个LCT的节点需要维护其所在路径中的最大边权，以及对应的边（或者该边所在的节点）。这可能需要在每个节点中保存最大值以及其来源。
当需要替换最大的边时，需要断开对应的边，并连接新边。但新边的添加会形成一个环，这时需要断开原来的最大边，并连接新边，以保持树的结构。
具体来说，当添加边u-v，权重w时，执行以下步骤：
1. 在LCT中查询u到v的路径的最大边权max_edge。
2. 如果w < max_edge，则sum -= max_edge，sum += w。
3. 断开max_edge对应的边，将u和v用新边连接起来，并将新边的权值
设置为w。
这样，每次操作都能动态维护当前的MST总和。
现在的
问题是如何在LCT中表示边，并且能够快速找到最大边的位置。例如，每个节点需要记录父边的权值，并且在路径查询时能够找到最大的权值及其位置。
例如，每个LCT的节点可以维护三个值：当前节点到父节点的边的权值（如果是虚边则为0或不考虑），以及该节点所在splay子树中的最大边权值，以及对应的边的子节点（因为断开边时需要断开该子节点与其父节点的连接）。
例如，每个节点的结构体可能包含：
- 父节点、左孩子、右孩子（splay树的连接）
- 翻转标记（用于处理路径反转）
- 当前边的权值（即该节点到父节点的边的权值）
- max_val：该splay子树中的最大边权值
- max_node：该子树中最大边权对应的子节点（因为断开边时需要断开该子节点与其父节点的链接）
这样，当合并路径时，可以维护max_val和max_node的值。
在每次splay操作时，需要更新节点的max_val和max_node，以反映其子树中的最大值。
当需要查询路径u到v的最大边权时，执行以下步骤：
1. 将u作为根，将v的路径与u相连，使v成为当前splay树的根。
2. 此时，整个路径的信息已经被维护在v的splay树中，可以直接读取max_val。
或者，可能需要split出u到v的路径，然后查询该路径的最大值。
这可能需要更详细的理解LCT的实现细节。
无论如何，这样的动态结构需要能够支持路径最大值查询和边的断开操作。
现在，假设我们有一个LCT结构，可以处理这些操作。那么，整个
问题的处理步骤如下：
初始阶段：
1. 构建原树，并将所有边加入LCT中。初始总和sum为所有边的权重之和。
2. 对每个查询：
a. 添加边u_i, v_i, w_i.
b. 在LCT中找到u_i到v_i的路径的最大边权max_edge.
c. 如果w_i < max_edge:
i. 断开这条max_edge对应的边（即从LCT中删除）。
ii. 将新边u_i-v_i，权w_i加入LCT中，连接u_i和v_i。
iii. sum = sum - max_edge + w_i.
d. 输出sum.
这样，每次处理查询的时间是O(log N)的，因为LCT的每个操作的时间复杂度是均摊O(log N)的。
现在，
问题转化为如何实现这个LCT结构，并正确处理边的权值和最大值的维护。
这似乎是一个可行的解决方案，但具体的代码实现可能比较复杂。尤其是在处理边的断开和连接时，需要正确维护每个节点的父边权值，并在路径查询时能够找到最大值。
例如，在LCT中，每个节点保存到父节点的边的权值。当我们需要找到路径上的最大边权时，需要遍历路径上的所有节点，比较它们的权值，并记录最大值。但通过维护每个节点的子树中的最大值，可以在splay操作时快速得到路径的最大值。
例如，每个节点维护max_val（该子树中的最大边权）和max_edge（对应的子节点）。当合并子树时，max_val是当前节点的边权，左子树的max_val，右子树的max_val中的最大值。对应的max_edge则是这三个中最大对应的那个节点。
这样，当查询路径u到v的最大边权时，只需要在将u和v所在的路径合并后，访问根节点的max_val，即可得到路径中的最大边权。
那么，当需要断开最大边时，如何找到对应的边？
例如，假设路径的最大边权是max_val，对应的边位于节点x到其父节点之间。这时候，断开x和其父节点的链接即可删除这条边。
因此，在LCT的每个节点中，除了维护max_val外，还需要维护max_edge，即该子树中最大边权所在的子节点。例如，当某个节点的左子树的max_val是最大的，那么max_edge就是左子树的max_edge；否则，如果当前节点的边权是最大的，则max_edge是当前节点本身；否则，是右子树的max_edge。
这样，当需要断开最大边时，可以找到对应的子节点x，并断开x与其父节点的链接。
因此，LCT中的每个节点需要维护以下信息：
- 父节点、左子、右子
- rev标记（表示子树是否需要翻转）
- weight：该节点到父节点的边的权重（如果该节点是树根，则无父节点，weight无效）
- max_val：该子树中的最大边权重
- max_edge：该子树中最大边对应的子节点（即，该边所在的节点）
这可能比较难以维护，但可以通过push_up函数在每次结构变化时更新这些信息。
例如，push_up函数可能如下：
def push_up(node):
left_max = node.left.max_val if node.left else 0
right_max = node.right.max_val if node.right else 0
current_weight = node.weight
max_val = max(left_max, right_max, current_weight)
node.max_val = max_val
# 确定max_edge
if max_val == current_weight:
node.max_edge = node
elif node.left and max_val == left_max:
node.max_edge = node.left.max_edge
else:
node.max_edge = node.right.max_edge
这样，在每次splay操作时，通过push_up维护这些信息。
当查询路径u-v的最大边时，执行以下步骤：
1. 将u和v进行split，使得它们之间的路径成为当前的splay树。
2. 该splay树的根节点的max_val即为路径中的最大边权。
3. 对应的max_edge即为该边所在的节点。
然后，如果需要断开这条边，只需要断开max_edge节点与其父节点的连接。
但是，在LCT中，边的断开通常是通过cut操作实现的。例如，cut操作会断开某个节点与其父节点的链接。因此，当max_edge对应的节点是某个子节点，那么执行cut(max_edge)即可断开该边。
此时，原树将被分成两部分。然后，连接新边u-v，这可以通过link操作实现。
综上，整个处理流程可以用LCT来实现，并且每次查询的时间复杂度是O(log N)，能够满足题目的时间限制。
现在，需要考虑如何初始化LCT的结构。原树的结构需要被正确构建，每个边被插入到LCT中。例如，原树的构建可以通过遍历所有边，并使用link操作将它们连接起来。
但原树中的边需要被正确插入到LCT中。例如，对于原树的每条边a_i和b_i，权c_i，假设在LCT中，这条边被表示为连接a_i和b_i的边。在LCT中，link操作通常需要将一个节点作为另一个的父节点，这可能需要选择其中一个方向。例如，可以将a_i和b_i的父节点关系建立起来，并
设置边权。
这可能需要将原树转换为有根树，例如以某个节点（如1号节点）为根，然后构建parent结构。或者，可以使用双向的边，但这在LCT中可能比较复杂。
或者，在构建原树时，可以按照树的结构进行LCT的链接。例如，可以通过BFS或DFS遍历原树，并为每个节点
设置父节点，并在LCT中执行link操作，
设置相应的边权。
例如，对于原树的每条边a_i和b_i，假设a_i是父节点，那么将b_i的父节点
设置为a_i，并
设置边权为c_i。或者，根据原树的结构，可能需要确定父节点的方向。
这可能需要在原树构建时，确定每个节点的父节点，例如，以1为根进行BFS，然后建立每个节点的父节点关系，并将边权存储在对应的节点中。
这样，在初始化LCT时，每个节点的父节点已经
设置，并且边权也被正确存储。这样，LCT的结构就与原树的结构一致。
总结，解决此
问题的步骤：
1. 构建原树的结构，并计算初始总和sum。
2. 初始化LCT结构，将所有原树的边加入其中，每条边的权值正确记录。
3. 对于每个查询：
a. 添加边u, v, w.
b. 在LCT中查询u到v的路径的最大边权max_edge.
c. 如果w < max_edge：
i. 断开该最大边所在的边（使用cut操作）。
ii. 连接u和v的新边，权w（使用link操作，并
设置边权）。
iii. sum = sum - max_edge + w.
d. 输出sum.
现在，如何具体实现这个LCT结构？
这可能需要编写一个支持以下操作的LCT：
- link(u, v, w)：将u和v连接，边权为w。
- cut(edge)：断开某条边。
- query_max(u, v)：查询u到v路径上的最大边权。
但LCT通常的link和cut操作是基于节点之间的连接，而不是边。因此，如何将边的权值融入节点？
一种常用的方法是将每条边视为一个节点。例如，原树中的边可以插入为虚拟节点，每个这样的节点存储边权。但这样会增加节点数目，可能会影响时间复杂度。
或者，可以将边权保存在节点中，例如，每个节点保存到父节点的边的权值。这样，在LCT中，每个节点的权值是其到父节点的边的权值。当需要查询路径中的最大边权时，只需要比较路径中所有节点的权值中的最大值。
这可能是一个更简单的方法。因为每条边在LCT中对应两个方向的父连接。例如，对于边a-b，权c，假设a是父节点，那么b的父指针指向a，且b的权值为c。当路径经过这条边时，该权值会被计入最大值比较。
这样，LCT中的每个节点维护到父节点的边的权值。并且，在路径查询时，最大的权值即为路径中的最大边权。
例如，当查询u到v的路径的最大边权时，在LCT中将u和v的路径合并到同一个splay树中，然后遍历路径上的所有节点的权值，找到最大值。但如何高效地做到这一点？
这需要每个节点维护子树中的最大值，这样在splay操作时，可以快速查询路径上的最大值。
因此，每个节点需要维护以下信息：
- 父节点、左子、右子
- rev标记
- weight：该节点到父节点的边的权值
- max_val：该子树中的最大边权值
当合并两个子树时，节点的max_val是当前节点的weight、左子树的max_val、右子树的max_val中的最大值。
在push_up操作中，max_val被更新为这三个值的最大值。
这样，当splay操作完成之后，根节点的max_val就是整个路径的最大边权。
这样，在查询u到v的路径的最大边权时，可以执行以下步骤：
1. 将u
设置为根。
2. 将v连接到根所在的splay树中，此时v所在的splay树的路径就是u到v的路径。
3. 此时，该splay树的max_val即为路径中的最大边权。
或者，需要更精确的操作。例如，在LCT中，调用expose(v)将u到v的路径打通，然后访问v的max_val属性。
具体来说，可以使用LCT的split操作将u和v所在的路径分离出来，并查询该路径的最大值。
这可能需要更详细的LCT实现。
例如，在实现LCT时，每个节点的结构体包含：
struct Node {
Node *ch[2], *fa;
int rev;
int weight; // 到父节点的边的权值
int max_val;
// 其他信息...
};
其中，max_val表示该节点所在splay树中的最大边权值，包括该节点的weight以及左右子树的max_val。
每次push_up操作时，该节点的max_val取max(左子树的max_val, 右子树的max_val, weight)。
这样，当执行splay操作时，每个节点的max_val会被正确维护。
当需要查询u到v的路径的最大边权时，可以：
1. 将u和v进行split，使得它们的路径成为当前splay树的根。
或者，更详细地说：
在LCT中，要查询u到v的路径的最大边权，可以执行：
- make_root(u)：将u设为根。
- access(v)：将v到根的路径打通，形成一个splay树。
- splay(v)：将v旋转到splay树的根。
此时，v的max_val就是路径u到v的最大边权。
这可能正确，因为此时v所在的splay树包含整个路径u到v的所有节点，而每个节点的max_val已经维护了路径中的最大值。
这样，查询路径最大值的时间复杂度是O(log N)。
当需要断开最大边时，如何找到对应的节点？
例如，假设路径的最大边权是max_val，那么需要找到对应的边所在的节点。例如，这个边是路径中某个节点x到其父节点的边。此时，x的weight等于max_val。要找到这个x。
但这似乎比较困难，因为每个节点的weight存储的是其到父节点的边的权值，而父节点可能不是该路径中的一部分。
或许，在查询路径最大值时，除了得到最大值之外，还需要得到对应的边所在的节点。这可能需要每个节点在维护max_val的同时，也维护max_node，即该子树中最大边对应的节点（即，其到父节点的边的权值等于该子树的max_val的节点）。
此时，每个节点的push_up函数还需要维护max_node：
struct Node {
// ...其他属性
int max_val;
Node *max_node; // 指向该子树中最大边对应的节点
};
在push_up时：
left_max = left ? left->max_val : 0;
right_max = right ? right->max_val : 0;
current = weight;
max_val = max(left_max, right_max, current);
然后，确定max_node：
if (max_val == current) {
max_node = this;
} else if (left && max_val == left_max) {
max_node = left->max_node;
} else {
max_node = right->max_node;
}
这样，当访问路径的max_val时，对应的max_node即为该路径中最大边对应的节点。
这样，当需要断开该边时，可以切断该max_node节点与其父节点的链接。
例如，执行cut(max_node)即可断开该边。
因此，在LCT中，当查询到max_val和max_node后，可以执行以下操作：
cut(max_node);
这将断开该节点与其父节点的链接，从而删除这条边。
然后，将新边u-v的权值w加入到LCT中：
link(u, v, w);
link操作需要将u和v连接，并
设置边的权值。例如，假设u是树中的一个节点，v是另一个树的根，那么执行link(u, v)会将v的父节点设为u，并
设置v的weight为w。
这样，新边u-v的权值w就被正确存储。
综上，整个LCT的实现需要支持：
- make_root(u): 将u设为根。
- access(v): 打通到根的路径。
- find_max(u, v): 查询u到v路径的最大边权及对应的节点。
- cut(node): 断开该节点与其父节点的边。
- link(u, v, w): 将u和v连接，边权为w.
这样，每次查询的处理步骤为：
对于查询中的u, v, w：
1. 在LCT中，将u和v所在的树的路径找到，并查询最大边权max_val和对应的节点max_node.
a. 首先，make_root(u).
b. access(v), splay(v).
c. max_val = v->max_val.
d. max_node = v->max_node.
2. 如果w < max_val：
a. sum = sum - max_val + w.
b. 执行cut(max_node)，断开该边。
c. 执行link(u, v, w)，添加新边。
3. 输出sum.
这样，每次查询的时间复杂度是O(log N).
现在，如何初始化原树的边？
原树的边数目是N-1条。我们需要将这些边构建到LCT中。这可以通过将原树进行某种遍历，例如DFS或 BFS，并依次连接各个节点，
设置边的权值。
例如，可以以节点1为根，然后对每个节点，找到其子节点，并执行link操作，
设置对应的权值。
这可能需要将原树转换为以节点1为根的有根树结构，并确定每个节点的父节点。例如，使用BFS遍历原树，并记录每个节点的父节点和对应的边权。
例如，原树的结构可以通过邻接表存储。然后，使用BFS遍历，从根节点1出发，访问所有节点。对于每个节点u，遍历其邻接表中的所有邻接节点v。如果v不是父节点，则将其父节点设为u，并记录边权。然后，在LCT中执行link(u, v, c)操作，其中c是边的权值。
这样，原树的所有边就被正确加入到了LCT中。
现在，关于LCT的具体实现，需要编写相应的代码结构。然而，对于编程竞赛来说，实现一个完整的LCT结构需要一定的代码量，并处理许多细节。例如，节点结构的定义、splay操作、旋转、push_up、push_down、rev标记的处理等。
综上，本题的正确解法应该是使用Link-Cut Tree动态维护MST的结构，并在每次查询时，找到当前u-v路径的最大边权，判断是否需要替换，并更新总和sum。这样，每次查询的时间复杂度为O(log N)，能够处理题目中的约束条件。
最后，考虑示例
输入：
示例
输入：
4 4
1 2 6
2 3 5
2 4 4
1 3 3
1 2 3
1 4 10
3 4 1
初始sum为6+5+4=15。
第一个查询：添加1-3，w=3。原树中1-3的路径是1-2-3。边权分别是6和5。最大边权是6。w=3 <6，所以替换。sum=15-6+3=12. 输出12.
第二个查询：添加1-2，w=3。原树中的1-2边已经被替换为1-3-2的路径。此时，添加1-2的边，查询路径1-2的最大边。此时，当前MST中1和2的路径是1-3-2。边的权值是3（1-3）和5（2-3）。最大是5。新边w=3 <5。所以替换，sum=12-5+3=10. 输出10.
第三个查询：添加1-4，w=10.路径1-4的当前路径是1-3-2-4。边权3，5，4。最大是5。新边w=10 >=5，所以不替换。sum还是10. 输出10.
第四个查询：添加3-4，w=1.路径3-4的当前路径是3-2-4。边权5，4。最大是5。w=1 <5，替换。sum=10-5+1=6. 但是示例的输出是7。这说明我的分析有误？
哦，这里可能哪里出错了？
示例输出是：
12
10
10
7
第四个查询的处理：添加3-4边，权1。此时，在当前的MST中，3和4的路径应该是怎样的？
当前的MST结构：经过前三次查询后的结构可能已经改变了。比如，第一个查询后的MST结构包括边1-3（3）、2-3（5）、2-4（4）？或者可能被替换为其他边？
或者，在第二个查询后，添加边1-2的权3，替换路径1-3-2中的最大边5。所以，原路径1-3-2的最大边是5，被替换，所以MST中的边变为1-3（3）、1-2（3）， 2-4（4）？或者可能其他结构？
这时候，MST的总权值为3+3+4=10.
第三个查询添加边1-4权10。此时，原MST中的1和4的路径是1-2-4，边权3和4。最大是4。新边的权是10>4，所以不替换。总和还是10.
第四个查询添加边3-4权1。此时，3和4在当前的MST中的路径是3-2-4，边权5和4？或者可能当前的路径是3-1-2-4？
这取决于LCT中的实际路径结构。例如，在第二个查询中，添加边1-2权3，替换了原来的路径中的最大边5，所以原边2-3的权5被断开，并被1-2的权3替换。所以，当前的MST结构包括边1-3（3）、1-2（3）、 2-4（4）吗？或者，可能其他结构？
这样，3和4的路径是3-1-2-4，边权3（3-1）、3（1-2）、4（2-4）。最大边是4。新边3-4的权1 <4，所以替换，sum=10-4+1=7。所以输出7。这与示例相符。
这说明，每次查询的处理是正确的，只要能够正确维护当前MST的结构，并正确找到路径中的最大边。
综上，该思路是正确的，并且能够正确解决
问题。现在需要编写相应的代码。
代码实现需要完成以下几个部分：
1. 读取
输入，构建原树的邻接表，并使用BFS或DFS确定每个节点的父节点和对应的边权。
2. 初始化LCT结构，将所有原树的边加入LCT。
3. 处理每个查询，按照上述步骤进行处理。
在编写LCT时，需要注意每个节点的max_val和max_node的维护，以及link和cut操作的实现。
由于代码的实现较为复杂，下面给出一个大致的
框架：
首先，定义LCT的节点结构：
struct Node {
Node *ch[2], *fa;
int rev;
int weight; // 到父节点的边的权值
int max_val;
Node *max_node;
// 其他成员，如size等，根据需求添加
Node() {
ch[0] = ch[1] = fa = nullptr;
rev = 0;
weight = 0;
max_val = 0;
max_node = this;
}
bool is_root() {
return fa == nullptr || (fa->ch[0] != this && fa->ch[1] != this);
}
void push_down() {
if (rev) {
swap(ch[0], ch[1]);
if (ch[0]) ch[0]->rev ^= 1;
if (ch[1]) ch[1]->rev ^= 1;
rev = 0;
}
}
void push_up() {
max_val = weight;
max_node = this;
if (ch[0] && ch[0]->max_val > max_val) {
max_val = ch[0]->max_val;
max_node = ch[0]->max_node;
}
if (ch[1] && ch[1]->max_val > max_val) {
max_val = ch[1]->max_val;
max_node = ch[1]->max_node;
}
}
};
然后，实现LCT的旋转、splay、access等操作：
void rotate(Node *x) {
Node *y = x->fa, *z = y->fa;
int k = x == y->ch[1];
if (!y->is_root()) z->ch[z->ch[1] == y] = x;
x->fa = z;
y->ch[k] = x->ch[k^1];
if (x->ch[k^1]) x->ch[k^1]->fa = y;
x->ch[k^1] = y;
y->fa = x;
y->push_up();
x->push_up();
}
void splay(Node *x) {
vector<Node*> path;
for (Node *y = x; ; y = y->fa) {
path.push_back(y);
if (y->is_root()) break;
}
reverse(path.begin(), path.end());
for (auto &y : path) y->push_down();
while (!x->is_root()) {
Node *y = x->fa;
if (!y->is_root()) rotate((x == y->ch[1]) ^ (y == y->fa->ch[1]) ? x : y);
rotate(x);
}
x->push_up();
}
void access(Node *x) {
for (Node *y = nullptr; x; y = x, x = x->fa) {
splay(x);
x->ch[1] = y;
x->push_up();
}
}
void make_root(Node *x) {
access(x);
splay(x);
x->rev ^= 1;
x->push_down();
}
Node* find_root(Node *x) {
access(x);
splay(x);
while (x->ch[0]) {
x = x->ch[0];
x->push_down();
}
splay(x);
return x;
}
void link(Node *x, Node *y, int w) {
make_root(x);
x->fa = y;
x->weight = w;
y->push_up();
}
void cut(Node *x) { // 切断x与其父节点的边
access(x);
splay(x);
if (x->ch[0]) {
x->ch[0]->fa = nullptr;
x->ch[0] = nullptr;
x->push_up();
}
}
然后，在主程序中：
读取N和Q。
构建原树的结构。例如，使用邻接表存储边。然后，通过BFS确定每个节点的父节点和对应的边权。
初始化LCT的节点数组。每个节点对应一个Node对象。
然后，根据原树的父节点关系，将所有边加入LCT中。
计算初始sum为所有原边权之和。
处理每个查询：
对于每个查询u, v, w：
1. 找到u和v节点在LCT中的对应Node对象。
2. 执行make_root(u), access(v), splay(v).
3. 如果u和v不在同一棵树中（即原树被分割），此时添加的边将连接两棵树，需要将这条边加入MST，sum += w. 但根据原题的条件，初始图是连通的，并且每次添加边后，图依然是连通的。所以，这种情况在本题中不会发生。因此，可以假设u和v在同一个树中，每次查询后的图都是连通的。因此，无需处理这种情况。
4. 获取max_val = v->max_val, max_node = v->max_node.
5. 如果w < max_val：
sum = sum - max_val + w.
cut(max_node).
link(u_node, v_node, w).
6. 输出sum.
需要注意的是，link操作中的方向。例如，在link(u_node, v_node, w)时，应将u_node的父节点设为v_node，并
设置u_node的weight为w？或者应该将v_node的父节点设为u_node？
这可能需要根据LCT的link实现进行调整。例如，在当前的link函数中，make_root(x)使得x成为其所在树的根，然后将x的父节点设为y，并
设置x的weight为w。这样，y是x的父节点，x的weight是w.
这样，在添加新边u-v时，需要将u和v中的一个作为父节点，另一个作为子节点。例如，假设我们调用link(u, v, w)，将u的父节点设为v，并
设置u的weight为w。或者，应该将v的父节点设为u？
或者，可能应该调用link(u, v, w)和link(v, u, w)？这可能不必要，因为LCT中的边是无向的，但物理上是有父指针的。
正确的做法是，在link(u, v, w)时，无论u和v的当前父节点如何，将其中一个连接到另一个。例如，make_root(u)，此时u的父节点为NULL。然后，将u的父节点设为v，并
设置u的weight为w. 这样，在LCT中，u成为v的子节点，边权为w.
这样，在查询路径时，无论方向如何，都可以正确找到路径的最大边权。
因此，在每次添加新边u-v时，执行：
make_root(u);
access(v);
splay(v);
max_val = v->max_val;
max_node = v->max_node;
if (w < max_val):
cut(max_node);
link(u_node, v_node, w);
或者，在link时，应该将其中一个节点作为父节点，另一个作为子节点。例如，调用link(u_node, v_node, w)将u_node的父节点设为v_node，并
设置u_node的weight为w.
这可能需要验证。
综上，本题的正确解法需要动态维护MST的结构，并利用LCT高效处理路径查询和边的替换。代码实现虽然复杂，但可以符合题目的时间要求。</think>要解决这个
问题，我们需要动态维护图的最小生成树（MST）并在每次添加新边后高效计算MST的总权重。由于每次添加边后需要快速找到路径中的最大边权并决定是否替换，我们使用Link-Cut Tree（LCT）来高效处理这些操作。
### 方法思路
1. **初始MST计算**：初始图是一棵树，直接计算所有边的权重和。
2. **动态维护MST**：每次添加新边时，找到当前MST中两端点路径上的最大边权。如果新边的权重更小，则替换该最大边，并更新总权重。
3. **高效查询与替换**：使用LCT来维护树的动态结构，支持路径上的最大边权查询和边的替换操作。
### 解决代码
```cpp
#include <
iostream>
#include <vector>
#include <queue>
using namespace std;
struct Node {
Node *ch[2], *fa;
int rev;
int weight;
int max_val;
Node *max_node;
Node() : ch{nullptr, nullptr}, fa(nullptr), rev(0), weight(0), max_val(0), max_node(this) {}
bool is_root() {
return fa == nullptr || (fa->ch[0] != this && fa->ch[1] != this);
}
void push_down() {
if (rev) {
swap(ch[0], ch[1]);
if (ch[0]) ch[0]->rev ^= 1;
if (ch[1]) ch[1]->rev ^= 1;
rev = 0;
}
}
void push_up() {
max_val = weight;
max_node = this;
for (int i = 0; i < 2; ++i) {
if (ch[i] && ch[i]->max_val > max_val) {
max_val = ch[i]->max_val;
max_node = ch[i]->max_node;
}
}
}
};
void rotate(Node *x) {
Node *y = x->fa, *z = y->fa;
int k = x == y->ch[1];
if (!y->is_root()) {
z->ch[z->ch[1] == y] = x;
}
x->fa = z;
y->ch[k] = x->ch[k ^ 1];
if (x->ch[k ^ 1]) {
x->ch[k ^ 1]->fa = y;
}
x->ch[k ^ 1] = y;
y->fa = x;
y->push_up();
x->push_up();
}
void splay(Node *x) {
while (!x->is_root()) {
Node *y = x->fa;
if (!y->is_root()) {
rotate((x == y->ch[1]) == (y == y->fa->ch[1]) ? y : x);
}
rotate(x);
}
}
void access(Node *x) {
for (Node *y = nullptr; x; x = x->fa) {
splay(x);
x->ch[1] = y;
x->push_up();
y = x;
}
}
void make_root(Node *x) {
access(x);
splay(x);
x->rev ^= 1;
x->push_down();
}
void link(Node *x, Node *y, int w) {
make_root(x);
x->fa = y;
x->weight = w;
x->push_up();
}
void cut(Node *x) {
access(x);
splay(x);
if (x->ch[0]) {
x->ch[0]->fa = nullptr;
x->ch[0] = nullptr;
x->push_up();
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, Q;
cin >> N >> Q;
vector<vector<pair<int, int>>> adj(N + 1);
vector<int> parent(N + 1, 0);
vector<int> edge_weight(N + 1, 0);
for (int i = 0; i < N - 1; ++i) {
int a, b, c;
cin >> a >> b >> c;
adj[a].emplace_back(b, c);
adj[b].emplace_back(a, c);
}
queue<int> q;
q.push(1);
parent[1] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto &p : adj[u]) {
int v = p.first;
int c = p.second;
if (v != parent[u] && parent[v] == 0) {
parent[v] = u;
edge_weight[v] = c;
q.push(v);
}
}
}
vector<Node> nodes(N + 1);
long long sum = 0;
for (int v = 2; v <= N; ++v) {
int u = parent[v];
link(&nodes[v], &nodes[u], edge_weight[v]);
sum += edge_weight[v];
}
while (Q--) {
int u, v, w;
cin >> u >> v >> w;
make_root(&nodes[u]);
access(&nodes[v]);
splay(&nodes[v]);
int max_val = nodes[v].max_val;
Node *max_node = nodes[v].max_node;
if (w < max_val) {
sum = sum - max_val + w;
cut(max_node);
link(&nodes[u], &nodes[v], w);
}
cout << sum << '\n';
}
return 0;
}
```
### 代码解释
1. **LCT节点结构**：每个节点维护父节点、子节点、反转标记、边权、最大值及其对应的节点。
2. **旋转与伸展操作**：用于维护树的平衡和路径信息。
3. **访问与根转换**：打通路径并调整树结构。
4. **链接与断开**：处理边的添加和删除。
5. **主程序逻辑**：读取
输入，构建初始树，预处理父节点和边权，初始化LCT，处理每个查询并输出结果。
通过LCT动态维护MST，每次查询时间复杂度为O(log N)，能够高效处理大规模
输入。
扫一扫
1027
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
