Submission #372599


Source Code Expand

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <cassert>
#include <cstdio>
#include <bitset>

using namespace std;
typedef long long ll;

/**
 * AA Treeにより書かれたMultiset
 *
 * とにかくクソ長い, ICPCで使うのは自殺行為
 * insert/eraseはこのライブラリの平衡二分木の中では最速
 * ただしstd::setよりは遅い、1.5倍程度?
 * 
 * template引数のclass Dは要素の型、class Cは比較関数
 */
template<class D, class C = less<D>>
struct AAMSet {
    struct Node;
    typedef Node* NP;
    static Node last_d;
    static NP last;
    struct Node {
        NP l, r;
        int level, sz;
        D v;
        Node(): l(nullptr), r(nullptr), level(0), sz(0) {}
        Node(D vv): l(last), r(last), level(1), sz(1) {
            v = vv;
        }
        /// メモリプールをしたい時のためにnewはラッパする
        static NP make() {
            return new Node();
        }
        static NP make(D vv) {
            return new Node(vv);
        }

        inline void update() {
            sz = 1+l->sz+r->sz;
        }

        inline void push() {
        }
    } *n;

    static D at(NP n, int k) {
        if (k == n->l->sz) return n->v;
        n->push();
        if (k < n->l->sz) {
            return at(n->l, k);
        } else {
            return at(n->r, k - (n->l->sz+1));
        }
    }
    /// k番目の要素を取得
    D at(int k) {
        return at(n, k);
    }
    static int lb(NP n, D x) {
        if (n == last) return 0;
        if (C()(n->v, x)) return n->l->sz + 1 + lb(n->r, x);
        return lb(n->l, x);
    }
    /// lower_bound、ただし返り値はインデックス
    int lb(D v) {
        return lb(n, v);
    }
    static int ub(NP n, D x) {
        if (n == last) return 0;
        if (C()(x, n->v)) return ub(n->l, x);
        return n->l->sz + 1 + ub(n->r, x);
    }
    /// upper_bound、ただし返り値はインデックス
    int ub(D v) {
        return ub(n, v);
    }
    static NP insert(NP n, D x) {
        if (n == last) {
            return Node::make(x);
        }
        n->push();
        if (!C()(n->v, x)) {
            n->l = insert(n->l, x);
            n->update();
        } else {
            n->r = insert(n->r, x);
            n->update();
        }
        n = skew(n);
        n = pull(n);
        return n;
    }
    /// xをinsertする
    void insert(D x) {
        n = insert(n, lb(x), x);
    }
    static NP erase(NP n, D x) {
        assert(n != last);
        n->push();
        if (!C()(n->v, x) && !C()(x, n->v)) {
            if (n->level == 1) {
                return n->r;
            }
            auto x = at0_with_remove(n->r);
            NP nn = x.first;
            nn->push();
            nn->l = n->l;
            nn->r = x.second;
            nn->level = n->level;
            nn->update();
            return rightdown(nn);
        }
        if (C()(x, n->v)) {
            n->l = erase(n->l, x);
            n->update();
            return leftdown(n);
        } else {
            n->r = erase(n->r, x);
            n->update();
            return rightdown(n);
        }
    }
    /// xを削除する
    void erase(D x) {
        n = remove(n, lb(x));
    }

    static void tp(NP n) {
        if (n == last) return;
        n->push();
        tp(n->l);
        cout << n->v << " ";
        tp(n->r);
    }
    void tp() {
        tp(n);
        printf("\n");
    }
    static void allpush(NP n) {
        if (n == last) return;
        n->push();
        allpush(n->l);
        allpush(n->r);
    }
    void allpush() {
        allpush(n);
        return;
    }

    static NP built(int sz, D d[]) {
        if (!sz) return last;
        int md = (sz-1)/2;
        NP n = Node::make(d[md]);
        n->l = built(md, d);
        n->r = built(sz-(md+1), d+(md+1));
        n->level = n->l->level+1;
        n->update();
        return n;
    }
    AAMSet() : n(last) {}
    AAMSet(NP n) : n(n) {}
    //木の初期化はn回insertより一気に作る方が有意に速くなる事が多い
    AAMSet(int sz, D d[]) {
        n = built(sz, d);
    }


