結果

問題 No.901 K-ary εxtrεεmε
ユーザー risujirohrisujiroh
提出日時 2019-10-04 22:30:03
言語 C++14
(gcc 10.1.0 + boost 1.73.0)
結果
AC  
実行時間 158 ms / 3,000 ms
コード長 2,503 Byte
コンパイル時間 1,969 ms
使用メモリ 31,712 KB
最終ジャッジ日時 2020-08-09 11:27:31
このコードへのチャレンジ(β)

テストケース

テストケース表示
入力 結果 実行時間
使用メモリ
testcase_00 AC 84 ms
31,712 KB
testcase_01 AC 2 ms
1,612 KB
testcase_02 AC 3 ms
1,640 KB
testcase_03 AC 3 ms
1,644 KB
testcase_04 AC 4 ms
1,640 KB
testcase_05 AC 4 ms
1,640 KB
testcase_06 AC 3 ms
1,640 KB
testcase_07 AC 150 ms
30,456 KB
testcase_08 AC 148 ms
30,452 KB
testcase_09 AC 148 ms
30,460 KB
testcase_10 AC 147 ms
30,452 KB
testcase_11 AC 149 ms
30,460 KB
testcase_12 AC 147 ms
30,456 KB
testcase_13 AC 144 ms
30,452 KB
testcase_14 AC 150 ms
30,448 KB
testcase_15 AC 158 ms
30,452 KB
testcase_16 AC 150 ms
30,452 KB
testcase_17 AC 149 ms
30,460 KB
testcase_18 AC 147 ms
30,452 KB
testcase_19 AC 148 ms
30,448 KB
testcase_20 AC 149 ms
30,456 KB
testcase_21 AC 145 ms
30,452 KB
testcase_22 AC 142 ms
30,456 KB
testcase_23 AC 142 ms
30,452 KB
testcase_24 AC 141 ms
30,456 KB
testcase_25 AC 141 ms
30,452 KB
testcase_26 AC 142 ms
30,452 KB
testcase_27 AC 121 ms
30,456 KB
testcase_28 AC 121 ms
30,452 KB
testcase_29 AC 124 ms
30,460 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