Greedy Pirate Gym - 101810M (树 + lca)
题目链接
题目大意:
一棵树,给你边相连的情况,双向边,每条边都有权值。m个查询,问从u到v能获得的最大权值。
Input:
1 T组数据
5 n个节点 n < 1e5
1 2 5 10 1到2的权值是5,2到1的权值是10
3 5 25 3
4 2 15 12
3 2 6 7
2 m个查询 m < 1e5
1 5
4 3
output:
64
65
题目思路:
简单画下图可以发现,其实最大的权值和就是总的权值和减去u到v的反向边的权值。
问题在于查询次数太多,如果没有去求一次反向边的路径会超时。
解决的方法就是,我们假设一个根,比如是1, 我们可以看出 u到v的反向路径的权值 = 根到u的正向权值和 + v到根的反向权值和 - 根到 lca(u, v)的权值和 - lca(u, v)到根的权值和。
这样我们预处理出根到每个节点的权值和 ,反向权值和。就可以直接计算了。然后因为查询是1e5,所以我们需要lca的时间复杂度是logn。
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
struct node {
int v, w1, w2;
};
vector<node> Edge[maxn];
int parent[maxn][20], dist1[maxn], dist2[maxn], depth[maxn];
//dist1 根到每个节点的权值和
//dist2 每个节点到根的权值和
//parent[root][k] 从root向上走2^k步走到的节点
//depth 当前节点的深度
void dfs(int root, int pre, int d) {
parent[root][0] = pre;
depth[root] = d;
for(int i = 1; i < 20; i++)
parent[root][i] = parent[parent[root][i - 1]][i - 1];
for(int i = 0; i < Edge[root].size(); i++) {
int to = Edge[root][i].v, w1 = Edge[root][i].w1, w2 = Edge[root][i].w2;
if(to != pre) {
dist1[to] = dist1[root] + w1;
dist2[to] = dist2[root] + w2;
dfs(to, root, d + 1);
}
}
}
int lca(int u, int v) {
if(depth[u] > depth[v]) swap(u, v);
for(int i = 0; i < 20; i++) {
if((depth[v] - depth[u]) >> i & 1) {
v = parent[v][i];
}
}
if(u == v) return u;
for(int i = 20 - 1; i >= 0; i--) {
if(parent[u][i] != parent[v][i]) {
u = parent[u][i];
v = parent[v][i];
}
}
return parent[u][0];
}
int main()
{
int t;
scanf("%d", &t);
while(t--) {
int n;
scanf("%d", &n);
for(int i = 0; i <= n; i++) Edge[i].clear();
int sum = 0;
for(int i = 1; i < n; i++)
{
int u, v, w1, w2;
scanf("%d %d %d %d", &u, &v, &w1, &w2);
Edge[u].push_back((node) {v, w1, w2});
Edge[v].push_back((node) {u, w2, w1});
sum += w1 + w2;
}
dfs(1, -1, 0);
int m;
scanf("%d", &m);
while(m--) {
int u, v;
scanf("%d %d", &u, &v);
int Lca = lca(u, v);
printf("%d\n", sum - (dist1[u] + dist2[v] - dist1[Lca] - dist2[Lca]));
}
}
}