Race

Análisis oficial (descomposición por centroide) 

Solución alternativa: fusión small-to-large

Hay que hallar un camino con el mínimo número de aristas recorridas tal que la suma del camino sea $s$. Primero, enraizamos el árbol de forma arbitraria. Sea $\text {lca}(u, v) = w$. Podemos partir $\text {path}(u, v)$ en $\text {path}(u, w)$ y $\text {path}(v, w)$.

Como $w$ debe ser un ancestro de $u$ y de $v$, $\text {sum}(u, w) = \text {sum}(u, root) - \text {sum}(w, root)$ y $\text {sum}(v, w) = \text {sum}(v, root) - \text {sum}(w, root)$, donde $\text {sum}(a, b)$ es la suma del camino entre los 2 nodos $a$ y $b$. Podemos calcular $\text {sum}(i, root)$ para todo $i$ en $O(N)$ con un DFS simple. También calculamos $\text {dist}(i, root)$, que es el número de aristas entre $i$ y $root$, de forma similar.

Hacemos fusión small-to-large para hallar un $\text {lca}$ $i$ tal que $\text {sum}(u, root) + \text {sum} (v, root) - 2 \cdot \text {sum}(i, root) = s$, y $\text {dist}(u, root) + \text {dist}(v, root) - 2 \cdot \text {dist}(i, root) = s$ se minimice.

Para lograrlo, podemos usar fusión small-to-large. Para cada $i$, mantenemos un mapa de pares clave-valor $\text {sum}(root, j) : \text {dist}(root, j)$ para $\text {sum}(root, j)$ distintos, para todo $j$ en el subárbol de $i$. Si hay $\text {sum}(root, j)$ duplicados, tomamos el mínimo $\text {dist}(root, j)$.

Al combinar los mapas de dos nodos, iteramos sobre cada par clave-valor $(sum_s, dist_s)$ del mapa de menor tamaño, buscamos un par $sum_l = s - sum_s$ en el mapa más grande, y si existe obtenemos $dist_s + dist_l$ a partir de $sum_l$. Nuestra respuesta sería el mínimo $dist_s + dist_l$ sobre todas las fusiones. Durante este proceso también fusionamos todos los pares clave-valor del mapa más pequeño.

Implementación

Complejidad temporal: $\mathcal{O}(N\log^2N)$

Los factores logarítmicos vienen de la fusión small-to-large y de las operaciones del mapa.

#include <bits/stdc++.h>
 
using namespace std;
 
typedef long long ll;
typedef pair<ll, ll> pii;
 
#define pb push_back
 
#define f first
#define s second
 
const int maxn = 2e5 + 1;
vector<pii> adj[maxn];
map<ll, ll> info[maxn];
ll dist[maxn], sum[maxn];  // define these relative to root
int N, K;
ll ret;
 
void precomp(int u, int p, ll c, int h) {
	info[u][c] = h;
	sum[u] = c;
	dist[u] = h;
	for (auto n : adj[u]) {
		if (p == n.f) { continue; }
		precomp(n.f, u, c + n.s, h + 1);
	}
}
 
void small_to_large_merge(int u, int p) {
	ll target = K + 2 * sum[u];
	for (auto n : adj[u]) {
		if (n.f == p) { continue; }
		small_to_large_merge(n.f, u);
		if (info[n.f].size() > info[u].size()) { swap(info[n.f], info[u]); }
		for (auto i : info[n.f]) {
			if (info[u].find(target - i.f) != info[u].end()) {
				ret = min(ret, info[u][target - i.f] + i.s - 2 * dist[u]);
			}
		}
		for (auto i : info[n.f]) {
			if (info[u].find(i.f) == info[u].end()) {
				info[u].insert(i);
			} else {
				info[u][i.f] = min(info[u][i.f], i.s);
			}
		}
	}
}
 
int best_path(int n, int k, int edges[][2], int weights[]) {
	N = n;
	K = k;
	ret = INT_MAX;
	for (int i = 0; i < n - 1; i++) {
		int u = edges[i][0];
		int v = edges[i][1];
		adj[u].pb(pii(v, weights[i]));
		adj[v].pb(pii(u, weights[i]));
	}
	precomp(0, -1, 0, 0);
	small_to_large_merge(0, -1);
	return ret == INT_MAX ? -1 : ret;
}