QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#276146#6737. NeighbourhoodmaspyRE 0ms3536kbC++2028.8kb2023-12-05 17:00:542023-12-05 17:00:55

Judging History

你现在查看的是最新测评结果

  • [2023-12-05 17:00:55]
  • 评测
  • 测评结果:RE
  • 用时:0ms
  • 内存:3536kb
  • [2023-12-05 17:00:54]
  • 提交

answer

#line 1 "library/my_template.hpp"
#if defined(LOCAL)
#include <my_template_compiled.hpp>
#else
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using u32 = unsigned int;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = unsigned __int128;
using f128 = __float128;

template <class T>
constexpr T infty = 0;
template <>
constexpr int infty<int> = 1'000'000'000;
template <>
constexpr ll infty<ll> = ll(infty<int>) * infty<int> * 2;
template <>
constexpr u32 infty<u32> = infty<int>;
template <>
constexpr u64 infty<u64> = infty<ll>;
template <>
constexpr i128 infty<i128> = i128(infty<ll>) * infty<ll>;
template <>
constexpr double infty<double> = infty<ll>;
template <>
constexpr long double infty<long double> = infty<ll>;

using pi = pair<ll, ll>;
using vi = vector<ll>;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vector<vc<T>>;
template <class T>
using vvvc = vector<vvc<T>>;
template <class T>
using vvvvc = vector<vvvc<T>>;
template <class T>
using vvvvvc = vector<vvvvc<T>>;
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;

