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 |
|
|
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 |