test/aoj/2880/2880-test-00.cpp

• View this file on GitHub
• Last update: 2025-12-27 20:04:46+09:00
• Problem: https://onlinejudge.u-aizu.ac.jp/problems/2880

Depends on

• cplib/intersection.hpp
• cplib/IntervalSet.hpp
• cplib/vector_io.hpp

Code

// competitive-verifier: PROBLEM https://onlinejudge.u-aizu.ac.jp/problems/2880
#include <bits/stdc++.h>
#include <atcoder/modint>
#include "cplib/IntervalSet.hpp"
#include "cplib/vector_io.hpp"

using namespace std;
using namespace atcoder;
using namespace cplib;

#ifdef DEBUG
template <typename T, typename U> void debug_print(T var_name, U value) {
    cerr << var_name << ": " << value << endl;
}
#define debug(x) debug_print(#x, x)
constexpr bool is_debug = true;
#else
// #pragma GCC target("arch=skylake-avx512")
#pragma GCC optimize("O3")
// #pragma GCC optimize("unroll-loops")
#define debug(x)
constexpr bool is_debug = false;
#endif

using ll = long long;
template <typename T>
using reverse_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template <typename T> using vector2 = vector<vector<T>>;
template <typename T> using vector3 = vector<vector2<T>>;
template <typename T> using vector4 = vector<vector3<T>>;
template <typename T> using vector5 = vector<vector4<T>>;
template <typename T> using vector6 = vector<vector5<T>>;
template <typename T>
inline vector2<T> make_vector2(const size_t l0,
                               const size_t l1,
                               const T& init = T{}) {
    return vector2<T>(l0, vector<T>(l1, init));
}
template <typename T>
inline vector3<T> make_vector3(const size_t l0,
                               const size_t l1,
                               const size_t l2,
                               const T& init = T{}) {
    return vector3<T>(l0, make_vector2<T>(l1, l2, init));
}
template <typename T>
inline vector4<T> make_vector4(const size_t l0,
                               const size_t l1,
                               const size_t l2,
                               const size_t l3,
                               const T& init = T{}) {
    return vector4<T>(l0, make_vector3<T>(l1, l2, l3, init));
}
template <typename T>
inline vector5<T> make_vector5(const size_t l0,
                               const size_t l1,
                               const size_t l2,
                               const size_t l3,
                               const size_t l4,
                               const T& init = T{}) {
    return vector5<T>(l0, make_vector4<T>(l1, l2, l3, l4, init));
}
template <typename T>
inline vector6<T> make_vector6(const size_t l0,
                               const size_t l1,
                               const size_t l2,
                               const size_t l3,
                               const size_t l4,
                               const size_t l5,
                               const T& init = T{}) {
    return vector6<T>(l0, make_vector5<T>(l1, l2, l3, l4, l5, init));
}

#define rep(...) overloadrep(__VA_ARGS__, rep4_, rep3_, rep2_)(__VA_ARGS__)
#define overloadrep(_1, _2, _3, _4, repn_, ...) repn_
#define rep2_(i, n) rep4_(i, 0, n, 1)
#define rep3_(i, a, b) rep4_(i, a, b, 1)
#define rep4_(i, a, b, s) for (auto i = (a); i < (b); i += (s))
#define repr(i, a, b) for (auto i = (b) - 1; i >= (a); --i)
#define foreach(x, a) for (auto& x : (a))

void din_() {}
template <class Head, class... Tail> void din_(Head&& head, Tail&&... tail) {
    cin >> head;
    din_(move(tail)...);
}
#define din(T, ...) \
    T __VA_ARGS__;  \
    din_(__VA_ARGS__)

inline void dout() { cout << '\n'; }
template <typename Head, typename... Tail>
void dout(const Head head, const Tail... tail) {
    cout << head;
    if constexpr (sizeof...(tail) > 0) {
        cout << ' ';
    }
    dout(tail...);
}

template <class T = ll> T IN() {
    T x;
    cin >> x;
    return (x);
}

inline void YesNo(bool b, const string yes, const string no) noexcept {
    cout << (b ? yes : no) << '\n';
}
inline void YES(bool b) noexcept { YesNo(b, "YES", "NO"); }
inline void Yes(bool b) noexcept { YesNo(b, "Yes", "No"); }
inline void POSSIBLE(bool b) noexcept { YesNo(b, "POSSIBLE", "IMPOSSIBLE"); }
inline void Possible(bool b) noexcept { YesNo(b, "Possible", "Impossible"); }
inline void FIRST(bool b) noexcept { YesNo(b, "FIRST", "SECOND"); }
inline void First(bool b) noexcept { YesNo(b, "First", "Second"); }

#define all(x) (x).begin(), (x).end()
template <typename T> inline int siz(const T& x) { return int(x.size()); }
template <typename IntLike> constexpr int Pcnt(const IntLike n) {
    return popcount(static_cast<unsigned long long>(n));
}
template <typename IntLike> constexpr ll Bit(const IntLike n) {
    return 1LL << n;
}
template <typename T> inline void uniq(vector<T>& v) {
    auto result = ranges::unique(v);
    v.erase(result.begin(), result.end());
}

template <class T1, class T2>
    requires totally_ordered_with<T1, T2> && assignable_from<T1&, T2>
inline bool chmax(T1& a, const T2& b) noexcept {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}
template <class T1, class T2>
    requires totally_ordered_with<T1, T2> && assignable_from<T1&, T2>
inline bool chmin(T1& a, const T2& b) noexcept {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}

constexpr char enl = '\n';
constexpr int dx[] = {1, 0, -1, 0, 1, -1, -1, 1};
constexpr int dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
constexpr long double eps = 1e-10;
constexpr int INF = 1'010'000'000;                 // 1e9
constexpr ll llINF = 3'010'000'000'000'000'000LL;  // 3e18
// constexpr ll MOD = 1'000'000'007LL;
constexpr ll MOD = 998244353LL;
using mint = static_modint<MOD>;

void Main([[maybe_unused]] int testcase_i) {
    din(int, n, m, q);
    vector<tuple<int, int, int, int>> event(m + q);
    rep(i, m) {
        din(int, d, a, b);
        event[i] = {d, INF, a, b};
    }
    rep(i, q) {
        din(int, e, s, t);
        event[i + m] = {e, i, s, t};
    }
    ranges::sort(event);
    cplib::IntervalSet<int> s;
    vector<bool> ans(q);
    for (auto& [day, qi, x, y] : event) {
        if (qi != INF) {
            ans[qi] = x >= y || s.mex(x) == s.mex(y);
        } else {
            s.insert(x, y);
        }
    }
    for (auto bo : ans) Yes(bo);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(15);
    int t = 1;
    // cin >> t;
    rep(i, t) Main(i);
}

#line 1 "test/aoj/2880/2880-test-00.cpp"
// competitive-verifier: PROBLEM https://onlinejudge.u-aizu.ac.jp/problems/2880
#include <bits/stdc++.h>
#include <atcoder/modint>
#line 2 "cplib/IntervalSet.hpp"

#line 5 "cplib/IntervalSet.hpp"
#include <concepts>
#line 8 "cplib/IntervalSet.hpp"
#include <ranges>
#line 2 "cplib/intersection.hpp"

#line 5 "cplib/intersection.hpp"

namespace cplib {

// [l1, r1)と[l2, r2)の共通部分を求める
// 共通部分がない場合や入力が l>r の場合は(0, 0)を返す
template <typename T>
constexpr inline std::pair<T, T> intersection(const T& l1,
                                              const T& r1,
                                              const T& l2,
                                              const T& r2) {
    const T l = std::max(l1, l2);
    const T r = std::min(r1, r2);
    if (l < r)
        return std::make_pair(l, r);
    else
        return std::make_pair(0, 0);
}

}  // namespace cplib
#line 13 "cplib/IntervalSet.hpp"

namespace cplib {

// Reference:
// https://github.com/drken1215/algorithm/blob/c9e99d6fe51137f0dc10cf3ca7f28ec4b07a14a9/DataStructureSegment/intervals_management_with_noninvertible_del.cpp

// 区間をsetで管理するクラス
template <std::totally_ordered coord = int64_t> struct IntervalSet {
  public:
    struct Interval {
        coord l;
        coord r;
        auto operator<=>(const Interval&) const = default;
    };
    using Set = std::set<Interval>;

  private:
    Set set;

  public:
    IntervalSet() {}
    template <typename T>
        requires std::ranges::input_range<T> &&
                 std::convertible_to<std::ranges::range_reference_t<T>,
                                     Interval>
    IntervalSet(const T& v) {
        set = std::ranges::to<Set>(v);
    }

    constexpr auto begin() const { return std::ranges::begin(set); }
    constexpr auto end() const { return std::ranges::end(set); }

    // p以上の点を含む区間のうち最も左にあるものへのイテレーターを取得する
    // p以上の点を含む区間が存在しない場合endを返す
    constexpr auto lower_bound(const coord& p) const
        requires std::same_as<decltype(std::numeric_limits<coord>::max()),
                              coord>
    {
        auto it =
            set.upper_bound(Interval(p, std::numeric_limits<coord>::max()));
        // assert(it == end() || p < it->l);
        if (it == begin()) return it;
        auto pit = std::ranges::prev(it);
        // assert(pit->l <= p);
        if (p < pit->r)
            return pit;
        else
            return it;
    }

    // pを含む区間へのイテレーターを取得する
    // pを含む区間が存在しない場合endを返す
    constexpr auto get_iterator(const coord& p) const {
        auto it = lower_bound(p);
        if (it == end()) return it;
        // assert(p < it->r);
        if (it->l <= p)
            return it;
        else
            return end();
    }

    // pを含む区間が存在するか判定する
    constexpr bool covered(const coord& p) const {
        return get_iterator(p) != end();
    }

    // [l, r)を完全に含む区間が存在するか判定する
    constexpr bool covered(const coord& l, const coord& r) const {
        if (l >= r) return true;
        auto it = get_iterator(l);
        return it != end() && r <= it->r;
    }

    // pとqが同じ区間に含まれるか判定する
    // pまたはqがどの区間にも含まれていない場合falseを返す
    constexpr bool same(const coord& p, const coord& q) const {
        if (!(covered(p) && covered(q))) return false;
        return get_iterator(p) == get_iterator(q);
    }

    // p以上の点のうち、どの区間にも含まれないような最左の点を返す
    constexpr coord mex(const coord& p = 0) const {
        if (!covered(p)) return p;
        return lower_bound(p)->r;
    }

    // setに含まれる区間全体と[l, r)の共通部分をvectorで返す
    constexpr std::vector<Interval> intersection(const coord& l,
                                                 const coord& r) const {
        if (l >= r) return std::vector<Interval>();
        std::vector<Interval> result;
        for (auto it = lower_bound(l); it != end() && it->l < r;
             std::ranges::advance(it, 1)) {
            auto [inter_l, inter_r] = cplib::intersection(l, r, it->l, it->r);
            // assert(inter_l < inter_r);
            result.push_back(Interval(inter_l, inter_r));
        }
        return result;
    }

    // [l, r)のうちsetに含まれない部分をvectorで返す
    constexpr std::vector<Interval> excluded(const coord& l,
                                             const coord& r) const {
        if (l >= r) return std::vector<Interval>();
        std::vector<Interval> inter_v = intersection(l, r);
        auto len = std::ranges::size(inter_v);
        if (len == 0) {
            return std::vector<Interval>(1, Interval(l, r));
        }
        std::vector<Interval> result;
        if (l < inter_v[0].l) {
            result.emplace_back(l, inter_v[0].l);
        }
        for (int i = 0; i < int(len) - 1; ++i) {
            result.emplace_back(inter_v[i].r, inter_v[i + 1].l);
        }
        if (inter_v.back().r < r) {
            result.emplace_back(inter_v.back().r, r);
        }
        return result;
    }

    // todo: get_state(l, r) intersectionとexcludedを合わせる
    // get_stateを使ってnot invertibleな関数に対応する
    // 閉区間バージョンを作る

    // 区間[l, r)を追加する
    // setに区間を追加した直後、追加した区間への読み取り専用イテレーターを引数としてadd_funcを呼び出す
    // setの区間を削除する直前、削除する区間への読み取り専用イテレーターを引数としてdel_funcを呼び出す
    template <std::invocable<std::ranges::const_iterator_t<Set>> AddFunc,
              std::invocable<std::ranges::const_iterator_t<Set>> DelFunc>
    void insert(coord l,
                coord r,
                const AddFunc& add_func,
                const DelFunc& del_func) {
        if (l >= r) return;
        // 消す区間のうち最も左のものを探す
        // 右端がlの区間があればまとめるために消す
        auto it = lower_bound(l);
        if (it != begin()) {
            auto pit = std::ranges::prev(it);
            // assert(pit->r <= l);
            if (pit->r == l) it = pit;
        }
        // [l, r]と共通部分がある区間を消す
        // 左端がrの区間もまとめるために消す
        while (it != end() && it->l <= r) {
            del_func(static_cast<std::ranges::const_iterator_t<Set>>(it));
            if (it->l < l) l = it->l;
            if (r < it->r) r = it->r;
            it = set.erase(it);
        }
        // insert
        // assert(l < r);
        it = set.emplace_hint(it, l, r);
        add_func(static_cast<std::ranges::const_iterator_t<Set>>(it));
    }
    // 区間[l, r)を追加する
    void insert(const coord& l, const coord& r) {
        insert(
            l, r, [](std::ranges::const_iterator_t<Set>) {},
            [](std::ranges::const_iterator_t<Set>) {});
    }

    // 区間[l, r)を削除する
    // setに区間を追加した直後、追加した区間への読み取り専用イテレーターを引数としてadd_funcを呼び出す
    // setの区間を削除する直前、削除する区間への読み取り専用イテレーターを引数としてdel_funcを呼び出す
    template <std::invocable<std::ranges::const_iterator_t<Set>> AddFunc,
              std::invocable<std::ranges::const_iterator_t<Set>> DelFunc>
    void erase(coord l,
               coord r,
               const AddFunc& add_func,
               const DelFunc& del_func) {
        if (l >= r) return;
        auto it = lower_bound(l);
        while (it != end() && it->l < r) {
            del_func(static_cast<std::ranges::const_iterator_t<Set>>(it));
            coord tl = it->l, tr = it->r;
            it = set.erase(it);
            if (r < tr) {
                it = set.emplace_hint(it, r, tr);
                add_func(static_cast<std::ranges::const_iterator_t<Set>>(it));
            }
            if (tl < l) {
                it = set.emplace_hint(it, tl, l);
                add_func(static_cast<std::ranges::const_iterator_t<Set>>(it));
                std::ranges::advance(it, 1);
            }
        }
    }
    // 区間[l, r)を削除する
    void erase(const coord& l, const coord& r) {
        erase(
            l, r, [](std::ranges::const_iterator_t<Set>) {},
            [](std::ranges::const_iterator_t<Set>) {});
    }
};

}  // namespace cplib
#line 2 "cplib/vector_io.hpp"

#line 6 "cplib/vector_io.hpp"

namespace cplib {

template <typename T>
inline std::istream& operator>>(std::istream& is, std::vector<T>& v) {
#ifdef DEBUG
    assert(v.size() != 0);
#endif
    for (auto& x : v) is >> x;
    return is;
}

template <typename T>
inline std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
    const size_t len = v.size();
    for (size_t i = 0; i < len - 1; ++i) os << v[i] << ' ';
    if (len > 0) os << v[len - 1];
    return os;
}

}  // namespace cplib
#line 6 "test/aoj/2880/2880-test-00.cpp"

using namespace std;
using namespace atcoder;
using namespace cplib;

#ifdef DEBUG
template <typename T, typename U> void debug_print(T var_name, U value) {
    cerr << var_name << ": " << value << endl;
}
#define debug(x) debug_print(#x, x)
constexpr bool is_debug = true;
#else
// #pragma GCC target("arch=skylake-avx512")
#pragma GCC optimize("O3")
// #pragma GCC optimize("unroll-loops")
#define debug(x)
constexpr bool is_debug = false;
#endif

using ll = long long;
template <typename T>
using reverse_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template <typename T> using vector2 = vector<vector<T>>;
template <typename T> using vector3 = vector<vector2<T>>;
template <typename T> using vector4 = vector<vector3<T>>;
template <typename T> using vector5 = vector<vector4<T>>;
template <typename T> using vector6 = vector<vector5<T>>;
template <typename T>
inline vector2<T> make_vector2(const size_t l0,
                               const size_t l1,
                               const T& init = T{}) {
    return vector2<T>(l0, vector<T>(l1, init));
}
template <typename T>
inline vector3<T> make_vector3(const size_t l0,
                               const size_t l1,
                               const size_t l2,
                               const T& init = T{}) {
    return vector3<T>(l0, make_vector2<T>(l1, l2, init));
}
template <typename T>
inline vector4<T> make_vector4(const size_t l0,
                               const size_t l1,
                               const size_t l2,
                               const size_t l3,
                               const T& init = T{}) {
    return vector4<T>(l0, make_vector3<T>(l1, l2, l3, init));
}
template <typename T>
inline vector5<T> make_vector5(const size_t l0,
                               const size_t l1,
                               const size_t l2,
                               const size_t l3,
                               const size_t l4,
                               const T& init = T{}) {
    return vector5<T>(l0, make_vector4<T>(l1, l2, l3, l4, init));
}
template <typename T>
inline vector6<T> make_vector6(const size_t l0,
                               const size_t l1,
                               const size_t l2,
                               const size_t l3,
                               const size_t l4,
                               const size_t l5,
                               const T& init = T{}) {
    return vector6<T>(l0, make_vector5<T>(l1, l2, l3, l4, l5, init));
}