    //基本動作
    int sz() {
        return n->sz;
    }
    int size() {
        return sz();
    }
    void merge(AAMSet r) {
        n = merge(n, r.n);
    }
    AAMSet split(int k) {
        auto y = split(n, k);
        n = y.first;
        return AAMSet(y.second);
    }
    void insert(int k, D x) {
        n = insert(n, k, x);
    }
    void remove(int k) {
        n = remove(n, k);
    }

    //AA木の基本動作であるskew/split splitは名前が紛らわしいためpullに変更してある
    static NP skew(NP n) {
        if (n->level == n->l->level) {
            NP L = n->l;
            n->push(); L->push();
            n->l = L->r;
            L->r = n;
            n->update(); L->update();
            return L;
        }
        return n;
    }
    static NP pull(NP n) {
        if (n->level == n->r->level && n->r->level == n->r->r->level) {
            NP R = n->r;
            n->push(); R->push();
            n->r = R->l;
            R->l = n;
            R->level++;
            n->update(); R->update();
            return R;
        }
        return n;
    }

    static NP leftdown(NP n) {
        assert(n->l->level < n->level);
        if (n->l->level == n->level-1) return n;
        n->level--;
        if (n->r->level == n->level) {
            n = pull(n);
        } else {
            n->r->level--;
            n->r = skew(n->r);
            n->r->r = skew(n->r->r);
            n = pull(n);
            n->r = pull(n->r);
        }
        return n;
    }
    static NP rightdown(NP n) {
        assert(n->r->level <= n->level);
        if (n->r->level >= n->level-1) return n;
        n->level--;
        n = skew(n);
        n->r = skew(n->r);
        n = pull(n);
        return n;
    }
    static NP superleftdown(NP n) {
        if (n->l->level == n->level-1) return n;
        if (n->level != n->r->level && n->r->level != n->r->r->level) {
            n->level--;
            return superleftdown(n);
        }
        n = leftdown(n);
        n->l = superleftdown(n->l);
        n = leftdown(n);
        return n;
    }
    static NP superrightdown(NP n) {
        if (n->r->level >= n->level-1) return n;
        n = rightdown(n);
        n->r = superrightdown(n->r);
        n = rightdown(n);
        return n;
    }

    static NP insert(NP n, int k, D x) {
        if (n == last) {
            assert(k == 0);
            return Node::make(x);
        }
        n->push();
        if (k <= n->l->sz) {
            n->l = insert(n->l, k, x);
            n->update();
        } else {
            n->r = insert(n->r, k - (n->l->sz+1), x);
            n->update();
        }
        n = skew(n);
        n = pull(n);
        return n;
    }
    //pair<0番目の要素,0番目の要素を削除した木>
    static pair<NP, NP> at0_with_remove(NP n) {
        n->push();
        if (n->l == last) {
            return {n, n->r};
        }
        auto x = at0_with_remove(n->l);
        n->l = x.second;
        n->update();
        x.second = leftdown(n);
        return x;
    }
    static NP remove(NP n, int k) {
        assert(n != last);
        n->push();
        if (k == n->l->sz) {
            if (n->level == 1) {
                return n->r;
            }
            auto x = at0_with_remove(n->r);
            NP nn = x.first;
            nn->push();
            nn->l = n->l;
            nn->r = x.second;
            nn->level = n->level;
            nn->update();
            return rightdown(nn);
        }
        if (k < n->l->sz) {
            n->l = remove(n->l, k);
            n->update();
            return leftdown(n);
        } else {
            n->r = remove(n->r, k - (n->l->sz+1));
            n->update();
            return rightdown(n);
        }
    }
    static NP merge(NP l, NP r) {
        if (l == last) return r;
        if (r == last) return l;
        if (l->level == r->level) {
            auto x = at0_with_remove(r);
            NP n = x.first;
            n->push();
            n->r = x.second;
            n->l = l;
            n->level = l->level+1;
            n->update();
            return rightdown(n);
        }
        NP n;
        l->push(); r->push();
        if (l->level > r->level) {
            l->push();
            l->r = merge(l->r, r);
            l->update();
            n = l;
        } else {
            r->push();
            r->l = merge(l, r->l);
            r->update();
            n = r;
        }
        n = skew(n);
        n = pull(n);
        return n;
    }
    static pair<NP, NP> split(NP n, int k) {
        if (n == last) return {last, last};
        n->push();
        if (k <= n->l->sz) {
            auto y = split(n->l, k);
            n->l = y.second;
            n->update();
            n = superleftdown(n);
            y.second = n;
            return y;
        } else {
            auto y = split(n->r, k- (n->l->sz+1));
            n->r = y.first;
            n->update();
            n = superrightdown(n);
            y.first = n;
            return y;
        }
    }
};
template<class D, class C>
typename AAMSet<D, C>::Node AAMSet<D, C>::last_d = AAMSet<D, C>::Node();
template<class D, class C>
typename AAMSet<D, C>::NP AAMSet<D, C>::last = &AAMSet<D, C>::last_d;

template<class D, class C = less<D>>
struct MyAAMSet {
    struct Node;
    typedef Node* NP;
    static Node last_d;
    static NP last;
    struct Node {
        NP l, r;
        int level, sz;
        D v;
        D ml[2];
        Node(): l(nullptr), r(nullptr), level(0), sz(0) {
            ml[0] = ml[1] = D(-1, -1);
        }
        Node(D vv): l(last), r(last), level(1), sz(1) {
            v = vv;
            ml[0] = v;
            ml[1] = D(-1, -1);
        }
        /// メモリプールをしたい時のためにnewはラッパする
        static NP make() {
            return new Node();
        }
        static NP make(D vv) {
            return new Node(vv);
        }

        inline void update() {
            sz = 1+l->sz+r->sz;
            vector<D> u;
            if (r->ml[0].second != -1) u.push_back(r->ml[0]);
            if (r->ml[1].second != -1) u.push_back(r->ml[1]);
            u.push_back(v);
            if (l->ml[0].second != -1) u.push_back(l->ml[0]);
            if (l->ml[1].second != -1) u.push_back(l->ml[1]);
            u.erase(unique(u.begin(), u.end(),[](const D &l, const D &r){
                return l.second == r.second;
            }), u.end());
            ml[0] = ml[1] = D(-1, -1);
            if (u.size() >= 1) {
                ml[0] = u[0];
            }
            if (u.size() >= 2) {
                ml[1] = u[1];
            }
        }
        inline void push() {
        }
    } *n;

    static D at(NP n, int k) {
        if (k == n->l->sz) return n->v;
        n->push();
        if (k < n->l->sz) {
            return at(n->l, k);
        } else {
            return at(n->r, k - (n->l->sz+1));
        }
    }
    /// k番目の要素を取得
    D at(int k) {
        return at(n, k);
    }

    /// k番目の要素を取得
    ll get() {
        ll u = n->ml[1].first;
        if (u == -1) return 0;
        return u;
    }
    static int lb(NP n, D x) {
        if (n == last) return 0;
        if (C()(n->v, x)) return n->l->sz + 1 + lb(n->r, x);
        return lb(n->l, x);
    }
    /// lower_bound、ただし返り値はインデックス
    int lb(D v) {
        return lb(n, v);
    }
    static int ub(NP n, D x) {
        if (n == last) return 0;
        if (C()(x, n->v)) return ub(n->l, x);
        return n->l->sz + 1 + ub(n->r, x);
    }
    /// upper_bound、ただし返り値はインデックス
    int ub(D v) {
        return ub(n, v);
    }
    static NP insert(NP n, D x) {
        if (n == last) {
            return Node::make(x);
        }
        n->push();
        if (!C()(n->v, x)) {
            n->l = insert(n->l, x);
            n->update();
        } else {
            n->r = insert(n->r, x);
            n->update();
        }
        n = skew(n);
        n = pull(n);
        return n;
    }
    /// xをinsertする
    void insert(D x) {
        n = insert(n, lb(x), x);
    }
    static NP erase(NP n, D x) {
        assert(n != last);
        n->push();
        if (!C()(n->v, x) && !C()(x, n->v)) {
            if (n->level == 1) {
                return n->r;
            }
            auto x = at0_with_remove(n->r);
            NP nn = x.first;
            nn->push();
            nn->l = n->l;
            nn->r = x.second;
            nn->level = n->level;
            nn->update();
            return rightdown(nn);
        }
        if (C()(x, n->v)) {
            n->l = erase(n->l, x);
            n->update();
            return leftdown(n);
        } else {
            n->r = erase(n->r, x);
            n->update();
            return rightdown(n);
        }
    }
    /// xを削除する
    void erase(D x) {
        n = remove(n, lb(x));
    }

    static void tp(NP n) {
        if (n == last) return;
        n->push();
        tp(n->l);
        cout << n->v << " ";
        tp(n->r);
    }
    void tp() {
        tp(n);
        printf("\n");
    }
    static void allpush(NP n) {
        if (n == last) return;
        n->push();
        allpush(n->l);
        allpush(n->r);
    }
    void allpush() {
        allpush(n);
        return;
    }

    static NP built(int sz, D d[]) {
        if (!sz) return last;
        int md = (sz-1)/2;
        NP n = Node::make(d[md]);
        n->l = built(md, d);
        n->r = built(sz-(md+1), d+(md+1));
        n->level = n->l->level+1;
        n->update();
        return n;
    }
    MyAAMSet() : n(last) {}
    MyAAMSet(NP n) : n(n) {}
    //木の初期化はn回insertより一気に作る方が有意に速くなる事が多い
    MyAAMSet(int sz, D d[]) {
        n = built(sz, d);
    }


    //基本動作
    int sz() {
        return n->sz;
    }
    int size() {
        return sz();
    }
    void merge(MyAAMSet r) {
        n = merge(n, r.n);
    }
    MyAAMSet split(int k) {
        auto y = split(n, k);
        n = y.first;
        return MyAAMSet(y.second);
    }
    void insert(int k, D x) {
        n = insert(n, k, x);
    }
    void remove(int k) {
        n = remove(n, k);
    }

    //AA木の基本動作であるskew/split splitは名前が紛らわしいためpullに変更してある
    static NP skew(NP n) {
        if (n->level == n->l->level) {
            NP L = n->l;
            n->push(); L->push();
            n->l = L->r;
            L->r = n;
            n->update(); L->update();
            return L;
        }
        return n;
    }
    static NP pull(NP n) {
        if (n->level == n->r->level && n->r->level == n->r->r->level) {
            NP R = n->r;
            n->push(); R->push();
            n->r = R->l;
            R->l = n;
            R->level++;
            n->update(); R->update();
            return R;
        }
        return n;
    }

    static NP leftdown(NP n) {
        assert(n->l->level < n->level);
        if (n->l->level == n->level-1) return n;
        n->level--;
        if (n->r->level == n->level) {
            n = pull(n);
        } else {
            n->r->level--;
            n->r = skew(n->r);
            n->r->r = skew(n->r->r);
            n = pull(n);
            n->r = pull(n->r);
        }
        return n;
    }
    static NP rightdown(NP n) {
        assert(n->r->level <= n->level);
        if (n->r->level >= n->level-1) return n;
        n->level--;
        n = skew(n);
        n->r = skew(n->r);
        n = pull(n);
        return n;
    }
    static NP superleftdown(NP n) {
        if (n->l->level == n->level-1) return n;
        if (n->level != n->r->level && n->r->level != n->r->r->level) {
            n->level--;
            return superleftdown(n);
        }
        n = leftdown(n);
        n->l = superleftdown(n->l);
        n = leftdown(n);
        return n;
    }
    static NP superrightdown(NP n) {
        if (n->r->level >= n->level-1) return n;
        n = rightdown(n);
        n->r = superrightdown(n->r);
        n = rightdown(n);
        return n;
    }

