【ACWing】264. 权值

题目地址：

https://www.acwing.com/problem/content/description/266/

给定一棵$N$个节点的树，每条边带有一个权值。求一条简单路径，路径上各条边的权值和等于$K$，且路径包含的边的数量最少。

输入格式：
第一行两个整数$N,K$。
第$2\sim N$行每行三个整数$x,y,z$，表示一条无向边的两个端点$x,y$和权值$z$，点的编号从$0$开始。

输出格式：
输出一个整数，表示最少边数量。如果不存在满足要求的路径，输出$-1$。

数据范围：
$1\le N\le 2\times 10^5$
$1\le K\le 10^6$
$0\le z\le 10^6$

思路是点分治，思路参考https://blog.csdn.net/qq_46105170/article/details/125555319。这里在归并的时候，当枚举到当前子树的时候，用一个map存一下之前的树的距离和对应的最少边数，从而可以枚举出一个端点在当前子树的情况。代码如下：

#include <iostream>
#include <cstring>
#include <map>
using namespace std;
using PII = pair<int, int>;

const int N = 2e5 + 10, M = N << 1;
int n, m;
int h[N], e[M], ne[M], w[M], idx;
int sz[N];
bool vis[N];
map<int, int> mp;
PII p[N];
int res;

void add(int a, int b, int c) {
  e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}

int get_sz(int u, int from) {
  if (vis[u]) return 0;
  int sz = 1;
  for (int i = h[u]; ~i; i = ne[i]) {
    int v = e[i];
    if (v != from) sz += get_sz(v, u);
  }

  return sz;
}

bool get_wc(int u, int from, int tot, int& wc) {
  if (vis[u]) return false;
  int ms = 0;
  sz[u] = 1;
  for (int i = h[u]; ~i; i = ne[i]) {
    int v = e[i];
    if (v != from && !vis[v]) {
      if (get_wc(v, u, tot, wc)) return true;
      ms = max(ms, sz[v]);
      sz[u] += sz[v];
    }
  }
  ms = max(ms, tot - sz[u]);
  if (ms <= tot / 2) {
    wc = u;
    return true;
  }
  return false;
}

void get_dist(int u, int from, int dist, int cnt, int& pd) {
  if (vis[u] || dist > m || cnt >= res) return;
  p[pd++] = {dist, cnt};
  for (int i = h[u]; ~i; i = ne[i]) {
    int v = e[i];
    if (v != from) get_dist(v, u, dist + w[i], cnt + 1, pd);
  }
}

void dfs(int u) {
  if (vis[u]) return;
  get_wc(u, -1, get_sz(u, -1), u);
  vis[u] = true;
  mp.clear();
  for (int i = h[u]; ~i; i = ne[i]) {
    int v = e[i];
    int pd = 0;
    get_dist(v, u, w[i], 1, pd);
    // 枚举一个点在当前子树，另一个在之前枚举过的子树的情形，
    // 同时也枚举一个端点在重心的情况
    for (int i = 0; i < pd; i++) {
      int dist = p[i].first, cnt = p[i].second;
      if (mp.count(m - dist)) res = min(res, cnt + mp[m - dist]);
      if (dist == m) res = min(res, cnt);
    }
	// 更新一下map
    for (int i = 0; i < pd; i++) {
      int dist = p[i].first, cnt = p[i].second;
      if (!mp.count(dist)) mp[dist] = cnt;
      else mp[dist] = min(mp[dist], cnt);
    }
  }

  for (int i = h[u]; ~i; i = ne[i]) dfs(e[i]);
}

int main() {
  memset(h, -1, sizeof h);
  res = N;
  scanf("%d%d", &n, &m);
  for (int i = 1; i < n; i++) {
    int a, b, c;
    scanf("%d%d%d", &a, &b, &c);
    add(a, b, c), add(b, a, c);
  }
  
  dfs(0);
  res < N ? printf("%d\n", res) : puts("-1");
}

时间复杂度$O(N{\log }^{2}N)$，空间$O(N)$。