#define vv(type, name, h, ...) \
  vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define vvv(type, name, h, w, ...)   \
  vector<vector<vector<type>>> name( \
      h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
#define vvvv(type, name, a, b, c, ...)       \
  vector<vector<vector<vector<type>>>> name( \
      a, vector<vector<vector<type>>>(       \
             b, vector<vector<type>>(c, vector<type>(__VA_ARGS__))))

// https://trap.jp/post/1224/
#define FOR1(a) for (ll _ = 0; _ < ll(a); ++_)
#define FOR2(i, a) for (ll i = 0; i < ll(a); ++i)
#define FOR3(i, a, b) for (ll i = a; i < ll(b); ++i)
#define FOR4(i, a, b, c) for (ll i = a; i < ll(b); i += (c))
#define FOR1_R(a) for (ll i = (a)-1; i >= ll(0); --i)
#define FOR2_R(i, a) for (ll i = (a)-1; i >= ll(0); --i)
#define FOR3_R(i, a, b) for (ll i = (b)-1; i >= ll(a); --i)
#define overload4(a, b, c, d, e, ...) e
#define overload3(a, b, c, d, ...) d
#define FOR(...) overload4(__VA_ARGS__, FOR4, FOR3, FOR2, FOR1)(__VA_ARGS__)
#define FOR_R(...) overload3(__VA_ARGS__, FOR3_R, FOR2_R, FOR1_R)(__VA_ARGS__)

#define FOR_subset(t, s) \
  for (ll t = (s); t >= 0; t = (t == 0 ? -1 : (t - 1) & (s)))
#define all(x) x.begin(), x.end()
#define len(x) ll(x.size())
#define elif else if

#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second

#define stoi stoll

int popcnt(int x) { return __builtin_popcount(x); }
int popcnt(u32 x) { return __builtin_popcount(x); }
int popcnt(ll x) { return __builtin_popcountll(x); }
int popcnt(u64 x) { return __builtin_popcountll(x); }
int popcnt_mod_2(int x) { return __builtin_parity(x); }
int popcnt_mod_2(u32 x) { return __builtin_parity(x); }
int popcnt_mod_2(ll x) { return __builtin_parityll(x); }
int popcnt_mod_2(u64 x) { return __builtin_parityll(x); }
// (0, 1, 2, 3, 4) -> (-1, 0, 1, 1, 2)
int topbit(int x) { return (x == 0 ? -1 : 31 - __builtin_clz(x)); }
int topbit(u32 x) { return (x == 0 ? -1 : 31 - __builtin_clz(x)); }
int topbit(ll x) { return (x == 0 ? -1 : 63 - __builtin_clzll(x)); }
int topbit(u64 x) { return (x == 0 ? -1 : 63 - __builtin_clzll(x)); }
// (0, 1, 2, 3, 4) -> (-1, 0, 1, 0, 2)
int lowbit(int x) { return (x == 0 ? -1 : __builtin_ctz(x)); }
int lowbit(u32 x) { return (x == 0 ? -1 : __builtin_ctz(x)); }
int lowbit(ll x) { return (x == 0 ? -1 : __builtin_ctzll(x)); }
int lowbit(u64 x) { return (x == 0 ? -1 : __builtin_ctzll(x)); }

template <typename T>
T floor(T a, T b) {
  return a / b - (a % b && (a ^ b) < 0);
}
template <typename T>
T ceil(T x, T y) {
  return floor(x + y - 1, y);
}
template <typename T>
T bmod(T x, T y) {
  return x - y * floor(x, y);
}
template <typename T>
pair<T, T> divmod(T x, T y) {
  T q = floor(x, y);
  return {q, x - q * y};
}

template <typename T, typename U>
T SUM(const vector<U> &A) {
  T sm = 0;
  for (auto &&a: A) sm += a;
  return sm;
}

#define MIN(v) *min_element(all(v))
#define MAX(v) *max_element(all(v))
#define LB(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define UB(c, x) distance((c).begin(), upper_bound(all(c), (x)))
#define UNIQUE(x) \
  sort(all(x)), x.erase(unique(all(x)), x.end()), x.shrink_to_fit()

template <typename T>
T POP(deque<T> &que) {
  T a = que.front();
  que.pop_front();
  return a;
}
template <typename T>
T POP(pq<T> &que) {
  T a = que.top();
  que.pop();
  return a;
}
template <typename T>
T POP(pqg<T> &que) {
  T a = que.top();
  que.pop();
  return a;
}
template <typename T>
T POP(vc<T> &que) {
  T a = que.back();
  que.pop_back();
  return a;
}

template <typename F>
ll binary_search(F check, ll ok, ll ng, bool check_ok = true) {
  if (check_ok) assert(check(ok));
  while (abs(ok - ng) > 1) {
    auto x = (ng + ok) / 2;
    (check(x) ? ok : ng) = x;
  }
  return ok;
}
template <typename F>
double binary_search_real(F check, double ok, double ng, int iter = 100) {
  FOR(iter) {
    double x = (ok + ng) / 2;
    (check(x) ? ok : ng) = x;
  }
  return (ok + ng) / 2;
}

template <class T, class S>
inline bool chmax(T &a, const S &b) {
  return (a < b ? a = b, 1 : 0);
}
template <class T, class S>
inline bool chmin(T &a, const S &b) {
  return (a > b ? a = b, 1 : 0);
}

// ? は -1
vc<int> s_to_vi(const string &S, char first_char) {
  vc<int> A(S.size());
  FOR(i, S.size()) { A[i] = (S[i] != '?' ? S[i] - first_char : -1); }
  return A;
}

template <typename T, typename U>
vector<T> cumsum(vector<U> &A, int off = 1) {
  int N = A.size();
  vector<T> B(N + 1);
  FOR(i, N) { B[i + 1] = B[i] + A[i]; }
  if (off == 0) B.erase(B.begin());
  return B;
}

// stable sort
template <typename T>
vector<int> argsort(const vector<T> &A) {
  vector<int> ids(len(A));
  iota(all(ids), 0);
  sort(all(ids),
       [&](int i, int j) { return (A[i] == A[j] ? i < j : A[i] < A[j]); });
  return ids;
}

// A[I[0]], A[I[1]], ...
template <typename T>
vc<T> rearrange(const vc<T> &A, const vc<int> &I) {
  vc<T> B(len(I));
  FOR(i, len(I)) B[i] = A[I[i]];
  return B;
}
#endif
#line 1 "library/other/io.hpp"
#define FASTIO
#include <unistd.h>

// https://judge.yosupo.jp/submission/21623
namespace fastio {
static constexpr uint32_t SZ = 1 << 17;
char ibuf[SZ];
char obuf[SZ];
char out[100];
// pointer of ibuf, obuf
uint32_t pil = 0, pir = 0, por = 0;

struct Pre {
  char num[10000][4];
  constexpr Pre() : num() {
    for (int i = 0; i < 10000; i++) {
      int n = i;
      for (int j = 3; j >= 0; j--) {
        num[i][j] = n % 10 | '0';
        n /= 10;
      }
    }
  }
} constexpr pre;

inline void load() {
  memcpy(ibuf, ibuf + pil, pir - pil);
  pir = pir - pil + fread(ibuf + pir - pil, 1, SZ - pir + pil, stdin);
  pil = 0;
  if (pir < SZ) ibuf[pir++] = '\n';
}

inline void flush() {
  fwrite(obuf, 1, por, stdout);
  por = 0;
}

void rd(char &c) {
  do {
    if (pil + 1 > pir) load();
    c = ibuf[pil++];
  } while (isspace(c));
}

void rd(string &x) {
  x.clear();
  char c;
  do {
    if (pil + 1 > pir) load();
    c = ibuf[pil++];
  } while (isspace(c));
  do {
    x += c;
    if (pil == pir) load();
    c = ibuf[pil++];
  } while (!isspace(c));
}

template <typename T>
void rd_real(T &x) {
  string s;
  rd(s);
  x = stod(s);
}

template <typename T>
void rd_integer(T &x) {
  if (pil + 100 > pir) load();
  char c;
  do
    c = ibuf[pil++];
  while (c < '-');
  bool minus = 0;
  if constexpr (is_signed<T>::value || is_same_v<T, i128>) {
    if (c == '-') { minus = 1, c = ibuf[pil++]; }
  }
  x = 0;
  while ('0' <= c) { x = x * 10 + (c & 15), c = ibuf[pil++]; }
  if constexpr (is_signed<T>::value || is_same_v<T, i128>) {
    if (minus) x = -x;
  }
}

void rd(int &x) { rd_integer(x); }
void rd(ll &x) { rd_integer(x); }
void rd(i128 &x) { rd_integer(x); }
void rd(u32 &x) { rd_integer(x); }
void rd(u64 &x) { rd_integer(x); }
void rd(u128 &x) { rd_integer(x); }
void rd(double &x) { rd_real(x); }
void rd(long double &x) { rd_real(x); }
void rd(f128 &x) { rd_real(x); }

template <class T, class U>
void rd(pair<T, U> &p) {
  return rd(p.first), rd(p.second);
}
template <size_t N = 0, typename T>
void rd_tuple(T &t) {
  if constexpr (N < std::tuple_size<T>::value) {
    auto &x = std::get<N>(t);
    rd(x);
    rd_tuple<N + 1>(t);
  }
}
template <class... T>
void rd(tuple<T...> &tpl) {
  rd_tuple(tpl);
}

template <size_t N = 0, typename T>
void rd(array<T, N> &x) {
  for (auto &d: x) rd(d);
}
template <class T>
void rd(vc<T> &x) {
  for (auto &d: x) rd(d);
}

void read() {}
template <class H, class... T>
void read(H &h, T &... t) {
  rd(h), read(t...);
}

void wt(const char c) {
  if (por == SZ) flush();
  obuf[por++] = c;
}
void wt(const string s) {
  for (char c: s) wt(c);
}
void wt(const char *s) {
  size_t len = strlen(s);
  for (size_t i = 0; i < len; i++) wt(s[i]);
}

template <typename T>
void wt_integer(T x) {
  if (por > SZ - 100) flush();
  if (x < 0) { obuf[por++] = '-', x = -x; }
  int outi;
  for (outi = 96; x >= 10000; outi -= 4) {
    memcpy(out + outi, pre.num[x % 10000], 4);
    x /= 10000;
  }
  if (x >= 1000) {
    memcpy(obuf + por, pre.num[x], 4);
    por += 4;
  } else if (x >= 100) {
    memcpy(obuf + por, pre.num[x] + 1, 3);
    por += 3;
  } else if (x >= 10) {
    int q = (x * 103) >> 10;
    obuf[por] = q | '0';
    obuf[por + 1] = (x - q * 10) | '0';
    por += 2;
  } else
    obuf[por++] = x | '0';
  memcpy(obuf + por, out + outi + 4, 96 - outi);
  por += 96 - outi;
}

template <typename T>
void wt_real(T x) {
  ostringstream oss;
  oss << fixed << setprecision(15) << double(x);
  string s = oss.str();
  wt(s);
}

void wt(int x) { wt_integer(x); }
void wt(ll x) { wt_integer(x); }
void wt(i128 x) { wt_integer(x); }
void wt(u32 x) { wt_integer(x); }
void wt(u64 x) { wt_integer(x); }
void wt(u128 x) { wt_integer(x); }
void wt(double x) { wt_real(x); }
void wt(long double x) { wt_real(x); }
void wt(f128 x) { wt_real(x); }

template <class T, class U>
void wt(const pair<T, U> val) {
  wt(val.first);
  wt(' ');
  wt(val.second);
}
template <size_t N = 0, typename T>
void wt_tuple(const T t) {
  if constexpr (N < std::tuple_size<T>::value) {
    if constexpr (N > 0) { wt(' '); }
    const auto x = std::get<N>(t);
    wt(x);
    wt_tuple<N + 1>(t);
  }
}
template <class... T>
void wt(tuple<T...> tpl) {
  wt_tuple(tpl);
}
template <class T, size_t S>
void wt(const array<T, S> val) {
  auto n = val.size();
  for (size_t i = 0; i < n; i++) {
    if (i) wt(' ');
    wt(val[i]);
  }
}
template <class T>
void wt(const vector<T> val) {
  auto n = val.size();
  for (size_t i = 0; i < n; i++) {
    if (i) wt(' ');
    wt(val[i]);
  }
}

void print() { wt('\n'); }
template <class Head, class... Tail>
void print(Head &&head, Tail &&... tail) {
  wt(head);
  if (sizeof...(Tail)) wt(' ');
  print(forward<Tail>(tail)...);
}

// gcc expansion. called automaticall after main.
void __attribute__((destructor)) _d() { flush(); }
} // namespace fastio
using fastio::read;
using fastio::print;
using fastio::flush;

#define INT(...)   \
  int __VA_ARGS__; \
  read(__VA_ARGS__)
#define LL(...)   \
  ll __VA_ARGS__; \
  read(__VA_ARGS__)
#define U32(...)   \
  u32 __VA_ARGS__; \
  read(__VA_ARGS__)
#define U64(...)   \
  u64 __VA_ARGS__; \
  read(__VA_ARGS__)
#define STR(...)      \
  string __VA_ARGS__; \
  read(__VA_ARGS__)
#define CHAR(...)   \
  char __VA_ARGS__; \
  read(__VA_ARGS__)
#define DBL(...)      \
  double __VA_ARGS__; \
  read(__VA_ARGS__)

#define VEC(type, name, size) \
  vector<type> name(size);    \
  read(name)
#define VV(type, name, h, w)                     \
  vector<vector<type>> name(h, vector<type>(w)); \
  read(name)

void YES(bool t = 1) { print(t ? "YES" : "NO"); }
void NO(bool t = 1) { YES(!t); }
void Yes(bool t = 1) { print(t ? "Yes" : "No"); }
void No(bool t = 1) { Yes(!t); }
void yes(bool t = 1) { print(t ? "yes" : "no"); }
void no(bool t = 1) { yes(!t); }
#line 3 "main.cpp"

#line 2 "library/graph/base.hpp"

template <typename T>
struct Edge {
  int frm, to;
  T cost;
  int id;
};

template <typename T = int, bool directed = false>
struct Graph {
  static constexpr bool is_directed = directed;
  int N, M;
  using cost_type = T;
  using edge_type = Edge<T>;
  vector<edge_type> edges;
  vector<int> indptr;
  vector<edge_type> csr_edges;
  vc<int> vc_deg, vc_indeg, vc_outdeg;
  bool prepared;

  class OutgoingEdges {
  public:
    OutgoingEdges(const Graph* G, int l, int r) : G(G), l(l), r(r) {}

    const edge_type* begin() const {
      if (l == r) { return 0; }
      return &G->csr_edges[l];
    }

    const edge_type* end() const {
      if (l == r) { return 0; }
      return &G->csr_edges[r];
    }

  private:
    const Graph* G;
    int l, r;
  };

  bool is_prepared() { return prepared; }

  Graph() : N(0), M(0), prepared(0) {}
  Graph(int N) : N(N), M(0), prepared(0) {}

  void build(int n) {
    N = n, M = 0;
    prepared = 0;
    edges.clear();
    indptr.clear();
    csr_edges.clear();
    vc_deg.clear();
    vc_indeg.clear();
    vc_outdeg.clear();
  }

  void add(int frm, int to, T cost = 1, int i = -1) {
    assert(!prepared);
    assert(0 <= frm && 0 <= to && to < N);
    if (i == -1) i = M;
    auto e = edge_type({frm, to, cost, i});
    edges.eb(e);
    ++M;
  }

#ifdef FASTIO
  // wt, off
  void read_tree(bool wt = false, int off = 1) { read_graph(N - 1, wt, off); }

  void read_graph(int M, bool wt = false, int off = 1) {
    for (int m = 0; m < M; ++m) {
      INT(a, b);
      a -= off, b -= off;
      if (!wt) {
        add(a, b);
      } else {
        T c;
        read(c);
        add(a, b, c);
      }
    }
    build();
  }
#endif

  void build() {
    assert(!prepared);
    prepared = true;
    indptr.assign(N + 1, 0);
    for (auto&& e: edges) {
      indptr[e.frm + 1]++;
      if (!directed) indptr[e.to + 1]++;
    }
    for (int v = 0; v < N; ++v) { indptr[v + 1] += indptr[v]; }
    auto counter = indptr;
    csr_edges.resize(indptr.back() + 1);
    for (auto&& e: edges) {
      csr_edges[counter[e.frm]++] = e;
      if (!directed)
        csr_edges[counter[e.to]++] = edge_type({e.to, e.frm, e.cost, e.id});
    }
  }

  OutgoingEdges operator[](int v) const {
    assert(prepared);
    return {this, indptr[v], indptr[v + 1]};
  }

  vc<int> deg_array() {
    if (vc_deg.empty()) calc_deg();
    return vc_deg;
  }

  pair<vc<int>, vc<int>> deg_array_inout() {
    if (vc_indeg.empty()) calc_deg_inout();
    return {vc_indeg, vc_outdeg};
  }

  int deg(int v) {
    if (vc_deg.empty()) calc_deg();
    return vc_deg[v];
  }

  int in_deg(int v) {
    if (vc_indeg.empty()) calc_deg_inout();
    return vc_indeg[v];
  }

  int out_deg(int v) {
    if (vc_outdeg.empty()) calc_deg_inout();
    return vc_outdeg[v];
  }

#ifdef FASTIO
  void debug() {
    print("Graph");
    if (!prepared) {
      print("frm to cost id");
      for (auto&& e: edges) print(e.frm, e.to, e.cost, e.id);
    } else {
      print("indptr", indptr);
      print("frm to cost id");
      FOR(v, N) for (auto&& e: (*this)[v]) print(e.frm, e.to, e.cost, e.id);
    }
  }
#endif

  vc<int> new_idx;
  vc<bool> used_e;

  // G における頂点 V[i] が、新しいグラフで i になるようにする
  // {G, es}
  Graph<T, directed> rearrange(vc<int> V, bool keep_eid = 0) {
    if (len(new_idx) != N) new_idx.assign(N, -1);
    if (len(used_e) != M) used_e.assign(M, 0);
    int n = len(V);
    FOR(i, n) new_idx[V[i]] = i;
    Graph<T, directed> G(n);
    vc<int> history;
    FOR(i, n) {
      for (auto&& e: (*this)[V[i]]) {
        if (used_e[e.id]) continue;
        int a = e.frm, b = e.to;
        if (new_idx[a] != -1 && new_idx[b] != -1) {
          history.eb(e.id);
          used_e[e.id] = 1;
          int eid = (keep_eid ? e.id : -1);
          G.add(new_idx[a], new_idx[b], e.cost, eid);
        }
      }
    }
    FOR(i, n) new_idx[V[i]] = -1;
    for (auto&& eid: history) used_e[eid] = 0;
    G.build();
    return G;
  }

private:
  void calc_deg() {
    assert(vc_deg.empty());
    vc_deg.resize(N);
    for (auto&& e: edges) vc_deg[e.frm]++, vc_deg[e.to]++;
  }

  void calc_deg_inout() {
    assert(vc_indeg.empty());
    vc_indeg.resize(N);
    vc_outdeg.resize(N);
    for (auto&& e: edges) { vc_indeg[e.to]++, vc_outdeg[e.frm]++; }
  }
};
#line 3 "library/graph/shortest_path/bfs01.hpp"

template <typename T, typename GT>
pair<vc<T>, vc<int>> bfs01(GT& G, int v) {
  assert(G.is_prepared());
  int N = G.N;
  vc<T> dist(N, infty<T>);
  vc<int> par(N, -1);
  deque<int> que;

  dist[v] = 0;
  que.push_front(v);
  while (!que.empty()) {
    auto v = que.front();
    que.pop_front();
    for (auto&& e: G[v]) {
      if (dist[e.to] == infty<T> || dist[e.to] > dist[e.frm] + e.cost) {
        dist[e.to] = dist[e.frm] + e.cost;
        par[e.to] = e.frm;
        if (e.cost == 0)
          que.push_front(e.to);
        else
          que.push_back(e.to);
      }
    }
  }
  return {dist, par};
}

// 多点スタート。[dist, par, root]
template <typename T, typename GT>
tuple<vc<T>, vc<int>, vc<int>> bfs01(GT& G, vc<int> vs) {
  assert(G.is_prepared());
  int N = G.N;
  vc<T> dist(N, infty<T>);
  vc<int> par(N, -1);
  vc<int> root(N, -1);
  deque<int> que;

  for (auto&& v: vs) {
    dist[v] = 0;
    root[v] = v;
    que.push_front(v);
  }

  while (!que.empty()) {
    auto v = que.front();
    que.pop_front();
    for (auto&& e: G[v]) {
      if (dist[e.to] == infty<T> || dist[e.to] > dist[e.frm] + e.cost) {
        dist[e.to] = dist[e.frm] + e.cost;
        root[e.to] = root[e.frm];
        par[e.to] = e.frm;
        if (e.cost == 0)
          que.push_front(e.to);
        else
          que.push_back(e.to);
      }
    }
  }
  return {dist, par, root};
}
#line 3 "library/graph/centroid_decomposition.hpp"

/*
頂点ベースの重心分解
f(par, V, indptr)
*/
template <typename F>
void centroid_decomposition_0_dfs(vc<int>& par, vc<int>& vs, F f) {
  const int N = len(par);
  assert(N >= 1);
  int c = -1;
  vc<int> sz(N, 1);
  FOR_R(i, N) {
    if (sz[i] >= ceil<int>(N, 2)) {
      c = i;
      break;
    }
    sz[par[i]] += sz[i];
  }
  vc<int> color(N);
  vc<int> V = {c};
  int nc = 1;
  FOR(v, 1, N) {
    if (par[v] == c) { V.eb(v), color[v] = nc++; }
  }
  if (c > 0) {
    for (int a = par[c]; a != -1; a = par[a]) { color[a] = nc, V.eb(a); }
    ++nc;
  }
  FOR(i, N) {
    if (i != c && color[i] == 0) color[i] = color[par[i]], V.eb(i);
  }
  vc<int> indptr(nc + 1);
  FOR(i, N) indptr[1 + color[i]]++;
  FOR(i, nc) indptr[i + 1] += indptr[i];
  vc<int> counter = indptr;
  vc<int> ord(N);
  for (auto& v: V) { ord[counter[color[v]]++] = v; }
  vc<int> new_idx(N);
  FOR(i, N) new_idx[ord[i]] = i;
  vc<int> name(N);
  FOR(i, N) name[new_idx[i]] = vs[i];
  {
    vc<int> tmp(N, -1);
    FOR(i, 1, N) {
      int a = new_idx[i], b = new_idx[par[i]];
      if (a > b) swap(a, b);
      tmp[b] = a;
    }
    swap(par, tmp);
  }
  f(par, name, indptr);
  FOR(k, 1, nc) {
    int L = indptr[k], R = indptr[k + 1];
    vc<int> par1(R - L, -1);
    vc<int> name1(R - L, -1);
    name1[0] = name[0];
    FOR(i, L, R) name1[i - L] = name[i];
    FOR(i, L, R) { par1[i - L] = max(par[i] - L, -1); }
    centroid_decomposition_0_dfs(par1, name1, f);
  }
}

/*
https://maspypy.com/%e9%87%8d%e5%bf%83%e5%88%86%e8%a7%a3%e3%83%bb1-3%e9%87%8d%e5%bf%83%e5%88%86%e8%a7%a3%e3%81%ae%e3%81%8a%e7%b5%b5%e6%8f%8f%e3%81%8d
centroid_decomposition_1:長さ 2 以上のパス全体
f(par, V, n1, n2)
[1,1+n1]: color 1
[1+n1,1+n1+n2]: color 2
*/
template <typename F>
void centroid_decomposition_1_dfs(vc<int>& par, vc<int> vs, F f) {
  const int N = len(par);
  assert(N > 1);
  if (N == 2) { return; }
  int c = -1;
  vc<int> sz(N, 1);
  FOR_R(i, N) {
    if (sz[i] >= ceil<int>(N, 2)) {
      c = i;
      break;
    }
    sz[par[i]] += sz[i];
  }
  vc<int> color(N, -1);
  int take = 0;
  vc<int> ord(N, -1);
  ord[c] = 0;
  int p = 1;
  FOR(v, 1, N) {
    if (par[v] == c && take + sz[v] <= floor<int>(N - 1, 2)) {
      color[v] = 0, ord[v] = p++, take += sz[v];
    }
  }
  FOR(i, 1, N) {
    if (color[par[i]] == 0) color[i] = 0, ord[i] = p++;
  }
  int n0 = p - 1;
  for (int a = par[c]; a != -1; a = par[a]) { color[a] = 1, ord[a] = p++; }
  FOR(i, N) {
    if (i != c && color[i] == -1) color[i] = 1, ord[i] = p++;
  }
  assert(p == N);
  int n1 = N - 1 - n0;
  vc<int> par0(n0 + 1, -1), par1(n1 + 1, -1), par2(N, -1);
  vc<int> V0(n0 + 1), V1(n1 + 1), V2(N);
  FOR(v, N) {
    int i = ord[v];
    V2[i] = vs[v];
    if (color[v] != 1) { V0[i] = vs[v]; }
    if (color[v] != 0) { V1[max(i - n0, 0)] = vs[v]; }
  }
  FOR(v, 1, N) {
    int a = ord[v], b = ord[par[v]];
    if (a > b) swap(a, b);
    par2[b] = a;
    if (color[v] != 1 && color[par[v]] != 1) par0[b] = a;
    if (color[v] != 0 && color[par[v]] != 0)
      par1[max(b - n0, 0)] = max(a - n0, 0);
  }
  f(par2, V2, n0, n1);
  centroid_decomposition_1_dfs(par0, V0, f);
  centroid_decomposition_1_dfs(par1, V1, f);
}

/*
https://maspypy.com/%e9%87%8d%e5%bf%83%e5%88%86%e8%a7%a3%e3%83%bb1-3%e9%87%8d%e5%bf%83%e5%88%86%e8%a7%a3%e3%81%ae%e3%81%8a%e7%b5%b5%e6%8f%8f%e3%81%8d
f(par2, V2, color)
color in [-1,0,1], -1 is virtual.
*/
template <typename F>
void centroid_decomposition_2_dfs(vc<int>& par, vc<int>& vs, vc<int>& real,
                                  F f) {
  const int N = len(par);
  assert(N > 1);
  if (N == 2) {
    if (real[0] && real[1]) {
      vc<int> color = {0, 1};
      f(par, vs, color);
    }
    return;
  }
  int c = -1;
  vc<int> sz(N, 1);
  FOR_R(i, N) {
    if (sz[i] >= ceil<int>(N, 2)) {
      c = i;
      break;
    }
    sz[par[i]] += sz[i];
  }
  vc<int> color(N, -1);
  int take = 0;
  vc<int> ord(N, -1);
  ord[c] = 0;
  int p = 1;
  FOR(v, 1, N) {
    if (par[v] == c && take + sz[v] <= floor<int>(N - 1, 2)) {
      color[v] = 0, ord[v] = p++, take += sz[v];
    }
  }
  FOR(i, 1, N) {
    if (color[par[i]] == 0) color[i] = 0, ord[i] = p++;
  }
  int n0 = p - 1;
  for (int a = par[c]; a != -1; a = par[a]) { color[a] = 1, ord[a] = p++; }
  FOR(i, N) {
    if (i != c && color[i] == -1) color[i] = 1, ord[i] = p++;
  }
  assert(p == N);
  int n1 = N - 1 - n0;
  vc<int> par0(n0 + 1, -1), par1(n1 + 1, -1), par2(N, -1);
  vc<int> V0(n0 + 1), V1(n1 + 1), V2(N);
  vc<int> rea0(n0 + 1), rea1(n1 + 1), rea2(N);
  FOR(v, N) {
    int i = ord[v];
    V2[i] = vs[v], rea2[i] = real[v];
    if (color[v] != 1) { V0[i] = vs[v], rea0[i] = real[v]; }
    if (color[v] != 0) {
      V1[max(i - n0, 0)] = vs[v], rea1[max(i - n0, 0)] = real[v];
    }
  }
  FOR(v, 1, N) {
    int a = ord[v], b = ord[par[v]];
    if (a > b) swap(a, b);
    par2[b] = a;
    if (color[v] != 1 && color[par[v]] != 1) par0[b] = a;
    if (color[v] != 0 && color[par[v]] != 0)
      par1[max(b - n0, 0)] = max(a - n0, 0);
  }
  if (real[c]) {
    color.assign(N, -1);
    color[0] = 0;
    FOR(i, 1, N) color[i] = rea2[i] ? 1 : -1;
    f(par2, V2, color);
    rea0[0] = rea1[0] = rea2[0] = 0;
  }
  color.assign(N, -1);
  FOR(i, 1, N) if (rea2[i]) color[i] = (i <= n0 ? 0 : 1);
  f(par2, V2, color);
  centroid_decomposition_2_dfs(par0, V0, rea0, f);
  centroid_decomposition_2_dfs(par1, V1, rea1, f);
}

// f(par, V, color)
// V: label in original tree, dfs order
// color in [-1,0,1], color=-1: virtual
template <int MODE, typename GT, typename F>
void centroid_decomposition(GT& G, F f) {
  const int N = G.N;
  if (N == 1) return;
  vc<int> V(N), par(N, -1);
  int l = 0, r = 0;
  V[r++] = 0;
  while (l < r) {
    int v = V[l++];
    for (auto& e: G[v]) {
      if (e.to != par[v]) V[r++] = e.to, par[e.to] = v;
    }
  }
  assert(r == N);
  vc<int> new_idx(N);
  FOR(i, N) new_idx[V[i]] = i;
  vc<int> tmp(N, -1);
  FOR(i, 1, N) {
    int j = par[i];
    tmp[new_idx[i]] = new_idx[j];
  }
  swap(par, tmp);
  static_assert(MODE == 0 || MODE == 1 || MODE == 2);
  if constexpr (MODE == 0) { centroid_decomposition_0_dfs(par, V, f); }
  elif constexpr(MODE == 1) { centroid_decomposition_1_dfs(par, V, f); }
  else {
    vc<int> real(N, 1);
    centroid_decomposition_2_dfs(par, V, real, f);
  }
}
#line 7 "main.cpp"

struct Block {
  int N, off;
  vc<ll> A;
  vc<ll> SORTED_A;
  ll lazy = 0;

  Block(vc<ll>& B, int L, int R) : N(R - L), off(L) {
    A = {B.begin() + L, B.begin() + R};
    SORTED_A = A;
    sort(all(SORTED_A));
  }

  void apply(int l, int r, ll x) {
    l -= off, r -= off;
    chmax(l, 0), chmin(r, N);
    if (l >= r) return;
    if (r - l != N) {
      FOR(i, l, r) A[i] += x;
      SORTED_A = A;
      sort(all(SORTED_A));
      return;
    }
    assert(r - l == N);
    lazy += x;
  }

  ll get(int i) { return A[i - off] + lazy; }

  int query(int l, int r, ll x) {
    l -= off, r -= off;
    chmax(l, 0), chmin(r, N);
    if (l >= r) return 0;
    x -= lazy;
    if (r - l == N) { return UB(SORTED_A, x); }
    int cnt = 0;
    FOR(i, l, r) { cnt += (A[i] <= x); }
    return cnt;
  }
};

void solve() {
  INT(N, Q);
  Graph<int, 0> G0(N);
  G0.read_tree(1);
  vc<int> P0 = bfs01<int>(G0, 0).se;
  vc<int> v_to_e(N, -1);
  FOR(i, 1, N) {
    for (auto& e: G0[i]) {
      if (e.to == P0[i]) v_to_e[i] = e.id;
    }
  }

  vc<tuple<int, int, int>> QUERY;
  vvc<int> QID(N);
  FOR(q, Q) {
    INT(a, b, c);
    if (a == 1) {
      --b;
      QUERY.eb(a, b, c);
      auto& e = G0.edges[b];
      QID[e.frm].eb(q);
    }
    if (a == 2) {
      --b;
      QUERY.eb(a, b, c);
      QID[b].eb(q);
    }
  }

  vc<int> ANS(Q);
  vc<int> new_idx(N, -1);
  vc<int> new_idx_e(N, -1);

  auto work = [&](vc<int> par, vc<int> V, vc<int> indptr) -> void {
    int n = len(V);
    FOR(i, n) { new_idx[V[i]] = i; }
    Graph<int, 1> G(n);
    vi A(n);
    vc<int> NOW_LEN(n);
    FOR(i, 1, n) {
      int a = V[par[i]], b = V[i];
      int raw_idx = -1;
      if (P0[b] == a) {
        raw_idx = v_to_e[b];
      } else {
        raw_idx = v_to_e[a];
      }
      G.add(par[i], i, G0.edges[raw_idx].cost);
      new_idx_e[raw_idx] = i;
      NOW_LEN[i] = G0.edges[raw_idx].cost;
      A[i] = A[par[i]] + NOW_LEN[i];
    }
    G.build();
    vc<int> ord, LID(n), RID(n);
    auto dfs = [&](auto& dfs, int v) -> void {
      LID[v] = len(ord);
      ord.eb(v);
      for (auto& e: G[v]) dfs(dfs, e.to);
      RID[v] = len(ord);
    };
    dfs(dfs, 0);

    A = rearrange(A, ord);
    vc<int> SUB_L(n), SUB_R(n);
    FOR(i, 1, n) {
      if (par[i] == 0) {
        int a = LID[i], b = RID[i];
        FOR(k, a, b) {
          SUB_L[ord[k]] = a;
          SUB_R[ord[k]] = b;
        }
      }
    }

    // qid, 1, v, x
    // qid, 2, v, x
    vc<tuple<int, int, int, ll>> SUB_QUERY;
    for (auto& v: V) {
      for (auto q: QID[v]) {
        auto [t, a, b] = QUERY[q];
        if (t == 1) {
          int w = new_idx_e[a];
          if (w != -1) {
            SUB_QUERY.eb(q, 1, w, b - NOW_LEN[w]);
            NOW_LEN[w] = b;
          }
        }
        if (t == 2) {
          a = new_idx[a];
          SUB_QUERY.eb(q, 2, a, b);
        }
      }
    }

    int b_sz = sqrt(n);
    int b_num = ceil<int>(n, b_sz);
    vc<Block> BLOCK;
    FOR(b, b_num) {
      int L = b_sz * b;
      int R = min<int>(L + b_sz, n);
      BLOCK.eb(Block(A, L, R));
    }

    auto ADD = [&](int L, int R, ll x) -> void {
      FOR(b, b_num) BLOCK[b].apply(L, R, x);
    };
    auto GET = [&](int i) -> ll {
      int bid = i / b_sz;
      return BLOCK[bid].get(i);
    };
    auto COUNT = [&](int L, int R, ll x) -> int {
      int cnt = 0;
      FOR(b, b_num) cnt += BLOCK[b].query(L, R, x);
      return cnt;
    };

    sort(all(SUB_QUERY));
    for (auto& [q, t, v, x]: SUB_QUERY) {
      if (t == 1) { ADD(LID[v], RID[v], x); }
      if (t == 2) {
        int ans = 0;
        ll xx = x - GET(LID[v]);
        ans += COUNT(0, n, xx);
        ans -= COUNT(SUB_L[v], SUB_R[v], xx);
        ANS[q] += ans;
      }
    }

    // reset
    for (auto& v: V) { new_idx[v] = -1; }
    FOR(i, 1, n) {
      int a = V[par[i]], b = V[i];
      int raw_idx = -1;
      if (P0[b] == a) {
        raw_idx = v_to_e[b];
      } else {
        raw_idx = v_to_e[a];
      }
      new_idx_e[raw_idx] = -1;
    }
  };
  centroid_decomposition<0>(G0, work);

  FOR(q, Q) {
    int t = get<0>(QUERY[q]);
    if (t == 2) print(ANS[q]);
  }
}

signed main() {
  solve();
  return 0;
}

詳細信息

Test #1:

score: 100
Accepted
time: 0ms
memory: 3536kb

input:

3 7
1 2 3
2 3 1
2 2 1
2 1 3
2 3 4
1 1 1
2 2 1
2 1 0
2 3 1

output:

2
2
3
3
1
2

result:

ok 6 numbers

Test #2:

score: -100
Runtime Error

input:

200000 200000
1 2 146181238
2 3 45037818
3 4 176924060
4 5 969365276
5 6 683948619
6 7 356268194
7 8 871634797
8 9 630254480
9 10 283061123
10 11 204904965
11 12 838381393
12 13 516373812
13 14 253862710
14 15 223572474
15 16 114452997
16 17 145251056
17 18 905638436
18 19 375445402
19 20 549829545
...

output:

4
0
0
7
0
7
4
4
1
7
0
0
9
0
0
3
0
0
1
0
0
0
0
0
0
0
11
0
6
0
0
0
1
8
1
0
0
0
7
3
0
0
8
0
2
2
0
8
1
6
0
5
0
0
3
0
3
5
3
7
0
2
2
0
12
6
12
3
3
5
6
0
8
0
4
6
1
1
0
0
5
0
7
0
0
8
9
3
0
2
5
0
0
10
2
0
0
3
5
0
0
7
0
0
0
0
0
0
10
0
12
0
0
4
6
0
0
6
0
3
0
2
3
0
0
0
1
2
0
0
0
7
0
0
6
10
0
0
1
6
14
0
4
6
1
3
...

result: