洛谷P1967货车运输（最大生成树 && LCA倍增）

<think>嗯，这个问题看起来是关于货车运输的最大载重问题。题目大意是说，给定一个无向图，每条边都有一个限重，然后对于每个查询，找到从x到y的路径中，这条路径的最小边权最大的那条路径，并输出这个最小值。如果无法到达则输出-1。 首先，我得想想这个问题应该怎么建模。最大生成树？因为要保证路径中的最小边权尽可能大，所以可能最大生成树里的路径就是最优的。因为最大生成树会选择边权尽可能大的边来连接各个节点，这样在树上的路径的最小边权就是最大的可能值。 那步骤可能是这样的：首先构建最大生成树，然后在最大生成树上处理查询。对于查询的两个节点，找到它们在最大生成树上的路径中的最小边权。这时候可能需要用到LCA（最近公共祖先）的方法，结合预处理每个节点到祖先路径上的最小边权。 具体来说，构建最大生成树可以使用Kruskal算法，按边权从大到小排序，然后用并查集来维护连通性。生成树之后，每个节点可能需要存储父节点信息和到父节点的边的权重。然后，预处理每个节点向上2^k步的祖先，以及对应的路径上的最小边权。这样，在查询时，找到x和y的LCA，然后分别沿着x和y向上跳，同时记录路径中的最小边权，最后合并得到整个路径的最小值。 不过，可能会有多个连通块的情况。比如，原图可能不是连通的，因此在生成树之后，每个连通块是一棵树。所以在处理查询的时候，需要先判断x和y是否在同一个连通块中，如果不在，直接返回-1。 那具体实现的话，大概的步骤是： 1. 对所有的边按照权重从大到小排序，构建最大生成树。这里可能需要用Kruskal算法，因为边的数量较多，但并查集的时间复杂度应该可以接受。 2. 对于每个节点，构建倍增数组，保存每个节点的祖先和对应的路径中的最小边权。比如，up[k][u]表示u节点向上2^k步到达的祖先，min_edge[k][u]表示这段路径中的最小边权。 3. 预处理每个节点的深度，以及倍增数组。 4. 对于每个查询，先检查x和y是否连通。如果不连通，返回-1。否则，找到它们的LCA，并在寻找LCA的过程中，记录路径中的最小边权。 举个例子，比如样例输入： 4个城市，3条边，边分别是1-2（4），2-3（3），3-1（1）。最大生成树应该会选1-2（4）和2-3（3），这样形成连通图。第三个边3-1的权重1更小，所以不会被选中。所以生成树中的边是两条，构成1-2-3，而城市4没有边连接，所以是孤立的。 当查询1-3时，路径是1-2-3，边权分别是4和3，所以最小的是3。而查询1-4的时候，不在同一连通块，返回-1。第三个查询还是同样的结果。 那问题来了，如何处理生成森林中的各个树？比如，每个树单独处理，各自有自己的父节点关系。或者，在预处理的时候，每个树分别处理它们的倍增数组。 所以，具体步骤： - Kruskal算法构建最大生成森林。然后，对每个树进行DFS或者BFS，记录每个节点的父节点和到父节点的边的权重，同时计算每个节点的深度。 - 然后，构建倍增数组。对于每个节点u，up[0][u]就是它的父节点，min_edge[0][u]就是到父节点的边的权重。然后，对于k>0，up[k][u] = up[k-1][up[k-1][u]]，而min_edge[k][u] = min(min_edge[k-1][u], min_edge[k-1][up[k-1][u]]). 这样预处理之后，每个节点向上2^k步的路径中的最小边权就保存下来了。 当处理查询x和y的时候，首先判断是否在同一个并查集中。如果不在，返回-1。否则，找到它们的LCA，并在过程中计算路径的最小边权。 寻找LCA的步骤中，需要先将x和y调整到同一深度。比如，假设x的深度更大，那么将x向上跳直到和y同一深度，同时记录每一步的最小边权。然后，同时向上跳，直到找到共同祖先。在此过程中，每一步都要记录最小的边权。 举个例子，假设x和y的LCA是l。那么路径x到l，y到l的路径中的最小边权，取两者的最小值，就是整个路径的最小边权，也就是答案。 这样，整个算法的时间复杂度大概是： - Kruskal算法的时间复杂度是O(m log m)，因为需要排序。 - 预处理倍增数组的时间是O(n log n)，每个节点处理log层。 - 每个查询的时间是O(log n)，因为LCA的查询是log级别的。 对于n到1e4，q到3e4的情况，这样的时间复杂度应该是可以通过的。 那现在需要考虑实现的具体细节。比如，如何构建最大生成树，如何处理多个连通块，以及如何高效地预处理倍增数组。 首先，边的排序要按照权重降序排列。然后，使用并查集来连接各个节点，确保每次选取的边都是当前最大的，且不形成环。 构建完生成森林后，每个连通块是一棵树。然后，对于每个节点，需要确定父节点，并建立树的结构。这一步可以通过DFS或BFS完成。比如，对每个连通块，从根节点（可以任意选）开始，遍历生成树中的边，记录父节点和对应的边权。 需要注意的是，生成树中的边可能并不是原图中的所有边，而是选出的最大生成树的边。所以，在生成树构建完成后，需要根据并查集的连通情况，重新构建每个连通块的树结构。这一步可能需要将生成树中的边单独存储。 或者，更高效的方式是，在Kruskal过程中，每选取一条边时，将这条边加入到生成森林的数据结构中。比如，可以维护邻接表，只保存最大生成树的边。 或者，在Kruskal之后，遍历所有属于生成树的边，并建立邻接表。但这样可能需要额外的处理。比如，可以记录每条边是否被选中，或者，因为生成树的过程已经用并查集连接，所以可能需要另一种方式。 或者，可以在Kruskal过程中，当合并两个集合的时候，添加这条边到邻接表中。例如，当合并x和y所在的集合时，将这条边加入邻接表，作为树中的边。这样，生成森林的结构就被保存在邻接表中。 是的，这应该可行。例如，初始化邻接表为空。在Kruskal处理每条边时，如果该边连接两个不同的集合，就将这条边加入邻接表两次（因为是双向的），然后合并集合。这样，邻接表中存储的就是最大生成森林的边。 然后，在预处理倍增数组时，遍历每个节点，如果还没有被访问过，就以该节点为根进行DFS或BFS，记录父节点、深度，以及边权。 这一步可能需要注意，因为生成森林可能有多个树，每个树需要单独处理。 接下来，构建倍增数组。例如，假设最大深度不超过log2(n)，所以预处理到log2(n)层即可。对于每个节点，从k=1到log层，计算up和min_edge数组。 然后，处理每个查询时，先检查x和y是否在同一个并查集的集合中。如果不是，输出-1。否则，找到它们的LCA，并计算路径中的最小边权。 现在，问题是如何在LCA过程中记录路径上的最小边权。例如，当调整x和y到同一深度时，每一步的上跳都要记录当前的min值。然后，当同时上跳时，也需要记录两边的min，最后合并得到整个路径的最小。 具体来说，假设要找x和y的LCA，并且在这个过程中找到x到LCA和y到LCA路径中的最小边权。这两个最小值中的较小者，就是整个路径的最小边权。 实现时，可以将问题拆分为两个步骤： 1. 将x和y提升到同一深度，并记录过程中的最小值。 2. 同时提升x和y直到找到LCA，同时记录这两个路径中的最小值。 例如，函数实现可能如下： def lca(x, y): min_val = infinity if depth[x] < depth[y]: swap x and y # 将x上移到与y同一深度 while depth[x] > depth[y]: k = log2(depth[x] - depth[y]) min_val = min(min_val, min_edge[k][x]) x = up[k][x] if x == y: return min_val # 现在x和y在同一深度，寻找LCA for k in reversed(range(0, log_max)): if up[k][x] != up[k][y]: min_val = min(min_val, min_edge[k][x], min_edge[k][y]) x = up[k][x] y = up[k][y] # 最后一步，检查父节点是否为LCA min_val = min(min_val, min_edge[0][x], min_edge[0][y]) return min_val 这可能有些简略，但大体思路是这样的。需要不断比较路径上的最小值，并将所有步骤的最小值记录下来。 需要注意的是，在调整深度的时候，可能不能一次跳2^k步，而是需要从最大的可能步长开始尝试，直到深度差为0。例如，在调整x的深度到y的深度时，需要循环k从大到小，每次如果当前步长可以跳，就跳，并记录对应的边权。 或者，另一种方法是，在预处理时，每个节点的深度已知，调整的时候，用二进制分解的方式，将深度差分解为二进制，然后逐个处理每一位。比如，在将x上移d步的时候，d是depth[x] - depth[y]，然后将d分解为二进制，每一位如果是1，就跳对应的步长。 比如，假设d=5（二进制101），那么k=2（步长4），跳之后，剩下的1，再跳k=0（步长1）。 这样，在调整深度的过程中，可以计算路径中的最小值。 例如： 初始化 min_val = INF d = depth[x] - depth[y] for k in range(log_max, -1, -1): if d & (1 << k): min_val = min(min_val, min_edge[k][x]) x = up[k][x] 然后，同样的步骤处理x和y的共同祖先。 这样，在调整到同一深度之后，x和y可能已经处于同一个节点，这时候直接返回当前的min_val。否则，继续处理共同祖先。 所以，在具体的实现中，需要将调整深度和寻找LCA的过程中的每一步的最小边权都记录下来。 现在，关于代码实现的一些细节： 1. 预处理log_max的值。比如，log_max = 20，因为2^20超过1e4，足够处理n=1e4的情况。 2. 使用并查集来判断连通性，同时在Kruskal过程中构建生成树的邻接表。 3. 在构建邻接表之后，进行DFS或BFS遍历每个连通块，记录每个节点的父节点、深度，以及到父节点的边的权重。 4. 预处理倍增数组，up数组和min_edge数组。 对于具体的代码结构，可能如下： - 输入n，m。 - 输入m条边，存储到一个列表edges中。 - 对edges按照z从大到小排序。 - 初始化并查集。 - 初始化邻接表：adj = [[] for _ in range(n+1)] - Kruskal算法：遍历所有边，按降序顺序。对于每条边x,y,z，如果x和y不在同一集合，就将这条边添加到邻接表中，并合并两个集合。这样，邻接表中存储的是最大生成森林的边。 - 初始化父数组，深度数组，以及min_edge数组。初始时，父数组为0，深度为0或未访问。 - 对每个节点，如果尚未被访问过，进行DFS或BFS，建立树的结构。例如，BFS时： queue = deque() visited = [False] * (n+1) for i in 1..n: if not visited[i]: queue.append(i) visited[i] = True parent[i] = 0 depth[i] = 0 while queue not empty: u = queue.popleft() for v, w in adj[u]: if not visited[v]: visited[v] = True parent[v] = u depth[v] = depth[u] + 1 min_edge[0][v] = w queue.append(v) - 然后，预处理倍增数组： 对于每个节点u，up[0][u] = parent[u], min_edge[0][u] = 到父节点的边的权重。 对于k从1到log_max: for u in 1..n: up[k][u] = up[k-1][up[k-1][u]] min_edge[k][u] = min(min_edge[k-1][u], min_edge[k-1][up[k-1][u]]) 需要注意的是，当up[k-1][u]为0时（即没有父节点），可能需要处理为不可达，或者跳过这些情况。例如，在预处理时，对于节点u，如果up[k-1][u]为0，那么up[k][u]也为0，而min_edge[k][u]可能保留原来的值或者取一个极小值？ 或者，在预处理的时候，只处理那些存在父节点的情况。或者，在查询的时候，如果某个祖先不存在（即up[k][u]为0），则跳过该步长。 这部分需要仔细处理，否则可能导致数组越界或者错误。 现在，当处理查询时，首先判断x和y是否连通。这可以通过并查集的find函数来判断。如果在同一个集合，才进行后续处理；否则返回-1。 然后，找到x和y的LCA，并在过程中记录路径的最小边权。 例如： def query(x, y): if find(x) != find(y): return -1 res = infinity if depth[x] < depth[y]: x, y = y, x # 提升x到y的深度 for k in range(log_max, -1, -1): if depth[x] - (1 << k) >= depth[y]: res = min(res, min_edge[k][x]) x = up[k][x] if x == y: return res # 同时提升x和y for k in range(log_max, -1, -1): if up[k][x] != up[k][y]: res = min(res, min_edge[k][x], min_edge[k][y]) x = up[k][x] y = up[k][y] # 此时x和y的父节点是LCA res = min(res, min_edge[0][x], min_edge[0][y]) return res 这样，返回的res就是路径中的最小边权的最大可能值。 现在，测试样例的情况： 比如输入中的边1-2（4）、2-3（3）、3-1（1）。在最大生成树中，前两条边会被选中，第三条边会被忽略，因为形成环。所以生成树的结构是1-2-3。城市4孤立。 查询1-3时，路径是1-2-3，边权4和3，最小值是3。查询1-4，不在同一集合，返回-1。第三个查询同第一个。 那在代码中的处理： 预处理时，对于节点1，父节点是0，或者假设根节点是1。在BFS时，可能根节点的父是0，深度是0。子节点2的父是1，深度1，min_edge[0][2] =4。节点3的父是2，深度2，min_edge[0][3]=3。 倍增数组预处理： 对于k=0，min_edge[0][2]=4，up[0][2] =1。min_edge[0][3]=3，up[0][3]=2. 对于k=1，up[1][3] = up[0][up[0][3]] = up[0][2] =1。min_edge[1][3] = min(3,4)=3. 当查询1和3时，他们的LCA是1。在调整深度时，3的深度是2，1的深度是0。所以将3提升到0的深度： 初始x=3，depth=2，y=1，depth=0. 需要将x的深度降低到0。循环k从log_max（比如20）到0： 当k=1时，1<<1=2，此时depth[x] -2 >=0，可以跳。min_edge[1][3]是3。x变成up[1][3]=1。此时x的深度是0，等于y的深度。 然后，x等于y，返回3。正确。 另一个例子，比如查询1和4，不在同一集合，返回-1。 所以，代码逻辑是正确的。 现在，关于代码实现中的问题，比如数组的大小。因为n可以达到1e4，所以数组的维度需要足够。例如，log_max取15（因为2^15=32768，大于1e4）。 另外，在预处理倍增数组的时候，需要注意节点是否可达。比如，如果某个节点的父节点是0，那么向上跳的时候可能会越界。这时候，在预处理时，可以将父节点设为0，且对应的min_edge可能设为一个极大值或者忽略。或者在查询的时候，判断up[k][u]是否为0，如果是的话，跳过这一步。 总之，需要确保在查询过程中不会访问到不存在的祖先节点。 另外，初始化邻接表的时候，每条边会被添加两次，因为是无向的。例如，在Kruskal选中x-y这条边时，会将y加入x的邻接表，x加入y的邻接表。但在这个过程中，可能生成树的结构是一个树，不会有环。因此，在BFS或DFS的时候，不会重复访问节点，因为每个节点会被标记为已访问。 综上，这样的算法应该可以正确解决问题。</think>### 题目介绍：P1967 [NOIP2013 提高组] 货车运输 #### **题目大意** 给定一个无向图，每条边有重量限制。对于多个查询，求从起点到终点的路径中，允许的最大载重（即路径上最小边权的最大值）。若两点不连通，返回 `-1`。 --- ### **算法思路** 1. **最大生成树** 货车的最优路径一定在最大生成树中。因为最大生成树能保证路径的边权尽可能大，路径的最小边权即为最大可能值。 2. **Kruskal 算法构建生成树** - 按边权从大到小排序，用并查集合并节点，形成最大生成森林。 3. **倍增法预处理 LCA** - 对生成树中的每个节点，预处理其各级祖先及路径上的最小边权。 - 对于查询的两点，找到其最近公共祖先（LCA），并计算路径上的最小边权。 --- ### **实现步骤** 1. **输入处理与初始化** - 读取边并按权重降序排序。 - 使用并查集构建最大生成树，并记录生成树的邻接表。 2. **预处理父节点与深度** - 通过 BFS/DFS 遍历生成树，记录每个节点的父节点、深度及到父节点的边权。 3. **构建倍增数组** - 定义 `up[k][u]` 表示节点 `u` 向上跳 $2^k$ 步的祖先。 - 定义 `min_edge[k][u]` 表示该路径的最小边权。 4. **处理查询** - 若两点不连通，返回 `-1`。 - 调整两点至同一深度，同步上跳寻找 LCA，并记录路径最小边权。 --- ### **代码实现** ```python import sys from collections import deque def main(): sys.setrecursionlimit(1 << 25) n, m = map(int, sys.stdin.readline().split()) edges = [] for _ in range(m): x, y, z = map(int, sys.stdin.readline().split()) edges.append((-z, x, y)) # 降序排序 edges.sort() # 并查集初始化 parent = list(range(n + 1)) def find(u): while parent[u] != u: parent[u] = parent[parent[u]] u = parent[u] return u # 构建