#1192071 (C++23(gcc16)) No.3756 Udon Network

• 問題: No.3756 Udon Network
• ユーザー: ei1333333
• 提出日時: 2026-10-09 18:35:43
• 言語: C++23(gcc16) (gcc 16.1.0 + boost 1.92.0 + ACL)
• 結果: WA
• 実行時間: -
• コード長: 5,881 bytes
• コンパイル時間: 5,216 ms
• コンパイル使用メモリ: 411,472 KB
• 実行使用メモリ: 1,308,108 KB
• 最終ジャッジ日時: 2026-10-09 18:36:15
• 合計ジャッジ時間: 9,051 ms
• ジャッジサーバーID （参考情報）: judge4_0 / judge5_0

サブタスク	配点	結果
Example	0 %	AC * 2 WA * 6
Subtask $1$	2 %	AC * 3 WA * 12
Subtask $2$	4 %	AC * 3 WA * 12 MLE * 2 -- * 5
Subtask $3$	8 %	AC * 3 -- * 6
Subtask $4$	16 %	AC * 2 -- * 8
Subtask $5$	32 %	AC * 2 WA * 1 -- * 7
Subtask $6$	38 %	AC * 3 WA * 12 MLE * 2 -- * 36
合計	4 * 0% = 0 点

ソースコード

#line 1 "template/template.hpp"
#include <bits/stdc++.h>

#if __has_include(<atcoder/all>)
#include <atcoder/all>

#endif

using namespace std;

using int64 = long long;

const int64 infll = (1LL << 62) - 1;
const int inf = (1 << 30) - 1;

struct IoSetup {
  IoSetup() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(10);
    cerr << fixed << setprecision(10);
  }
} iosetup;

template <typename T1, typename T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
  os << p.first << " " << p.second;
  return os;
}

template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& p) {
  is >> p.first >> p.second;
  return is;
}

template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
  for (size_t i = 0; i < v.size(); i++) {
    os << v[i] << (i + 1 != v.size() ? " " : "");
  }
  return os;
}

template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
  for (T& in : v) is >> in;
  return is;
}

template <typename T1, typename T2>
bool chmax(T1& a, T2 b) {
  return a < b && (a = b, true);
}

template <typename T1, typename T2>
bool chmin(T1& a, T2 b) {
  return a > b && (a = b, true);
}

template <typename T = int64>
vector<T> make_v(size_t a) {
  return vector<T>(a);
}

template <typename T, typename... Ts>
auto make_v(size_t a, Ts... ts) {
  return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}

template <typename T, typename V>
enable_if_t<is_class_v<T> == 0> fill_v(T& t, const V& v) {
  t = v;
}

template <typename T, typename V>
enable_if_t<is_class_v<T> != 0> fill_v(T& t, const V& v) {
  for (auto& e : t) fill_v(e, v);
}

template <typename F>
struct FixPoint : F {
  explicit FixPoint(F&& f) : F(std::forward<F>(f)) {}

  template <typename... Args>
  decltype(auto) operator()(Args&&... args) const {
    return F::operator()(*this, std::forward<Args>(args)...);
  }
};

template <typename F>
decltype(auto) MFP(F&& f) {
  return FixPoint<F>{std::forward<F>(f)};
}

#line 2 "structure/union-find/union-find.hpp"

#include <algorithm>
#include <cstddef>
#include <utility>
#include <vector>

struct UnionFind {
  std::vector<int> data;

  UnionFind() = default;

  explicit UnionFind(std::size_t sz) : data(sz, -1) {}

  bool unite(int x, int y) {
    x = find(x), y = find(y);
    if (x == y) return false;
   // if (data[x] > data[y]) std::swap(x, y);
    data[x] += data[y];
    data[y] = x;
    return true;
  }

  int find(int k) {
    if (data[k] < 0) return (k);
    return data[k] = find(data[k]);
  }

  int size(int k) { return -data[find(k)]; }

  bool same(int x, int y) { return find(x) == find(y); }