#define rep(...) overloadrep(__VA_ARGS__, rep4_, rep3_, rep2_)(__VA_ARGS__)
#define overloadrep(_1, _2, _3, _4, repn_, ...) repn_
#define rep2_(i, n) rep4_(i, 0, n, 1)
#define rep3_(i, a, b) rep4_(i, a, b, 1)
#define rep4_(i, a, b, s) for (auto i = (a); i < (b); i += (s))
#define repr(i, a, b) for (auto i = (b) - 1; i >= (a); --i)
#define foreach(x, a) for (auto& x : (a))

void din_() {}
template <class Head, class... Tail> void din_(Head&& head, Tail&&... tail) {
    cin >> head;
    din_(move(tail)...);
}
#define din(T, ...) \
    T __VA_ARGS__;  \
    din_(__VA_ARGS__)

inline void dout() { cout << '\n'; }
template <typename Head, typename... Tail>
void dout(const Head head, const Tail... tail) {
    cout << head;
    if constexpr (sizeof...(tail) > 0) {
        cout << ' ';
    }
    dout(tail...);
}

template <class T = ll> T IN() {
    T x;
    cin >> x;
    return (x);
}

inline void YesNo(bool b, const string yes, const string no) noexcept {
    cout << (b ? yes : no) << '\n';
}
inline void YES(bool b) noexcept { YesNo(b, "YES", "NO"); }
inline void Yes(bool b) noexcept { YesNo(b, "Yes", "No"); }
inline void POSSIBLE(bool b) noexcept { YesNo(b, "POSSIBLE", "IMPOSSIBLE"); }
inline void Possible(bool b) noexcept { YesNo(b, "Possible", "Impossible"); }
inline void FIRST(bool b) noexcept { YesNo(b, "FIRST", "SECOND"); }
inline void First(bool b) noexcept { YesNo(b, "First", "Second"); }

#define all(x) (x).begin(), (x).end()
template <typename T> inline int siz(const T& x) { return int(x.size()); }
template <typename IntLike> constexpr int Pcnt(const IntLike n) {
    return popcount(static_cast<unsigned long long>(n));
}
template <typename IntLike> constexpr ll Bit(const IntLike n) {
    return 1LL << n;
}
template <typename T> inline void uniq(vector<T>& v) {
    auto result = ranges::unique(v);
    v.erase(result.begin(), result.end());
}

template <class T1, class T2>
    requires totally_ordered_with<T1, T2> && assignable_from<T1&, T2>
inline bool chmax(T1& a, const T2& b) noexcept {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}
template <class T1, class T2>
    requires totally_ordered_with<T1, T2> && assignable_from<T1&, T2>
inline bool chmin(T1& a, const T2& b) noexcept {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}

constexpr char enl = '\n';
constexpr int dx[] = {1, 0, -1, 0, 1, -1, -1, 1};
constexpr int dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
constexpr long double eps = 1e-10;
constexpr int INF = 1'010'000'000;                 // 1e9
constexpr ll llINF = 3'010'000'000'000'000'000LL;  // 3e18
// constexpr ll MOD = 1'000'000'007LL;
constexpr ll MOD = 998244353LL;
using mint = static_modint<MOD>;

void Main([[maybe_unused]] int testcase_i) {
    din(int, n, m, q);
    vector<tuple<int, int, int, int>> event(m + q);
    rep(i, m) {
        din(int, d, a, b);
        event[i] = {d, INF, a, b};
    }
    rep(i, q) {
        din(int, e, s, t);
        event[i + m] = {e, i, s, t};
    }
    ranges::sort(event);
    cplib::IntervalSet<int> s;
    vector<bool> ans(q);
    for (auto& [day, qi, x, y] : event) {
        if (qi != INF) {
            ans[qi] = x >= y || s.mex(x) == s.mex(y);
        } else {
            s.insert(x, y);
        }
    }
    for (auto bo : ans) Yes(bo);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(15);
    int t = 1;
    // cin >> t;
    rep(i, t) Main(i);
}

Test cases