    static NP insert(NP n, int k, D x) {
        if (n == last) {
            assert(k == 0);
            return Node::make(x);
        }
        n->push();
        if (k <= n->l->sz) {
            n->l = insert(n->l, k, x);
            n->update();
        } else {
            n->r = insert(n->r, k - (n->l->sz+1), x);
            n->update();
        }
        n = skew(n);
        n = pull(n);
        return n;
    }
    //pair<0番目の要素,0番目の要素を削除した木>
    static pair<NP, NP> at0_with_remove(NP n) {
        n->push();
        if (n->l == last) {
            return {n, n->r};
        }
        auto x = at0_with_remove(n->l);
        n->l = x.second;
        n->update();
        x.second = leftdown(n);
        return x;
    }
    static NP remove(NP n, int k) {
        assert(n != last);
        n->push();
        if (k == n->l->sz) {
            if (n->level == 1) {
                return n->r;
            }
            auto x = at0_with_remove(n->r);
            NP nn = x.first;
            nn->push();
            nn->l = n->l;
            nn->r = x.second;
            nn->level = n->level;
            nn->update();
            return rightdown(nn);
        }
        if (k < n->l->sz) {
            n->l = remove(n->l, k);
            n->update();
            return leftdown(n);
        } else {
            n->r = remove(n->r, k - (n->l->sz+1));
            n->update();
            return rightdown(n);
        }
    }
    static NP merge(NP l, NP r) {
        if (l == last) return r;
        if (r == last) return l;
        if (l->level == r->level) {
            auto x = at0_with_remove(r);
            NP n = x.first;
            n->push();
            n->r = x.second;
            n->l = l;
            n->level = l->level+1;
            n->update();
            return rightdown(n);
        }
        NP n;
        l->push(); r->push();
        if (l->level > r->level) {
            l->push();
            l->r = merge(l->r, r);
            l->update();
            n = l;
        } else {
            r->push();
            r->l = merge(l, r->l);
            r->update();
            n = r;
        }
        n = skew(n);
        n = pull(n);
        return n;
    }
    static pair<NP, NP> split(NP n, int k) {
        if (n == last) return {last, last};
        n->push();
        if (k <= n->l->sz) {
            auto y = split(n->l, k);
            n->l = y.second;
            n->update();
            n = superleftdown(n);
            y.second = n;
            return y;
        } else {
            auto y = split(n->r, k- (n->l->sz+1));
            n->r = y.first;
            n->update();
            n = superrightdown(n);
            y.first = n;
            return y;
        }
    }
};
template<class D, class C>
typename MyAAMSet<D, C>::Node MyAAMSet<D, C>::last_d = MyAAMSet<D, C>::Node();
template<class D, class C>
typename MyAAMSet<D, C>::NP MyAAMSet<D, C>::last = &MyAAMSet<D, C>::last_d;

/**
 * Fenwick Treeと呼ばれる値の変更と区間のsumがO(logN)で行えるデータ構造
 *
 * template引数のint Nは要素数
 *
 * また、一般的なFenwick Treeと違い0-indexedとなるようにオフセットがかかっている
 */
template <int N>
struct FenwickTree {
    using D = ll; ///要素の型
    D seg[N+1];
    
    /// 要素を初期化する
    void init() {
        for (int i = 0; i <= N; i++) {
            seg[i] = 0;
        }
    }

    /// i番目の要素にxを追加する
    void add(int i, D x) {
        i++;
        while (i <= N) {
            seg[i] += x;
            i += i & -i;
        }
    }

    /// [0, i)のsumを求める
    D sum(int i) {
        D s = 0;
        while (i > 0) {
            s += seg[i];
            i -= i & -i;
        }
        return s;
    }

    /// [a, b)のsumを求める
    D sum(int a, int b) {
        return sum(b) - sum(a);
    }
};

/*
範囲addが可能なFenwicktree
すこし拡張されている
initでまず配列を与える
すると、add(l, r, x)で[l, r)それぞれにd[i]*xを足す
つまりdとして1で埋められたものを渡せば範囲addになる
*/
template <int SIZE>
struct FenwickRAdd {
    FenwickTree<SIZE> b0, b1;
    ll ds[SIZE+1];
    void init(const ll d[]) {
        b0.init();
        b1.init();
        ds[0] = 0;
        for (int i = 1; i <= SIZE; i++) {
            ds[i] = d[i-1]+ds[i-1];
        }
    }

    void add(int i, ll x) {
        b0.add(i, x);
    }

    void add(int l, int r, ll x) {
        b1.add(l, x);
        b1.add(r, -x);
        b0.add(l, -ds[l]*x);
        b0.add(r, ds[r]*x);
    }

    //[0, i)
    ll sum(int i) {
        return b0.sum(i)+b1.sum(i)*ds[i];
    }

    //[a, b)
    ll sum(int a, int b) {
        return sum(b) - sum(a);
    }
};

