Submission #1224605
Source Code Expand
/+ dub.sdl:
name "F"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
import std.container.rbtree;
// import dcomp.foundation, dcomp.scanner;
// import dcomp.array;
// import dcomp.algorithm;
// import dcomp.container.deque;
// import dcomp.datastructure.simpleseg;
int n;
int[2][] cards;
int[][] zero, one;
int q;
int[2][] ques;
void solve() {
/* writeln(n, " ", q);
writeln(cards);
writeln(ques);*/
zero = new int[][](n+2);
one = new int[][](n+2);
foreach (i; 0..n) {
zero[cards[i][0]] ~= i;
one[cards[i][1]] ~= i;
}
auto buf = new int[](n+1); buf[] = -1;
auto deq = Deque!int();
bool[] used = new bool[n];
bool[] isOne = new bool[n+1];
auto tr = redBlackTree!(int[2])();
int base = 0;
foreach (i; 0..n+1) {
foreach (d; zero[i]) {
tr.insert([cards[d][1], d].fixed);
}
foreach (d; one[i]) {
deq.insertBack(d);
}
while (deq.length) {
auto u = deq.back; deq.removeBack;
if (used[u]) continue;
used[u] = true;
isOne[i] = true;
buf[i] = u;
base++;
break;
}
if (buf[i] != -1) continue;
while (tr.length) {
auto p = tr.back; tr.removeBack;
int u = p[1];
if (used[u]) continue;
used[u] = true;
buf[i] = u;
break;
}
}
if (buf.count(-1) >= 2) {
foreach (_; ques) {
writeln(-1);
}
return;
}
// writeln(buf);
auto seg = SimpleSeg!(int, max, -(10^^9))(n+1);
foreach_reverse (i; 0..n+1) {
if (buf[i] == -1) {
seg[i] = 0;
continue;
}
auto cd = cards[buf[i]];
if (isOne[i]) {
seg[i] = seg.sum(i+1, n+1);
} else {
seg[i] = max(seg[i], seg.sum(i+1, cd[1]));
seg[i] = max(seg[i], 1+seg.sum(cd[1], n+1));
}
/* foreach (j; i+1..n+1) {
int nx = dp[j];
if (!isOne[i] && cd[1] <= j) nx++;
dp[i] = max(dp[i], nx);
}*/
}
// writeln(dp);
/* foreach (i; 0..n+1) {
seg[i] = dp[i];
}*/
foreach (p; ques) {
int ans = -1;
/* foreach (i; p[0]..p[1]) {
ans = max(ans, dp[i]);
}
foreach (i; p[1]..n+1) {
ans = max(ans, 1+dp[i]);
}*/
ans = max(ans, seg.sum(p[0], p[1]));
ans = max(ans, 1+seg.sum(p[1], n+1));
if (ans == -1) {
writeln(-1);
} else {
writeln(ans+base);
}
}
}
int main() {
auto sc = new Scanner(stdin);
sc.read(n);
int[2][] buf = new int[2][n];
foreach (i; 0..n) {
sc.read(buf[i][0], buf[i][1]);
}
int[] c;
sc.read(c);
c.sort!"a<b";
int getI(int x) {
return binSearch!(i => x <= c[i])(-1, n+1);
}
cards = new int[2][n];
foreach (i; 0..n) {
cards[i][0] = getI(buf[i][0]);
cards[i][1] = getI(buf[i][1]);
cards[i][1] = min(cards[i][0], cards[i][1]);
swap(cards[i][0], cards[i][1]);
}
sc.read(q);
ques = new int[2][q];
foreach (i; 0..q) {
sc.read(ques[i][0], ques[i][1]);
ques[i][0] = getI(ques[i][0]);
ques[i][1] = getI(ques[i][1]);
ques[i][1] = min(ques[i][0], ques[i][1]);
swap(ques[i][0], ques[i][1]);
}
solve();
return 0;
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/algorithm.d */
// module dcomp.algorithm;
import std.range.primitives;
import std.traits : isFloatingPoint, isIntegral;
//[0,0,0,...,1,1,1]で、初めて1となる場所を探す。pred(l) == 0, pred(r) == 1と仮定
T binSearch(alias pred, T)(T l, T r) if (isIntegral!T) {
while (r-l > 1) {
T md = (l+r)/2;
if (!pred(md)) l = md;
else r = md;
}
return r;
}
T binSearch(alias pred, T)(T l, T r, int cnt = 60) if (isFloatingPoint!T) {
foreach (i; 0..cnt) {
T md = (l+r)/2;
if (!pred(md)) l = md;
else r = md;
}
return r;
}
Rotator!Range rotator(Range)(Range r) {
return Rotator!Range(r);
}
struct Rotator(Range)
if (isForwardRange!Range && hasLength!Range) {
size_t cnt;
Range start, now;
this(Range r) {
cnt = 0;
start = r.save;
now = r.save;
}
this(this) {
start = start.save;
now = now.save;
}
@property bool empty() {
return now.empty;
}
@property auto front() {
assert(!now.empty);
import std.range : take, chain;
return chain(now, start.take(cnt));
}
@property Rotator!Range save() {
return this;
}
void popFront() {
cnt++;
now.popFront;
}
}
E minimum(alias pred = "a < b", Range, E = ElementType!Range)(Range range, E seed)
if (isInputRange!Range && !isInfinite!Range) {
import std.algorithm, std.functional;
return reduce!((a, b) => binaryFun!pred(a, b) ? a : b)(seed, range);
}
ElementType!Range minimum(alias pred = "a < b", Range)(Range range) {
assert(!range.empty, "range must not empty");
auto e = range.front; range.popFront;
return minimum!pred(range, e);
}
E maximum(alias pred = "a < b", Range, E = ElementType!Range)(Range range, E seed)
if (isInputRange!Range && !isInfinite!Range) {
import std.algorithm, std.functional;
return reduce!((a, b) => binaryFun!pred(a, b) ? b : a)(seed, range);
}
ElementType!Range maximum(alias pred = "a < b", Range)(Range range) {
assert(!range.empty, "range must not empty");
auto e = range.front; range.popFront;
return maximum!pred(range, e);
}
unittest {
assert(minimum([2, 1, 3]) == 1);
assert(minimum!"a > b"([2, 1, 3]) == 3);
assert(minimum([2, 1, 3], -1) == -1);
assert(minimum!"a > b"([2, 1, 3], 100) == 100);
assert(maximum([2, 1, 3]) == 3);
assert(maximum!"a > b"([2, 1, 3]) == 1);
assert(maximum([2, 1, 3], 100) == 100);
assert(maximum!"a > b"([2, 1, 3], -1) == -1);
}
bool[ElementType!Range] toMap(Range)(Range r) {
import std.algorithm : each;
bool[ElementType!Range] res;
r.each!(a => res[a] = true);
return res;
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/container/deque.d */
// module dcomp.container.deque;
struct Deque(T) {
import core.exception : RangeError;
import core.memory : GC;
import std.range : ElementType, isInputRange;
import std.traits : isImplicitlyConvertible;
struct Payload {
T *d;
size_t st, length, cap;
@property bool empty() const { return length == 0; }
alias opDollar = length;
ref inout(T) opIndex(size_t i) inout {
version(assert) if (length <= i) throw new RangeError();
return d[(st+i >= cap) ? (st+i-cap) : st+i];
}
private void expand() {
import std.algorithm : max;
assert(length == cap);
auto nc = max(size_t(4), 2*cap);
T* nd = cast(T*)GC.malloc(nc * T.sizeof);
foreach (i; 0..length) {
nd[i] = this[i];
}
d = nd; st = 0; cap = nc;
}
void clear() {
st = length = 0;
}
void insertFront(T v) {
if (length == cap) expand();
if (st == 0) st += cap;
st--; length++;
this[0] = v;
}
void insertBack(T v) {
if (length == cap) expand();
length++;
this[length-1] = v;
}
void removeFront() {
assert(!empty, "Deque.removeFront: Deque is empty");
st++; length--;
if (st == cap) st = 0;
}
void removeBack() {
assert(!empty, "Deque.removeBack: Deque is empty");
length--;
}
}
struct RangeT(A) {
alias T = typeof(*(A.p));
alias E = typeof(A.p.d[0]);
T *p;
size_t a, b;
@property bool empty() const { return b <= a; }
@property size_t length() const { return b-a; }
@property RangeT save() { return RangeT(p, a, b); }
@property RangeT!(const A) save() const {
return typeof(return)(p, a, b);
}
alias opDollar = length;
@property ref inout(E) front() inout { return (*p)[a]; }
@property ref inout(E) back() inout { return (*p)[b-1]; }
void popFront() {
version(assert) if (empty) throw new RangeError();
a++;
}
void popBack() {
version(assert) if (empty) throw new RangeError();
b--;
}
ref inout(E) opIndex(size_t i) inout { return (*p)[i]; }
RangeT opSlice() { return this.save; }
RangeT opSlice(size_t i, size_t j) {
version(assert) if (i > j || a + j > b) throw new RangeError();
return typeof(return)(p, a+i, a+j);
}
RangeT!(const A) opSlice() const { return this.save; }
RangeT!(const A) opSlice(size_t i, size_t j) const {
version(assert) if (i > j || a + j > b) throw new RangeError();
return typeof(return)(p, a+i, a+j);
}
}
alias Range = RangeT!Deque;
alias ConstRange = RangeT!(const Deque);
alias ImmutableRange = RangeT!(immutable Deque);
Payload *p;
private void I() { if (!p) p = new Payload(); }
private void C() const {
version(assert) if (!p) throw new RangeError();
}
//some value
this(U)(U[] values...) if (isImplicitlyConvertible!(U, T)) {I;
p = new Payload();
foreach (v; values) {
insertBack(v);
}
}
//range
this(Range)(Range r)
if (isInputRange!Range &&
isImplicitlyConvertible!(ElementType!Range, T) &&
!is(Range == T[])) {I;
p = new Payload();
foreach (v; r) {
insertBack(v);
}
}
@property bool empty() const { return (!p || p.empty); }
@property size_t length() const { return (p ? p.length : 0); }
alias opDollar = length;
ref inout(T) opIndex(size_t i) inout {C; return (*p)[i]; }
ref inout(T) front() inout {C; return (*p)[0]; }
ref inout(T) back() inout {C; return (*p)[$-1]; }
void clear() { if (p) p.clear(); }
void insertFront(T v) {I; p.insertFront(v); }
void insertBack(T v) {I; p.insertBack(v); }
void removeFront() {C; p.removeFront(); }
void removeBack() {C; p.removeBack(); }
Range opSlice() {I; return Range(p, 0, length); }
}
unittest {
import std.algorithm : equal;
import std.range.primitives : isRandomAccessRange;
import std.container.util : make;
auto q = make!(Deque!int);
assert(isRandomAccessRange!(typeof(q[])));
//insert,remove
assert(equal(q[], new int[](0)));
q.insertBack(1);
assert(equal(q[], [1]));
q.insertBack(2);
assert(equal(q[], [1, 2]));
q.insertFront(3);
assert(equal(q[], [3, 1, 2]) && q.front == 3);
q.removeFront;
assert(equal(q[], [1, 2]) && q.length == 2);
q.insertBack(4);
assert(equal(q[], [1, 2, 4]) && q.front == 1 && q.back == 4 && q[$-1] == 4);
q.insertFront(5);
assert(equal(q[], [5, 1, 2, 4]));
//range
assert(equal(q[][1..3], [1, 2]));
assert(equal(q[][][][], q[]));
//const range
const auto rng = q[];
assert(rng.front == 5 && rng.back == 4);
//reference type
auto q2 = q;
q2.insertBack(6);
q2.insertFront(7);
assert(equal(q[], q2[]) && q.length == q2.length);
//construct with make
auto a = make!(Deque!int)(1, 2, 3);
auto b = make!(Deque!int)([1, 2, 3]);
assert(equal(a[], b[]));
}
unittest {
import std.algorithm : equal;
import std.range.primitives : isRandomAccessRange;
import std.container.util : make;
auto q = make!(Deque!int);
q.clear();
assert(equal(q[], new int[0]));
foreach (i; 0..100) {
q.insertBack(1);
q.insertBack(2);
q.insertBack(3);
q.insertBack(4);
q.insertBack(5);
assert(equal(q[], [1,2,3,4,5]));
q.clear();
assert(equal(q[], new int[0]));
}
}
unittest {
Deque!int a;
Deque!int b;
a.insertFront(2);
assert(b.length == 0);
}
unittest {
import std.algorithm : equal;
import std.range : iota;
Deque!int a;
foreach (i; 0..100) {
a.insertBack(i);
}
assert(equal(a[], iota(100)));
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/scanner.d */
// module dcomp.scanner;
class Scanner {
import std.stdio : File;
import std.conv : to;
import std.range : front, popFront, array, ElementType;
import std.array : split;
import std.traits : isSomeChar, isStaticArray, isArray;
import std.algorithm : map;
File f;
this(File f) {
this.f = f;
}
char[512] lineBuf;
char[] line;
private bool succ() {
import std.range.primitives : empty, front, popFront;
import std.ascii : isWhite;
while (true) {
while (!line.empty && line.front.isWhite) {
line.popFront;
}
if (!line.empty) break;
if (f.eof) return false;
line = lineBuf[];
f.readln(line);
}
return true;
}
private bool readSingle(T)(ref T x) {
import std.algorithm : findSplitBefore;
import std.string : strip;
import std.conv : parse;
if (!succ()) return false;
static if (isArray!T) {
alias E = ElementType!T;
static if (isSomeChar!E) {
//string or char[10] etc
//todo optimize
auto r = line.findSplitBefore(" ");
x = r[0].strip.dup;
line = r[1];
} else {
auto buf = line.split.map!(to!E).array;
static if (isStaticArray!T) {
//static
assert(buf.length == T.length);
}
x = buf;
line.length = 0;
}
} else {
x = line.parse!T;
}
return true;
}
int read(T, Args...)(ref T x, auto ref Args args) {
if (!readSingle(x)) return 0;
static if (args.length == 0) {
return 1;
} else {
return 1 + read(args);
}
}
}
unittest {
import std.path : buildPath;
import std.file : tempDir;
import std.algorithm : equal;
import std.stdio : File;
string fileName = buildPath(tempDir, "kyuridenanmaida.txt");
auto fout = File(fileName, "w");
fout.writeln("1 2 3");
fout.writeln("ab cde");
fout.writeln("1.0 1.0 2.0");
fout.close;
Scanner sc = new Scanner(File(fileName, "r"));
int a;
int[2] b;
char[2] c;
string d;
double e;
double[] f;
sc.read(a, b, c, d, e, f);
assert(a == 1);
assert(equal(b[], [2, 3]));
assert(equal(c[], "ab"));
assert(equal(d, "cde"));
assert(e == 1.0);
assert(equal(f, [1.0, 2.0]));
}
unittest {
import std.path : buildPath;
import std.file : tempDir;
import std.algorithm : equal;
import std.stdio : File, writeln;
import std.datetime;
string fileName = buildPath(tempDir, "kyuridenanmaida.txt");
auto fout = File(fileName, "w");
foreach (i; 0..1_000_000) {
fout.writeln(3*i, " ", 3*i+1, " ", 3*i+2);
}
fout.close;
writeln("Scanner Speed Test(3*1,000,000 int)");
StopWatch sw;
sw.start;
Scanner sc = new Scanner(File(fileName, "r"));
foreach (i; 0..500_000) {
int a, b, c;
sc.read(a, b, c);
assert(a == 3*i);
assert(b == 3*i+1);
assert(c == 3*i+2);
}
foreach (i; 500_000..700_000) {
int[3] d;
sc.read(d);
int a = d[0], b = d[1], c = d[2];
assert(a == 3*i);
assert(b == 3*i+1);
assert(c == 3*i+2);
}
foreach (i; 700_000..1_000_000) {
int[] d;
sc.read(d);
assert(d.length == 3);
int a = d[0], b = d[1], c = d[2];
assert(a == 3*i);
assert(b == 3*i+1);
assert(c == 3*i+2);
}
writeln(sw.peek.msecs, "ms");
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/foundation.d */
// module dcomp.foundation;
//fold(for old compiler)
static if (__VERSION__ <= 2070) {
template fold(fun...) if (fun.length >= 1) {
auto fold(R, S...)(R r, S seed) {
import std.algorithm : reduce;
static if (S.length < 2) {
return reduce!fun(seed, r);
} else {
import std.typecons : tuple;
return reduce!fun(tuple(seed), r);
}
}
}
unittest {
import std.stdio;
auto l = [1, 2, 3, 4, 5];
assert(l.fold!"a+b"(10) == 25);
}
}
version (X86) static if (__VERSION__ < 2071) {
int bsf(ulong v) {
foreach (i; 0..64) {
if (v & (1UL << i)) return i;
}
return -1;
}
int bsr(ulong v) {
foreach_reverse (i; 0..64) {
if (v & (1UL << i)) return i;
}
return -1;
}
int popcnt(ulong v) {
int c = 0;
foreach (i; 0..64) {
if (v & (1UL << i)) c++;
}
return c;
}
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/datastructure/simpleseg.d */
// module dcomp.datastructure.simpleseg;
// simpleなsegtree
// a op b op .. op x が求められる、遅延評価なし
// (T, op)はモノイドの必要がある、eはモノイド
struct SimpleSeg(T, alias op, T e) {
const size_t n, sz;
T[] d;
@disable this();
this(size_t n) {
import std.algorithm : fill;
import core.bitop : bsr;
int lg = n.bsr;
if ((2^^lg) < n) lg++;
this.n = n;
this.sz = 2^^lg;
d = new T[](2*this.sz);
d.fill(e);
}
T opIndex(int idx) {return d[idx+sz];}
void opIndexAssign(T v, int idx) {
import std.stdio : writeln;
idx += sz;
d[idx] = v;
while (idx/2 >= 1) {
idx /= 2;
d[idx] = op(d[2*idx], d[2*idx+1]);
}
}
//todo more beautiful?
T sum(size_t a, size_t b, size_t l, size_t r, size_t k) {
if (b <= l || r <= a) return e;
if (a <= l && r <= b) return d[k];
size_t md = (l+r)/2;
return op(sum(a, b, l, md, 2*k),
sum(a, b, md, r, 2*k+1));
}
//[a, b)
T sum(size_t a, size_t b) {
return sum(a, b, 0, sz, 1);
}
//todo formatspec?
string toString() {
import std.conv : to;
return d[sz..sz+n].to!string;
}
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/array.d */
// module dcomp.array;
T[N] fixed(T, int N)(T[N] a) {return a;}
//this is not reference type!(please attention to copy)
struct FastAppender(A) {
import std.algorithm : max;
import std.range.primitives : ElementEncodingType;
import core.stdc.string : memcpy;
private alias T = ElementEncodingType!A;
private T* _data;
private size_t len, cap;
@property size_t length() {return len;}
void reserve(size_t nlen) {
import core.memory : GC;
if (nlen <= cap) return;
void* nx = GC.malloc(nlen * T.sizeof);
cap = nlen;
if (len) memcpy(nx, _data, len * T.sizeof);
_data = cast(T*)(nx);
}
void opOpAssign(string op : "~")(T item) {
if (len == cap) {
reserve(max(4, cap*2));
}
_data[len++] = item;
}
void clear() {
len = 0;
}
T[] data() {
return (_data) ? _data[0..len] : null;
}
}
unittest {
import std.stdio, std.algorithm;
auto u = FastAppender!(int[])();
u ~= 4; u ~= 5;
assert(equal(u.data, [4, 5]));
}
Submission Info
Submission Time |
|
Task |
F - Two Faced Cards |
User |
yosupo |
Language |
D (LDC 0.17.0) |
Score |
2000 |
Code Size |
20695 Byte |
Status |
AC |
Exec Time |
295 ms |
Memory |
21660 KB |
Judge Result
Set Name |
Sample |
All |
Score / Max Score |
0 / 0 |
2000 / 2000 |
Status |
|
|
Set Name |
Test Cases |
Sample |
sample_01.txt, sample_02.txt, sample_03.txt |
All |
sample_01.txt, sample_02.txt, sample_03.txt, sample_01.txt, sample_02.txt, sample_03.txt, subtask_1_01.txt, subtask_1_02.txt, subtask_1_03.txt, subtask_1_04.txt, subtask_1_05.txt, subtask_1_06.txt, subtask_1_07.txt, subtask_1_08.txt, subtask_1_09.txt, subtask_1_10.txt, subtask_1_11.txt, subtask_1_12.txt, subtask_1_13.txt, subtask_1_14.txt, subtask_1_15.txt, subtask_1_16.txt, subtask_1_17.txt, subtask_1_18.txt, subtask_1_19.txt, subtask_1_20.txt, subtask_1_21.txt, subtask_1_22.txt, subtask_1_23.txt, subtask_1_24.txt, subtask_1_25.txt, subtask_1_26.txt, subtask_1_27.txt, subtask_1_28.txt, subtask_1_29.txt, subtask_1_30.txt, subtask_1_31.txt, subtask_1_32.txt, subtask_1_33.txt, subtask_1_34.txt, subtask_1_35.txt, subtask_1_36.txt, subtask_1_37.txt, subtask_1_38.txt, subtask_1_39.txt, subtask_1_40.txt, subtask_1_41.txt, subtask_1_42.txt, subtask_1_43.txt, subtask_1_44.txt, subtask_1_45.txt, subtask_1_46.txt, subtask_1_47.txt, subtask_1_48.txt, subtask_1_49.txt, subtask_1_50.txt, subtask_1_51.txt, subtask_1_52.txt, subtask_1_53.txt, subtask_1_54.txt, subtask_1_55.txt |
Case Name |
Status |
Exec Time |
Memory |
sample_01.txt |
AC |
1 ms |
256 KB |
sample_02.txt |
AC |
1 ms |
256 KB |
sample_03.txt |
AC |
1 ms |
256 KB |
subtask_1_01.txt |
AC |
122 ms |
11220 KB |
subtask_1_02.txt |
AC |
135 ms |
9740 KB |
subtask_1_03.txt |
AC |
65 ms |
6000 KB |
subtask_1_04.txt |
AC |
119 ms |
11652 KB |
subtask_1_05.txt |
AC |
87 ms |
5292 KB |
subtask_1_06.txt |
AC |
205 ms |
12704 KB |
subtask_1_07.txt |
AC |
119 ms |
19996 KB |
subtask_1_08.txt |
AC |
190 ms |
19948 KB |
subtask_1_09.txt |
AC |
177 ms |
14928 KB |
subtask_1_10.txt |
AC |
112 ms |
11244 KB |
subtask_1_11.txt |
AC |
63 ms |
10508 KB |
subtask_1_12.txt |
AC |
97 ms |
10088 KB |
subtask_1_13.txt |
AC |
138 ms |
9664 KB |
subtask_1_14.txt |
AC |
83 ms |
8960 KB |
subtask_1_15.txt |
AC |
83 ms |
11972 KB |
subtask_1_16.txt |
AC |
60 ms |
3284 KB |
subtask_1_17.txt |
AC |
265 ms |
20092 KB |
subtask_1_18.txt |
AC |
67 ms |
8484 KB |
subtask_1_19.txt |
AC |
107 ms |
11836 KB |
subtask_1_20.txt |
AC |
216 ms |
18088 KB |
subtask_1_21.txt |
AC |
295 ms |
20020 KB |
subtask_1_22.txt |
AC |
272 ms |
19636 KB |
subtask_1_23.txt |
AC |
292 ms |
21172 KB |
subtask_1_24.txt |
AC |
273 ms |
20788 KB |
subtask_1_25.txt |
AC |
287 ms |
20660 KB |
subtask_1_26.txt |
AC |
279 ms |
20276 KB |
subtask_1_27.txt |
AC |
159 ms |
20916 KB |
subtask_1_28.txt |
AC |
289 ms |
19896 KB |
subtask_1_29.txt |
AC |
286 ms |
20532 KB |
subtask_1_30.txt |
AC |
286 ms |
21044 KB |
subtask_1_31.txt |
AC |
159 ms |
18100 KB |
subtask_1_32.txt |
AC |
294 ms |
19768 KB |
subtask_1_33.txt |
AC |
289 ms |
20276 KB |
subtask_1_34.txt |
AC |
280 ms |
20276 KB |
subtask_1_35.txt |
AC |
158 ms |
20148 KB |
subtask_1_36.txt |
AC |
289 ms |
21048 KB |
subtask_1_37.txt |
AC |
291 ms |
20276 KB |
subtask_1_38.txt |
AC |
282 ms |
19508 KB |
subtask_1_39.txt |
AC |
160 ms |
17972 KB |
subtask_1_40.txt |
AC |
290 ms |
21432 KB |
subtask_1_41.txt |
AC |
274 ms |
21660 KB |
subtask_1_42.txt |
AC |
272 ms |
19484 KB |
subtask_1_43.txt |
AC |
275 ms |
19484 KB |
subtask_1_44.txt |
AC |
271 ms |
21660 KB |
subtask_1_45.txt |
AC |
168 ms |
17824 KB |
subtask_1_46.txt |
AC |
262 ms |
20872 KB |
subtask_1_47.txt |
AC |
257 ms |
20368 KB |
subtask_1_48.txt |
AC |
256 ms |
18300 KB |
subtask_1_49.txt |
AC |
262 ms |
18072 KB |
subtask_1_50.txt |
AC |
158 ms |
18080 KB |
subtask_1_51.txt |
AC |
1 ms |
256 KB |
subtask_1_52.txt |
AC |
1 ms |
256 KB |
subtask_1_53.txt |
AC |
1 ms |
256 KB |
subtask_1_54.txt |
AC |
1 ms |
256 KB |
subtask_1_55.txt |
AC |
1 ms |
256 KB |