#866411 (C++23) No.2292 Interval Union Find

提出ソース

結果

問題	No.2292 Interval Union Find
ユーザー	👑 emthrm
提出日時	2023-05-05 22:07:26
言語	C++23 (gcc 12.3.0 + boost 1.83.0)
結果	AC
実行時間	244 ms / 5,000 ms
コード長	6,070 bytes
コンパイル時間	3,513 ms
コンパイル使用メモリ	254,616 KB
実行使用メモリ	16,100 KB
最終ジャッジ日時	2023-08-15 04:17:06
合計ジャッジ時間	13,471 ms
ジャッジサーバーID （参考情報）	judge13 / judge14

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	1 ms 4,384 KB
testcase_01	AC	1 ms 4,380 KB
testcase_02	AC	1 ms 4,380 KB
testcase_03	AC	1 ms 4,380 KB
testcase_04	AC	61 ms 4,384 KB
testcase_05	AC	91 ms 4,384 KB
testcase_06	AC	59 ms 4,380 KB
testcase_07	AC	83 ms 4,380 KB
testcase_08	AC	89 ms 4,380 KB
testcase_09	AC	89 ms 4,380 KB
testcase_10	AC	81 ms 4,384 KB
testcase_11	AC	77 ms 4,380 KB
testcase_12	AC	93 ms 4,380 KB
testcase_13	AC	71 ms 4,384 KB
testcase_14	AC	74 ms 4,384 KB
testcase_15	AC	76 ms 4,384 KB
testcase_16	AC	74 ms 4,380 KB
testcase_17	AC	86 ms 4,384 KB
testcase_18	AC	162 ms 15,868 KB
testcase_19	AC	244 ms 15,860 KB
testcase_20	AC	236 ms 16,100 KB
testcase_21	AC	191 ms 10,716 KB
testcase_22	AC	191 ms 10,720 KB
testcase_23	AC	194 ms 10,788 KB
testcase_24	AC	194 ms 10,732 KB
testcase_25	AC	193 ms 10,744 KB
testcase_26	AC	196 ms 10,716 KB
testcase_27	AC	193 ms 10,692 KB
testcase_28	AC	194 ms 10,800 KB
testcase_29	AC	197 ms 10,952 KB
testcase_30	AC	194 ms 10,736 KB
testcase_31	AC	198 ms 10,712 KB
testcase_32	AC	197 ms 10,712 KB
testcase_33	AC	193 ms 10,688 KB
testcase_34	AC	194 ms 10,736 KB
testcase_35	AC	193 ms 10,872 KB
testcase_36	AC	197 ms 10,736 KB
testcase_37	AC	195 ms 10,760 KB
testcase_38	AC	195 ms 10,720 KB
testcase_39	AC	198 ms 10,708 KB
testcase_40	AC	196 ms 10,712 KB
testcase_41	AC	46 ms 4,380 KB
testcase_42	AC	48 ms 4,380 KB
testcase_43	AC	50 ms 4,384 KB
testcase_44	AC	56 ms 4,380 KB
testcase_45	AC	57 ms 4,384 KB
testcase_46	AC	59 ms 4,384 KB
testcase_47	AC	66 ms 4,384 KB

権限があれば一括ダウンロードができます

ソースコード

raw source code

#include <bits/stdc++.h>
using namespace std;
#define FOR(i,m,n) for(int i=(m);i<(n);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
using ll = long long;
constexpr int INF = 0x3f3f3f3f;
constexpr long long LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr double EPS = 1e-8;
constexpr int MOD = 998244353;
// constexpr int MOD = 1000000007;
constexpr int DY4[]{1, 0, -1, 0}, DX4[]{0, -1, 0, 1};
constexpr int DY8[]{1, 1, 0, -1, -1, -1, 0, 1};
constexpr int DX8[]{0, -1, -1, -1, 0, 1, 1, 1};
template <typename T, typename U>
inline bool chmax(T& a, U b) { return a < b ? (a = b, true) : false; }
template <typename T, typename U>
inline bool chmin(T& a, U b) { return a > b ? (a = b, true) : false; }
struct IOSetup {
  IOSetup() {
    std::cin.tie(nullptr);
    std::ios_base::sync_with_stdio(false);
    std::cout << fixed << setprecision(20);
  }
} iosetup;

template <typename T>
struct IntervalsManagedBySet {
  using IntervalsType = std::set<std::pair<T, T>>;
  IntervalsType intervals{
      {std::numeric_limits<T>::lowest(), std::numeric_limits<T>::lowest()},
      {std::numeric_limits<T>::max(), std::numeric_limits<T>::max()}};

  IntervalsManagedBySet() = default;

  bool contains(const T x) const { return contains(x, x); }

  bool contains(const T left, const T right) const {
    return find(left, right) != intervals.end();
  }

