結果

問題 No.901 K-ary εxtrεεmε
ユーザー risujiroh
提出日時 2019-10-04 22:30:03
言語 C++14
(gcc 9.2.0)
結果
AC  
実行時間 160 ms
コード長 2,503 Byte
コンパイル時間 1,904 ms
使用メモリ 34,516 KB
最終ジャッジ日時 2020-02-12 23:30:10

テストケース

テストケース表示
入力 結果 実行時間
使用メモリ
challenge01.txt AC 88 ms
34,516 KB
sample01 AC 4 ms
3,332 KB
test_1_01 AC 4 ms
3,288 KB
test_1_02 AC 4 ms
3,268 KB
test_1_03 AC 4 ms
3,276 KB
test_1_04 AC 4 ms
3,340 KB
test_1_05 AC 4 ms
3,220 KB
test_2_01 AC 152 ms
31,884 KB
test_2_02 AC 148 ms
31,920 KB
test_2_03 AC 148 ms
31,944 KB
test_2_04 AC 152 ms
31,944 KB
test_2_05 AC 152 ms
31,800 KB
test_3_01 AC 156 ms
31,884 KB
test_3_02 AC 156 ms
31,920 KB
test_3_03 AC 156 ms
31,844 KB
test_3_04 AC 148 ms
31,940 KB
test_3_05 AC 152 ms
31,916 KB
test_4_01 AC 160 ms
31,852 KB
test_4_02 AC 156 ms
31,948 KB
test_4_03 AC 160 ms
31,876 KB
test_4_04 AC 160 ms
31,896 KB
test_4_05 AC 152 ms
31,948 KB
test_5_01 AC 148 ms
31,944 KB
test_5_02 AC 148 ms
31,844 KB
test_5_03 AC 144 ms
31,892 KB
test_5_04 AC 148 ms
31,792 KB
test_5_05 AC 148 ms
31,936 KB
test_6_01 AC 124 ms
31,852 KB
test_6_02 AC 124 ms
31,948 KB
test_6_03 AC 124 ms
31,832 KB
テストケース一括ダウンロード

ソースコード

diff #
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template<class T = int> using V = vector<T>;
template<class T = int> using VV = V< V<T> >;

namespace LCA {
  using T = lint;
  struct Edge { int to; T w; };
  T op(const T& x, const T& y) { return x + y; }
  constexpr T e = 0;

  V<> dep, in;
  VV<> par;
  VV<T> val;
  void init(const VV<Edge>& g, int r) {
    int n = g.size();
    dep.resize(n);
    in.resize(n);
    par.assign(__lg(2 * n - 1), V<>(n, -1));
    val.assign(__lg(2 * n - 1), V<T>(n, e));
    auto dfs = [&](const auto& dfs, int v, int p) -> void {
      static int t = 0;
      in[v] = t++;
      for (const auto& e : g[v]) if (e.to != p) {
        dep[e.to] = dep[v] + 1;
        par[0][e.to] = v;
        val[0][e.to] = e.w;
        dfs(dfs, e.to, v);
      }
    };
    dep[r] = 0;
    dfs(dfs, r, -1);
    for (int k = 1; k < (int) par.size(); ++k) {
      for (int v = 0; v < n; ++v) {
        if (par[k - 1][v] == -1) continue;
        par[k][v] = par[k - 1][par[k - 1][v]];
        val[k][v] = op(val[k - 1][v], val[k - 1][par[k - 1][v]]);
      }
    }
  }
  int get_par(int v, int h) {
    for (int k = 0; h > 0; h >>= 1, ++k) {
      if (v == -1) break;
      if (h & 1) v = par[k][v];
    }
    return v;
  }
  int lca(int u, int v) {
    if (dep[u] > dep[v]) swap(u, v);
    v = get_par(v, dep[v] - dep[u]);
    if (u == v) return u;
    for (int k = par.size() - 1; k >= 0; --k) {
      if (par[k][u] != par[k][v]) {
        u = par[k][u];
        v = par[k][v];
      }
    }
    return par[0][u];
  }
  T get_val(int v, int h) {
    T res = e;
    for (int k = 0; h > 0; h >>= 1, ++k) {
      if (v == -1) break;
      if (h & 1) {
        res = op(res, val[k][v]);
        v = par[k][v];
      }
    }
    return res;
  }
  T acc(int u, int v) {
    int a = lca(u, v);
    return op(get_val(v, dep[v] - dep[a]), get_val(u, dep[u] - dep[a]));
  }
}

int main() {
  cin.tie(nullptr); ios::sync_with_stdio(false);
  int n; cin >> n;
  VV<LCA::Edge> g(n);
  for (int _ = 0; _ < n - 1; ++_) {
    int u, v, w; cin >> u >> v >> w;
    g[u].emplace_back(LCA::Edge{v, w});
    g[v].emplace_back(LCA::Edge{u, w});
  }
  LCA::init(g, 0);
  int q; cin >> q;
  while (q--) {
    int k; cin >> k;
    V<> x(k); for (auto&& e : x) cin >> e;
    sort(begin(x), end(x), [&](int u, int v) { return LCA::in[v] < LCA::in[u]; });
    lint res = 0;
    for (int i = 0; i < k; ++i) {
      res += LCA::acc(x[i], x[(i + 1) % k]);
    }
    cout << res / 2 << '\n';
  }
}
0