Env	Name	Status	Elapsed	Memory
g++	00_sample_00.in	AC	10 ms	0 MB
g++	00_sample_01.in	AC	9 ms	0 MB
g++	10_handmade_00.in	AC	9 ms	0 MB
g++	10_handmade_01.in	AC	9 ms	0 MB
g++	10_handmade_02.in	AC	10 ms	0 MB
g++	10_handmade_03.in	AC	10 ms	0 MB
g++	50_random_small_00.in	AC	10 ms	0 MB
g++	50_random_small_01.in	AC	10 ms	0 MB
g++	50_random_small_02.in	AC	10 ms	0 MB
g++	50_random_small_03.in	AC	10 ms	0 MB
g++	50_random_small_04.in	AC	10 ms	0 MB
g++	50_random_small_05.in	AC	9 ms	0 MB
g++	50_random_small_06.in	AC	9 ms	0 MB
g++	50_random_small_07.in	AC	9 ms	0 MB
g++	50_random_small_08.in	AC	10 ms	0 MB
g++	50_random_small_09.in	AC	10 ms	0 MB
g++	51_random_large_00.in	AC	202 ms	0 MB
g++	51_random_large_01.in	AC	152 ms	0 MB
g++	51_random_large_02.in	AC	162 ms	0 MB
g++	51_random_large_03.in	AC	287 ms	0 MB
g++	51_random_large_04.in	AC	222 ms	0 MB
g++	51_random_large_05.in	AC	307 ms	0 MB
g++	51_random_large_06.in	AC	167 ms	0 MB
g++	51_random_large_07.in	AC	184 ms	0 MB
g++	51_random_large_08.in	AC	221 ms	0 MB
g++	51_random_large_09.in	AC	157 ms	0 MB
g++	52_MIN_00.in	AC	10 ms	0 MB
g++	53_MAX_00.in	AC	367 ms	0 MB
g++	53_MAX_01.in	AC	362 ms	0 MB
g++	53_MAX_02.in	AC	357 ms	0 MB
g++	53_MAX_03.in	AC	354 ms	0 MB
g++	53_MAX_04.in	AC	353 ms	0 MB
g++	53_MAX_05.in	AC	351 ms	0 MB
g++	53_MAX_06.in	AC	352 ms	0 MB
g++	53_MAX_07.in	AC	354 ms	0 MB
g++	53_MAX_08.in	AC	361 ms	0 MB
g++	53_MAX_09.in	AC	362 ms	0 MB
g++	54_Nsmall_00.in	AC	252 ms	0 MB
g++	54_Nsmall_01.in	AC	164 ms	0 MB
g++	54_Nsmall_02.in	AC	260 ms	0 MB
g++	54_Nsmall_03.in	AC	104 ms	0 MB
g++	54_Nsmall_04.in	AC	242 ms	0 MB
g++	54_Nsmall_05.in	AC	49 ms	0 MB
g++	54_Nsmall_06.in	AC	97 ms	0 MB
g++	54_Nsmall_07.in	AC	134 ms	0 MB
g++	54_Nsmall_08.in	AC	214 ms	0 MB
g++	54_Nsmall_09.in	AC	204 ms	0 MB
g++	55_Msmall_00.in	AC	27 ms	0 MB
g++	55_Msmall_01.in	AC	91 ms	0 MB
g++	55_Msmall_02.in	AC	25 ms	0 MB
g++	55_Msmall_03.in	AC	58 ms	0 MB
g++	55_Msmall_04.in	AC	44 ms	0 MB
g++	55_Msmall_05.in	AC	66 ms	0 MB
g++	55_Msmall_06.in	AC	71 ms	0 MB
g++	55_Msmall_07.in	AC	48 ms	0 MB
g++	55_Msmall_08.in	AC	85 ms	0 MB
g++	55_Msmall_09.in	AC	70 ms	0 MB
g++	56_DEsmall_00.in	AC	197 ms	0 MB
g++	56_DEsmall_01.in	AC	346 ms	0 MB
g++	56_DEsmall_02.in	AC	266 ms	0 MB
g++	56_DEsmall_03.in	AC	205 ms	0 MB
g++	56_DEsmall_04.in	AC	132 ms	0 MB
g++	56_DEsmall_05.in	AC	176 ms	0 MB
g++	56_DEsmall_06.in	AC	203 ms	0 MB
g++	56_DEsmall_07.in	AC	186 ms	0 MB
g++	56_DEsmall_08.in	AC	51 ms	0 MB
g++	56_DEsmall_09.in	AC	150 ms	0 MB
g++	60_challenge_00.in	AC	359 ms	0 MB
g++	60_challenge_01.in	AC	290 ms	0 MB

Back to top page