  std::pair<typename IntervalsType::const_iterator, bool> erase(const T x) {
    typename IntervalsType::const_iterator it = intervals.lower_bound({x, x});
    if (it->first == x) {
      const T right = it->second;
      it = intervals.erase(it);
      if (x + 1 <= right) it = intervals.emplace(x + 1, right).first;
    } else {
      it = std::prev(it);
      const auto [left, right] = *it;
      if (right < x) return {std::next(it), false};
      intervals.erase(it);
      it = std::next(intervals.emplace(left, x - 1).first);
      if (x + 1 <= right) it = intervals.emplace(x + 1, right).first;
    }
    return {it, true};
  }

  std::pair<typename IntervalsType::const_iterator, T> erase(
      const T left, const T right) {
    assert(left <= right);
    typename IntervalsType::const_iterator it =
        intervals.lower_bound({left, left});
    T res = 0;
    for (; it->second <= right; it = intervals.erase(it)) {
      res += it->second - it->first + 1;
    }
    if (it->first <= right) {
      res += right - it->first + 1;
      const T r = it->second;
      intervals.erase(it);
      it = intervals.emplace(right + 1, r).first;
    }
    if (left <= std::prev(it)->second) {
      it = std::prev(it);
      const auto [l, r] = *it;
      intervals.erase(it);
      if (right < r) {
        res += right - left + 1;
        intervals.emplace(right + 1, r);
      } else {
        res += r - left + 1;
      }
      it = std::next(intervals.emplace(l, left - 1).first);
    }
    return {it, res};
  }

  typename IntervalsType::const_iterator find(const T x) const {
    return find(x, x);
  }

  typename IntervalsType::const_iterator find(
      const T left, const T right) const {
    typename IntervalsType::const_iterator it =
        intervals.lower_bound({left, left});
    if (left < it->first) it = std::prev(it);
    return it->first <= left && right <= it->second ? it : intervals.end();
  }

  std::pair<typename IntervalsType::const_iterator, bool> insert(const T x) {
    typename IntervalsType::const_iterator it = intervals.lower_bound({x, x});
    if (it->first == x) return {it, false};
    if (x <= std::prev(it)->second) return {std::prev(it), false};
    T left = x, right = x;
    if (x + 1 == it->first) {
      right = it->second;
      it = intervals.erase(it);
    }
    if (std::prev(it)->second == x - 1) {
      it = std::prev(it);
      left = it->first;
      intervals.erase(it);
    }
    return {intervals.emplace(left, right).first, true};
  }

  std::pair<typename IntervalsType::const_iterator, T> insert(T left, T right) {
    assert(left <= right);
    typename IntervalsType::const_iterator it =
        intervals.lower_bound({left, left});
    if (left <= std::prev(it)->second) {
      it = std::prev(it);
      left = it->first;
    }
    T res = 0;
    if (left == it->first && right <= it->second) return {it, res};
    for (; it->second <= right; it = intervals.erase(it)) {
      res -= it->second - it->first + 1;
    }
    if (it->first <= right) {
      res -= it->second - it->first + 1;
      right = it->second;
      it = intervals.erase(it);
    }
    res += right - left + 1;
    if (right + 1 == it->first) {
      right = it->second;
      it = intervals.erase(it);
    }
    if (std::prev(it)->second == left - 1) {
      it = std::prev(it);
      left = it->first;
      intervals.erase(it);
    }
    return {intervals.emplace(left, right).first, res};
  }

  T mex(const T x = 0) const {
    auto it = intervals.lower_bound({x, x});
    if (x <= std::prev(it)->second) it = std::prev(it);
    return x < it->first ? x : it->second + 1;
  }

  friend std::ostream& operator<<(std::ostream& os,
                                  const IntervalsManagedBySet& x) {
    if (x.intervals.size() == 2) return os;
    auto it = next(x.intervals.begin());
    while (true) {
      os << '[' << it->first << ", " << it->second << ']';
      it = next(it);
      if (next(it) == x.intervals.end()) break;
      os << ' ';
    }
    return os;
  }
};

int main() {
  int n, q; cin >> n >> q;
  IntervalsManagedBySet<ll> s;
  while (q--) {
    int type; cin >> type;
    if (type == 1) {
      int l, r; cin >> l >> r;
      s.insert(l * 2, r * 2);
    } else if (type == 2) {
      int l, r; cin >> l >> r;
      s.erase((l + 1) * 2 - 1, (r - 1) * 2 + 1);
    } else if (type == 3) {
      int u, v; cin >> u >> v;
      if (u > v) swap(u, v);
      cout << (u == v || s.contains(u * 2, v * 2) ? "1\n" : "0\n");
    } else if (type == 4) {
      int v; cin >> v;
      const auto it = s.find(v * 2);
      cout << (it == s.intervals.end() ? 1 : (it->second - it->first + 2) / 2) << '\n';
    }
    // cout << s << '\n';
  }
  return 0;
}

yukicoder

結果

テストケース

ソースコード