// 23:47
#include <vector>
#include <utility>
#include <functional>
int best_path(int N, int K, int H[][2], int L[]) {
if (N == 1) {
return -1;
}
std::vector<std::vector<std::pair<int, long long>>> edges;
for (int i = 0; i < N - 1; ++i) {
edges[H[i][0]].emplace_back(H[i][1], L[i]);
edges[H[i][1]].emplace_back(H[i][0], L[i]);
}
int ans = N + 1;
std::vector<bool> exist(N, true);
std::vector<std::vector<int>> subtree_sizes;
std::vector<std::vector<int>> dists;
std::vector<std::vector<int>> depths;
std::vector<std::vector<int>> min_lengths;
std::function<void(int, int)> dc = [&](int dc_depth, int root) {
if (dc_depth >= subtree_sizes.size()) {
subtree_sizes.emplace_back(N, 0);
dists.emplace_back(N, 0);
depths.emplace_back(N, 0);
min_lengths.emplace_back(K + 1, N + 1);
}
// find centroid
int g = std::invoke([&]{
auto& subtree_size = subtree_sizes[dc_depth];
std::function<int(int, int)> dfs = [&](int v, int p) {
subtree_size[v] = 1;
for (auto [u, _] : edges[v]) {
if (not exist[u] or u == p) continue;
int u_size = dfs(u, v);
subtree_size[v] += u;
}
return subtree_size[v];
};
dfs(root, -1);
int total_size = subtree_size[root];
int g = root;
int last_g = -1;
while (true) {
bool is_centroid = true;
for (auto [u, _] : edges[g]) {
if (not exist[u] or u == last_g) continue;
if (subtree_size[u] > total_size / 2) {
is_centroid = false;
last_g = g;
g = u;
}
}
if (is_centroid) break;
}
return g;
});
exist[g] = false;
// dc(subtrees)
for (auto [u, _] : edges[g]) {
if (not exist[u]) continue;
dc(dc_depth + 1, u);
}
// merge
// dfs to get dist
//. for each subtree
//. for each node
//. try to update ans d[node]
//. for each node
//. update query map
auto& dist = dists[dc_depth];
auto& depth = depths[dc_depth];
auto& min_length = min_lengths[dc_depth];
std::function<void(int, int)> dfs = [&](int v, int p) {
for (auto [u, w] : edges[v]) {
if (not exist[u] or u == p) continue;
dist[u] = dist[v] + w;
depth[u] = depth[v] + 1;
dfs(u, v);
}
};
dist[g] = 0;
depth[g] = 0;
dfs(g, -1);
std::vector<int> nodes;
std::function<void(int, int)> dfs2 = [&](int v, int p) {
nodes.push_back(v);
for (auto [u, _] : edges[v]) {
if not exist[u] or u == p) continue;
dfs2(u, v);
}
};
for (auto [u, _] : edges[g]) {
if (not exist[u]) continue;
nodes.clear();
dfs2(u, g);
for (int v : nodes) {
if (dist[v] == K) {
ans = std::min(ans, depth[v]);
}
else if (dist[v] < K) {
ans = std::min(ans, depth[v] + min_length[K - dist[v]]);
}
}
for (int v : nodes) if (dist[v] <= K) {
min_length[dist[v]] = std::min(min_length[dist[v]], depth[v]);
}
}
};
dc(0, 0);
return ans == N + 1 ? -1 : ans;
}