const int MA = 200200;
typedef pair<ll, ll> P;
MyAAMSet<P> ls, rs;
AAMSet<ll> as;
FenwickRAdd<MA> down, up;
FenwickRAdd<MA> dop, upp;
void add(ll x, ll a) {
//    printf("add %lld %lld\n", x, a);
    if (x > 0) {
        rs.insert(P(x, a));
    }
    if (x < 0) {
        ls.insert(P(-x, a));
    }
    as.insert(a);
    up.add(a, MA, 1);
    upp.add(a, MA, -a);
    down.add(0, a, 1);
    dop.add(0, a, a);
}
void del(ll x, ll a) {
//    printf("del %lld %lld\n", x, a);
    if (x > 0) {
        rs.erase(P(x, a));
    }
    if (x < 0) {
        ls.erase(P(-x, a));
    }
    as.erase(a);
    up.add(a, MA, -1);
    upp.add(a, MA, a);
    down.add(0, a, -1);
    dop.add(0, a, -a);
}

const ll INF = 1LL<<62;

ll calc(ll a) {
    ll res = up.sum(a, a+1) + upp.sum(a, a+1) + down.sum(a, a+1) + dop.sum(a, a+1);
    ll ld = 0, rd = 0;
    if (ls.sz() >= 1) {
        if (a == ls.at(ls.sz()-1).second) {
            ld = ls.get();
        } else {
            ld = ls.at(ls.sz()-1).first;
        }
    }
    if (rs.sz() >= 1) {
        if (a == rs.at(rs.sz()-1).second) {
            rd = rs.get();
        } else {
            rd = rs.at(rs.sz()-1).first;
        }
    }
    res += ld + rd + min(ld, rd);
    return res;
}
ll calc2(ll a) {
    ll res = up.sum(a, a+1) + upp.sum(a, a+1) + down.sum(a, a+1) + dop.sum(a, a+1);
//    res += ls.get();
//    res += rs.get();
    return res;
}

ll get() {
//    for (int i = 0; i < 10; i++) {
//        printf("get:%d :%lld %lld\n", i, calc(i), calc2(i));
//    }
    ll res = INF;
    if (as.size() == 0) return 0;
    res = min(res, calc(as.at(as.sz()/2)));
    if (ls.size()) {
        res = min(res, calc(ls.at(ls.sz()-1).second));
    }
    if (rs.size()) {
        res = min(res, calc(rs.at(rs.sz()-1).second));
    }
    return res;
}

int main() {
    ll a[MA+1];
    for (int i = 0; i < MA+1; i++) {
        a[i] = i;
    }
    up.init(a);
    for (int i = 0; i < MA+1; i++) {
        a[i] = -i;
    }
    down.init(a);
    for (int i = 0; i < MA+1; i++) {
        a[i] = 1;
    }
    upp.init(a);
    dop.init(a);
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        ll x, a;
        cin >> x >> a;
        add(x, a);
    }
    int q;
    cin >> q;
    for (int i = 0; i < q; i++) {
        ll c, y, b;
        cin >> c >> y >> b;
        if (c == 1) {
            add(y, b);
        } else {
            del(y, b);
        }
        cout << get() << endl;
    }
    return 0;
}

Submission Info

Submission Time
Task J - 看板の塗り替え
User yosupo
Language C++11 (GCC 4.9.2)
Score 300
Code Size 24529 Byte
Status AC
Exec Time 3603 ms
Memory 46128 KB

Judge Result

