Submission #264917

#	Time	Username	Problem	Language	Result	Execution time	Memory
264917		KoD	다리 (APIO19_bridges)	C++11	100 / 100	2332 ms	154968 KiB

bridges

/**
 * @title Template
 */

#include <iostream>
#include <algorithm>
#include <utility>
#include <numeric>
#include <vector>
#include <array>
#include <cassert>
#include <tuple>
#include <stack>


template <class T, class U>
bool chmin(T &lhs, const U &rhs) {
  if (lhs > rhs) { 
    lhs = rhs; 
    return true; 
  }
  return false;
}

template <class T, class U>
bool chmax(T &lhs, const U &rhs) {
  if (lhs < rhs) { 
    lhs = rhs; 
    return true; 
  }
  return false;
}

/**
 * @title Chmin/Chmax
 */


class range {
public:
  class iterator {
  private:
    int64_t M_position;

  public:
    iterator(int64_t position) noexcept: M_position(position) { }
    void operator ++ () noexcept { ++M_position; }
    bool operator != (iterator other) const noexcept { return M_position != other.M_position; }
    int64_t operator * () const noexcept { return M_position; }

  };

  class reverse_iterator {
  private:
    int64_t M_position;
  
  public:
    reverse_iterator(int64_t position) noexcept: M_position(position) { }
    void operator ++ () noexcept { --M_position; }
    bool operator != (reverse_iterator other) const noexcept { return M_position != other.M_position; }
    int64_t operator * () const noexcept { return M_position; }

  };
  
private:
  const iterator M_first, M_last;

public:
  range(int64_t first, int64_t last) noexcept: M_first(first), M_last(std::max(first, last)) { }
  iterator begin() const noexcept { return M_first; }
  iterator end() const noexcept { return M_last; }
  reverse_iterator rbegin() const noexcept { return reverse_iterator(*M_last - 1); } 
  reverse_iterator rend() const noexcept { return reverse_iterator(*M_first - 1); } 

};

/**
 * @title Range
 */

#include <type_traits>
#include <iterator>

template <class T>
class rev_impl {
public:
  using iterator = decltype(std::declval<T>().rbegin());

private:
  const iterator M_begin;
  const iterator M_end;

public:
  rev_impl(T &&cont) noexcept: M_begin(cont.rbegin()), M_end(cont.rend()) { }
  iterator begin() const noexcept { return M_begin; }
  iterator end() const noexcept { return M_end; }

};

template <class T>
rev_impl<T> rev(T &&cont) {
  return rev_impl<T>(std::forward<T>(cont));
}

/**
 * @title Reverser
 */

using i32 = int32_t;
using i64 = int64_t;
using u32 = uint32_t;
using u64 = uint64_t;

constexpr i32 inf32 = (i32(1) << 30) - 1;
constexpr i64 inf64 = (i64(1) << 62) - 1;

constexpr size_t Bucket = 800;

struct query_t {
  i32 u, v, c;
  query_t(i32 u_, i32 v_, i32 c_): u(u_), v(v_), c(c_) { }
};

int main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(nullptr);
  i32 N, M;
  std::cin >> N >> M;
  std::vector<i32> U(M), V(M), C(M);
  for (auto i: range(0, M)) {
    std::cin >> U[i] >> V[i] >> C[i];
    --U[i]; --V[i];
  }
  i32 Q;
  std::cin >> Q;
  i32 B = (Q + Bucket - 1) / Bucket;
  std::vector<std::vector<query_t>> qs1(B);
  std::vector<std::vector<std::tuple<i32, i32, i32>>> qs2(B);
  for (auto i: range(0, Q)) {
    i32 t;
    std::cin >> t;
    if (t == 1) {
      i32 b, r;
      std::cin >> b >> r;
      --b;
      qs2[i / Bucket].emplace_back(b, r, i);
    }
    else {
      i32 u, c;
      std::cin >> u >> c;
      --u;
      qs1[i / Bucket].emplace_back(u, -(i + 1), c);
    }
  }
  std::vector<i32> answer(Q);
  for (auto step: range(0, B)) {
    auto &q1 = qs1[step];
    const auto &q2 = qs2[step];
    q1.reserve(q1.size() + M);
    std::vector<bool> change(M);
    for (const auto &q: q2) {
      change[std::get<0>(q)] = true;
    }
    for (auto i: range(0, M)) {
      if (!change[i]) {
        q1.emplace_back(U[i], V[i], C[i]);
      }
    }
    std::sort(q1.begin(), q1.end(), [](const query_t &x, const query_t &y) {
      if (x.c != y.c) return x.c > y.c;
      return x.v > y.v;
    });
    std::vector<i32> parent(N, -1);
    const auto find = [&](i32 u) {
      while (parent[u] >= 0) {
        u = parent[u];
      }
      return u;
    };
    for (const auto &q: q1) {
      if (q.v >= 0) {
        i32 u = find(q.u), v = find(q.v);
        if (u == v) continue;
        if (parent[u] > parent[v]) std::swap(u, v);
        parent[u] += parent[v];
        parent[v] = u;
      }
      else {
        const i32 idx = -(q.v + 1);
        std::stack<std::tuple<i32, i32, i32, i32>> st;
        std::stack<std::pair<i32, i32>> eo;
        for (const auto &r: q2) {
          if (std::get<2>(r) < idx) {
            const i32 b = std::get<0>(r);
            eo.emplace(b, C[b]);
            C[b] = std::get<1>(r);
          }
        }
        for (const auto &r: q2) {
          const i32 b = std::get<0>(r);
          if (C[b] < q.c) continue;
          i32 u = find(U[b]), v = find(V[b]);
          if (u == v) continue;
          if (parent[u] > parent[v]) std::swap(u, v);
          st.emplace(u, parent[u], v, parent[v]);
          parent[u] += parent[v];
          parent[v] = u;
        }
        answer[idx] = -parent[find(q.u)];
        while (!st.empty()) {
          i32 u, up, v, vp;
          std::tie(u, up, v, vp) = st.top();
          st.pop();
          parent[u] = up;
          parent[v] = vp;
        }
        while (!eo.empty()) {
          C[eo.top().first] = eo.top().second;
          eo.pop();
        }
      }
    }
    for (const auto &q: q2) {
      C[std::get<0>(q)] = std::get<1>(q);
    }
  }
  for (auto x: answer) {
    if (x != 0) {
      std::cout << x << '\n';
    }
  }
  return 0;
}

• Subtask 1: 13 / 13
• Subtask 2: 16 / 16
• Subtask 3: 17 / 17
• Subtask 4: 14 / 14
• Subtask 5: 13 / 13
• Subtask 6: 27 / 27