  std::vector<std::vector<int>> groups() {
    int n = (int)data.size();
    std::vector<std::vector<int>> ret(n);
    for (int i = 0; i < n; i++) {
      ret[find(i)].emplace_back(i);
    }
    ret.erase(
        std::remove_if(ret.begin(), ret.end(),
                       [&](const std::vector<int>& v) { return v.empty(); }),
        ret.end());
    return ret;
  }
};

#line 2 "structure/others/persistent-array.hpp"

#include <utility>
#include <vector>

template <typename T, int LOG>
struct PersistentArray {
  struct Node {
    T data;
    Node* child[1 << LOG] = {};

    Node() {}

    Node(const T& data) : data(data) {}
  };

  Node* root;

  PersistentArray() : root(nullptr) {}

  T get(Node* t, int k) {
    if (k == 0) return t->data;
    return get(t->child[k & ((1 << LOG) - 1)], k >> LOG);
  }

  T get(const int& k) { return get(root, k); }

  std::pair<Node*, T*> mutable_get(Node* t, int k) {
    t = t ? new Node(*t) : new Node();
    if (k == 0) return {t, &t->data};
    auto p = mutable_get(t->child[k & ((1 << LOG) - 1)], k >> LOG);
    t->child[k & ((1 << LOG) - 1)] = p.first;
    return {t, p.second};
  }

  T* mutable_get(const int& k) {
    auto ret = mutable_get(root, k);
    root = ret.first;
    return ret.second;
  }

  Node* build(Node* t, const T& data, int k) {
    if (!t) t = new Node();
    if (k == 0) {
      t->data = data;
      return t;
    }
    auto p = build(t->child[k & ((1 << LOG) - 1)], data, k >> LOG);
    t->child[k & ((1 << LOG) - 1)] = p;
    return t;
  }

  void build(const std::vector<T>& v) {
    root = nullptr;
    for (int i = 0; i < (int)v.size(); i++) {
      root = build(root, v[i], i);
    }
  }
};



int main() {
  int N, M, Q;
  cin >> N >> M >> Q;
  vector< int > A(N);
  cin >> A;
  vector< tuple< int, int, int > > es(M);
  for (auto& [w, u, v]: es) {
    cin >> u >> v >> w;
    --u, --v;
  }
  ranges::sort(es);
  vector< int > s(Q), c(Q);
  for (int i = 0; i < Q; i++) {
    cin >> s[i] >> c[i];
    --s[i];
  }
  vector ok(Q, inf), ng(Q, -1), mid(Q, -1);


  UnionFind uf(N);
  vector< unordered_set< int > > st(N);
  using P = PersistentArray< int, 19 >;
  vector< P > as;
  P vs;
  vs.build(vector(N, 1));
  as.emplace_back(vs);
  for (int j = 0; j < N; j++) {
    st[j].emplace(A[j]);
  }
  for (auto [_, u, v] : es) {
    u = uf.find(u);
    v = uf.find(v);
    if (u != v) {
      if (st[u].size() < st[v].size()) {
        swap(u, v);
      }
      for (auto x : st[v]) st[u].emplace(x);
      st[v].clear();
      uf.unite(u, v);
      *vs.mutable_get(u) = st[u].size();
    }
    as.emplace_back(vs);
  }
  for (int i = 0; i < 32; i++) {
    vector< pair< int, int > > ev;
    for (int j = 0; j < Q; j++) {
      mid[j] = (ok[j] + ng[j]) / 2;
      ev.emplace_back(mid[j], j);
    }
    ranges::sort(ev);
    int p = 0;
    for (auto[vs, j]: ev) {
      while (p < es.size() and get< 0 >(es[p]) <= vs) {
        auto[_, u, v] = es[p];
        u = uf.find(u);
        v = uf.find(v);
        uf.unite(u, v);
        ++p;
      }
      auto u = uf.find(s[j]);
      if (as[p].get(u)  >= c[j]) ok[j] = vs;
      else ng[j] = vs;
    }
  }
  for (auto& p : ok) {
    if (p == inf) cout << -1 << "\n";
    else cout << p << "\n";
  }
}