Set Name Subtask All
Score / Max Score 30 / 30 270 / 270
Status
AC × 26
AC × 53
Set Name Test Cases
Subtask subtask_00.txt, subtask_01.txt, subtask_02.txt, subtask_03.txt, subtask_04.txt, subtask_05.txt, subtask_06.txt, subtask_07.txt, subtask_08.txt, subtask_09.txt, subtask_10.txt, subtask_11.txt, subtask_12.txt, subtask_13.txt, subtask_14.txt, subtask_15.txt, subtask_16.txt, subtask_17.txt, subtask_18.txt, subtask_19.txt, subtask_20.txt, subtask_21.txt, subtask_22.txt, subtask_23.txt, subtask_24.txt, subtask_25.txt
All scrambled_00.txt, scrambled_01.txt, scrambled_02.txt, scrambled_03.txt, scrambled_04.txt, scrambled_05.txt, scrambled_06.txt, scrambled_07.txt, scrambled_08.txt, scrambled_09.txt, scrambled_10.txt, scrambled_11.txt, scrambled_12.txt, scrambled_13.txt, scrambled_14.txt, scrambled_15.txt, scrambled_16.txt, scrambled_17.txt, scrambled_18.txt, scrambled_19.txt, scrambled_20.txt, scrambled_21.txt, scrambled_22.txt, scrambled_23.txt, scrambled_24.txt, scrambled_25.txt, scrambled_26.txt, subtask_00.txt, subtask_01.txt, subtask_02.txt, subtask_03.txt, subtask_04.txt, subtask_05.txt, subtask_06.txt, subtask_07.txt, subtask_08.txt, subtask_09.txt, subtask_10.txt, subtask_11.txt, subtask_12.txt, subtask_13.txt, subtask_14.txt, subtask_15.txt, subtask_16.txt, subtask_17.txt, subtask_18.txt, subtask_19.txt, subtask_20.txt, subtask_21.txt, subtask_22.txt, subtask_23.txt, subtask_24.txt, subtask_25.txt
Case Name Status Exec Time Memory
scrambled_00.txt AC 60 ms 21024 KB
scrambled_01.txt AC 3603 ms 46128 KB
scrambled_02.txt AC 2220 ms 35812 KB
scrambled_03.txt AC 1575 ms 33560 KB
scrambled_04.txt AC 1042 ms 29220 KB
scrambled_05.txt AC 1293 ms 33824 KB
scrambled_06.txt AC 3052 ms 33568 KB
scrambled_07.txt AC 311 ms 22816 KB
scrambled_08.txt AC 2804 ms 32676 KB
scrambled_09.txt AC 1566 ms 28064 KB
scrambled_10.txt AC 564 ms 26404 KB
scrambled_11.txt AC 2387 ms 39832 KB
scrambled_12.txt AC 1457 ms 35100 KB
scrambled_13.txt AC 567 ms 25508 KB
scrambled_14.txt AC 959 ms 32932 KB
scrambled_15.txt AC 784 ms 27036 KB
scrambled_16.txt AC 3122 ms 39788 KB
scrambled_17.txt AC 1655 ms 31800 KB
scrambled_18.txt AC 677 ms 26148 KB
scrambled_19.txt AC 1584 ms 29164 KB
scrambled_20.txt AC 823 ms 26280 KB
scrambled_21.txt AC 3468 ms 46016 KB
scrambled_22.txt AC 3421 ms 39888 KB
scrambled_23.txt AC 766 ms 25380 KB
scrambled_24.txt AC 2660 ms 35700 KB
scrambled_25.txt AC 1916 ms 31724 KB
scrambled_26.txt AC 1843 ms 28200 KB
subtask_00.txt AC 108 ms 21532 KB
subtask_01.txt AC 104 ms 21536 KB
subtask_02.txt AC 92 ms 21288 KB
subtask_03.txt AC 74 ms 21272 KB
subtask_04.txt AC 87 ms 21340 KB
subtask_05.txt AC 100 ms 21280 KB
subtask_06.txt AC 73 ms 21152 KB
subtask_07.txt AC 102 ms 21280 KB
subtask_08.txt AC 70 ms 21160 KB
subtask_09.txt AC 75 ms 21148 KB
subtask_10.txt AC 103 ms 21412 KB
subtask_11.txt AC 70 ms 21160 KB
subtask_12.txt AC 87 ms 21408 KB
subtask_13.txt AC 69 ms 21156 KB
subtask_14.txt AC 81 ms 21152 KB
subtask_15.txt AC 108 ms 21416 KB
subtask_16.txt AC 91 ms 21416 KB
subtask_17.txt AC 89 ms 21280 KB
subtask_18.txt AC 72 ms 21164 KB
subtask_19.txt AC 101 ms 21416 KB
subtask_20.txt AC 109 ms 21540 KB
subtask_21.txt AC 103 ms 21408 KB
subtask_22.txt AC 84 ms 21284 KB
subtask_23.txt AC 94 ms 21344 KB
subtask_24.txt AC 71 ms 21284 KB
subtask_25.txt AC 85 ms 21272 KB