ソースコード 拡げる

Copy
```import java.io.InputStream;
import java.util.Arrays;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;

public class Main {
public static void main(String[] args) throws Exception {
ExtendedScanner sc = new ExtendedScanner();
FastPrintStream pw = new FastPrintStream();
solve(sc, pw);
sc.close();
pw.flush();
pw.close();
}

public static void solve(ExtendedScanner sc, FastPrintStream pw) {
int n = sc.nextInt();
int m = sc.nextInt();
int s = n / 2;
int t = n - n / 2;

boolean[][] edges = new boolean[n][n];
for (int i = 0; i < m; i++) {
int u = sc.nextInt() - 1;
int v = sc.nextInt() - 1;
edges[u][v] = edges[v][u] = true;
}

int[][] bits = new int[1 << t][];
bits[0] = new int[0];

int[] dpt = new int[1 << t];
for (int set = 1; set < 1 << t; set++) {
int bsr = BitUtil.bsr(set);
int pset = set ^ (1 << bsr);
int[] pbits = bits[pset];
int plen = pbits.length;
bits[set] = Arrays.copyOf(pbits, plen + 1);
bits[set][plen] = bsr;

boolean ng = false;
int u = bsr;
for (int v : pbits) ng |= edges[s + u][s + v];
dpt[set] = dpt[pset] + (ng ? 0 : 1);
}

for (int i = 1; i < 1 << t; i <<= 1) {
for (int j = 0; j < 1 << t; j++) {
if ((j & i) == 0) {
dpt[j | i] = Math.max(dpt[j | i], dpt[j]);
}
}
}

boolean[] oks = new boolean[1 << s];
int[] ts = new int[1 << s];
oks[0] = true;
ts[0] = (1 << t) - 1;
for (int set = 1; set < 1 << s; set++) {
int bsr = BitUtil.bsr(set);
int pset = set ^ (1 << bsr);

boolean ok = oks[pset];
int u = bsr;
for (int v : bits[pset]) ok &= !edges[u][v];
if (oks[set] = ok) {
ts[set] = ts[pset];
for (int i = 0; i < t; i++) {
if (edges[u][s + i]) {
ts[set] &= ~(1 << i);
}
}
}
}

int max = 0;
for (int i = 0; i < 1 << s; i++) {
if (!oks[i]) continue;
max = Math.max(max, bits[i].length + dpt[ts[i]]);
}
pw.println(max);
}
}

/**
* @author https://atcoder.jp/users/suisen
*/
class FastScanner implements AutoCloseable {
private final ByteBuffer tokenBuf = new ByteBuffer();
private final java.io.InputStream in;
private final byte[] rawBuf = new byte[1 << 14];
private int ptr = 0;
private int buflen = 0;

public FastScanner(java.io.InputStream in) {
this.in = in;
}

public FastScanner() {
this(new java.io.FileInputStream(java.io.FileDescriptor.in));
}

if (ptr < buflen) return rawBuf[ptr++];
ptr = 0;
try {
if (buflen > 0) {
return rawBuf[ptr++];
} else {
throw new java.io.EOFException();
}
} catch (java.io.IOException e) {
throw new java.io.UncheckedIOException(e);
}
}

if (ptr < buflen) return rawBuf[ptr++];
ptr = 0;
try {
if (buflen > 0) {
return rawBuf[ptr++];
} else {
return -1;
}
} catch (java.io.IOException e) {
throw new java.io.UncheckedIOException(e);
}
}

private final int skipUnprintableChars() {
while (b <= 32 || b >= 127) b = readByte();
return b;
}

tokenBuf.clear();
for (int b = skipUnprintableChars(); 32 < b && b < 127; b = readByteUnsafe()) {
tokenBuf.append(b);
}
}

public final boolean hasNext() {
for (int b = readByteUnsafe(); b <= 32 || b >= 127; b = readByteUnsafe()) {
if (b == -1) return false;
}
--ptr;
return true;
}

public final String next() {
return new String(tokenBuf.getRawBuf(), 0, tokenBuf.size());
}

public final String nextLine() {
tokenBuf.clear();
for (int b = readByte(); b != '\n'; b = readByteUnsafe()) {
if (b == -1) break;
tokenBuf.append(b);
}
return new String(tokenBuf.getRawBuf(), 0, tokenBuf.size());
}

public final char nextChar() {
return (char) skipUnprintableChars();
}

public final char[] nextChars() {
}

public final long nextLong() {
long n = 0;
boolean isNegative = false;
int b = skipUnprintableChars();
if (b == '-') {
isNegative = true;
}
if (b < '0' || '9' < b) throw new NumberFormatException();
while ('0' <= b && b <= '9') {
// -9223372036854775808 - 9223372036854775807
if (n >= 922337203685477580l) {
if (n > 922337203685477580l) {
throw new ArithmeticException("long overflow");
}
if (isNegative) {
if (b >= '9') {
throw new ArithmeticException("long overflow");
}
n = -n - (b + '0');
if ('0' <= b && b <= '9') {
throw new ArithmeticException("long overflow");
} else if (b <= 32 || b >= 127) {
return n;
} else {
throw new NumberFormatException();
}
} else {
if (b >= '8') {
throw new ArithmeticException("long overflow");
}
n = n * 10 + b - '0';
if ('0' <= b && b <= '9') {
throw new ArithmeticException("long overflow");
} else if (b <= 32 || b >= 127) {
return n;
} else {
throw new NumberFormatException();
}
}
}
n = n * 10 + b - '0';
}
if (b <= 32 || b >= 127) return isNegative ? -n : n;
throw new NumberFormatException();
}
public final int nextInt() {
long value = nextLong();
if ((int) value != value) {
throw new ArithmeticException("int overflow");
}
return (int) value;
}
public final double nextDouble() {
return Double.parseDouble(next());
}
public final void close() {
try {
in.close();
} catch (java.io.IOException e) {
throw new java.io.UncheckedIOException(e);
}
}

private static final class ByteBuffer {
private static final int DEFAULT_BUF_SIZE = 1 << 12;
private byte[] buf;
private int ptr = 0;
private ByteBuffer(int capacity) {
this.buf = new byte[capacity];
}
private ByteBuffer() {
this(DEFAULT_BUF_SIZE);
}
private ByteBuffer append(int b) {
if (ptr == buf.length) {
int newLength = buf.length << 1;
byte[] newBuf = new byte[newLength];
System.arraycopy(buf, 0, newBuf, 0, buf.length);
buf = newBuf;
}
buf[ptr++] = (byte) b;
return this;
}
private char[] toCharArray() {
char[] chs = new char[ptr];
for (int i = 0; i < ptr; i++) {
chs[i] = (char) buf[i];
}
return chs;
}
private byte[] getRawBuf() {
return buf;
}
private int size() {
return ptr;
}
private void clear() {
ptr = 0;
}
}
}

/**
* @author https://atcoder.jp/users/suisen
*/
final class ExtendedScanner extends FastScanner {
public ExtendedScanner() {super();}
public ExtendedScanner(InputStream in) {super(in);}
public int[] ints(final int n) {
final int[] a = new int[n];
Arrays.setAll(a, \$ -> nextInt());
return a;
}
public int[] ints(final int n, final IntUnaryOperator f) {
final int[] a = new int[n];
Arrays.setAll(a, \$ -> f.applyAsInt(nextInt()));
return a;
}
public int[][] ints(final int n, final int m) {
final int[][] a = new int[n][];
Arrays.setAll(a, \$ -> ints(m));
return a;
}
public int[][] ints(final int n, final int m, final IntUnaryOperator f) {
final int[][] a = new int[n][];
Arrays.setAll(a, \$ -> ints(m, f));
return a;
}
public long[] longs(final int n) {
final long[] a = new long[n];
Arrays.setAll(a, \$ -> nextLong());
return a;
}
public long[] longs(final int n, final LongUnaryOperator f) {
final long[] a = new long[n];
Arrays.setAll(a, \$ -> f.applyAsLong(nextLong()));
return a;
}
public long[][] longs(final int n, final int m) {
final long[][] a = new long[n][];
Arrays.setAll(a, \$ -> longs(m));
return a;
}
public long[][] longs(final int n, final int m, final LongUnaryOperator f) {
final long[][] a = new long[n][];
Arrays.setAll(a, \$ -> longs(m, f));
return a;
}
public char[][] charArrays(final int n) {
final char[][] c = new char[n][];
Arrays.setAll(c, \$ -> nextChars());
return c;
}
public double[] doubles(final int n) {
final double[] a = new double[n];
Arrays.setAll(a, \$ -> nextDouble());
return a;
}
public double[][] doubles(final int n, final int m) {
final double[][] a = new double[n][];
Arrays.setAll(a, \$ -> doubles(m));
return a;
}
public String[] strings(final int n) {
final String[] s = new String[n];
Arrays.setAll(s, \$ -> next());
return s;
}
}

/**
* @author https://atcoder.jp/users/suisen
*/
class FastPrintStream implements AutoCloseable {
private static final int INT_MAX_LEN = 11;
private static final int LONG_MAX_LEN = 20;

private int precision = 9;

private static final int BUF_SIZE = 1 << 14;
private static final int BUF_SIZE_MINUS_INT_MAX_LEN = BUF_SIZE - INT_MAX_LEN;
private static final int BUF_SIZE_MINUS_LONG_MAX_LEN = BUF_SIZE - LONG_MAX_LEN;
private final byte[] buf = new byte[BUF_SIZE];
private int ptr = 0;
private final java.lang.reflect.Field strField;
private final java.nio.charset.CharsetEncoder encoder;

private final java.io.OutputStream out;

public FastPrintStream(java.io.OutputStream out) {
this.out = out;
java.lang.reflect.Field f;
try {
f = java.lang.String.class.getDeclaredField("value");
f.setAccessible(true);
} catch (NoSuchFieldException | SecurityException e) {
f = null;
}
this.strField = f;
this.encoder = java.nio.charset.StandardCharsets.US_ASCII.newEncoder();
}

public FastPrintStream(java.io.File file) throws java.io.IOException {
this(new java.io.FileOutputStream(file));
}

public FastPrintStream(java.lang.String filename) throws java.io.IOException {
this(new java.io.File(filename));
}

public FastPrintStream() {
this(new java.io.FileOutputStream(java.io.FileDescriptor.out));
}

public FastPrintStream println() {
if (ptr == BUF_SIZE) internalFlush();
buf[ptr++] = (byte) '\n';
return this;
}

public FastPrintStream println(java.lang.Object o) {
return print(o).println();
}

public FastPrintStream println(java.lang.String s) {
return print(s).println();
}

public FastPrintStream println(char[] s) {
return print(s).println();
}

public FastPrintStream println(char c) {
return print(c).println();
}

public FastPrintStream println(int x) {
return print(x).println();
}

public FastPrintStream println(long x) {
return print(x).println();
}

public FastPrintStream println(double d, int precision) {
return print(d, precision).println();
}

public FastPrintStream println(double d) {
return print(d).println();
}

private FastPrintStream print(byte[] bytes) {
int n = bytes.length;
if (ptr + n > BUF_SIZE) {
internalFlush();
try {
out.write(bytes);
} catch (java.io.IOException e) {
throw new java.io.UncheckedIOException(e);
}
} else {
System.arraycopy(bytes, 0, buf, ptr, n);
ptr += n;
}
return this;
}

public FastPrintStream print(java.lang.Object o) {
return print(o.toString());
}

public FastPrintStream print(java.lang.String s) {
if (strField == null) {
return print(s.getBytes());
} else {
try {
Object value = strField.get(s);
if (value instanceof byte[]) {
return print((byte[]) value);
} else {
return print((char[]) value);
}
} catch (IllegalAccessException e) {
return print(s.getBytes());
}
}
}

public FastPrintStream print(char[] s) {
try {
return print(encoder.encode(java.nio.CharBuffer.wrap(s)).array());
} catch (java.nio.charset.CharacterCodingException e) {
byte[] bytes = new byte[s.length];
for (int i = 0; i < s.length; i++) {
bytes[i] = (byte) s[i];
}
return print(bytes);
}
}

public FastPrintStream print(char c) {
if (ptr == BUF_SIZE) internalFlush();
buf[ptr++] = (byte) c;
return this;
}

public FastPrintStream print(int x) {
if (ptr > BUF_SIZE_MINUS_INT_MAX_LEN) internalFlush();
if (-10 < x && x < 10) {
if (x < 0) {
buf[ptr++] = '-';
x = -x;
}
buf[ptr++] = (byte) ('0' + x);
return this;
}
int d;
if (x < 0) {
if (x == Integer.MIN_VALUE) {
buf[ptr++] = '-'; buf[ptr++] = '2'; buf[ptr++] = '1'; buf[ptr++] = '4';
buf[ptr++] = '7'; buf[ptr++] = '4'; buf[ptr++] = '8'; buf[ptr++] = '3';
buf[ptr++] = '6'; buf[ptr++] = '4'; buf[ptr++] = '8';
return this;
}
d = len(x = -x);
buf[ptr++] = '-';
} else {
d = len(x);
}
int j = ptr += d;
while (x > 0) {
buf[--j] = (byte) ('0' + (x % 10));
x /= 10;
}
return this;
}

public FastPrintStream print(long x) {
if ((int) x == x) return print((int) x);
if (ptr > BUF_SIZE_MINUS_LONG_MAX_LEN) internalFlush();
int d;
if (x < 0) {
if (x == Long.MIN_VALUE) {
buf[ptr++] = '-'; buf[ptr++] = '9'; buf[ptr++] = '2'; buf[ptr++] = '2';
buf[ptr++] = '3'; buf[ptr++] = '3'; buf[ptr++] = '7'; buf[ptr++] = '2';
buf[ptr++] = '0'; buf[ptr++] = '3'; buf[ptr++] = '6'; buf[ptr++] = '8';
buf[ptr++] = '5'; buf[ptr++] = '4'; buf[ptr++] = '7'; buf[ptr++] = '7';
buf[ptr++] = '5'; buf[ptr++] = '8'; buf[ptr++] = '0'; buf[ptr++] = '8';
return this;
}
d = len(x = -x);
buf[ptr++] = '-';
} else {
d = len(x);
}
int j = ptr += d;
while (x > 0) {
buf[--j] = (byte) ('0' + (x % 10));
x /= 10;
}
return this;
}

public FastPrintStream print(double d, int precision) {
if (d < 0) {
print('-');
d = -d;
}
d += Math.pow(10, -precision) / 2;
print((long) d).print('.');
d -= (long) d;
for(int i = 0; i < precision; i++){
d *= 10;
print((int) d);
d -= (int) d;
}
return this;
}

public FastPrintStream print(double d) {
return print(d, precision);
}

public void setPrecision(int precision) {
this.precision = precision;
}

private void internalFlush() {
try {
out.write(buf, 0, ptr);
ptr = 0;
} catch (java.io.IOException e) {
throw new java.io.UncheckedIOException(e);
}
}

public void flush() {
try {
out.write(buf, 0, ptr);
out.flush();
ptr = 0;
} catch (java.io.IOException e) {
throw new java.io.UncheckedIOException(e);
}
}

public void close() {
try {
out.close();
} catch (java.io.IOException e) {
throw new java.io.UncheckedIOException(e);
}
}

private static int len(int x) {
return
x >= 1000000000 ? 10 :
x >= 100000000  ?  9 :
x >= 10000000   ?  8 :
x >= 1000000    ?  7 :
x >= 100000     ?  6 :
x >= 10000      ?  5 :
x >= 1000       ?  4 :
x >= 100        ?  3 :
x >= 10         ?  2 : 1;
}

private static int len(long x) {
return
x >= 1000000000000000000l ? 19 :
x >= 100000000000000000l  ? 18 :
x >= 10000000000000000l   ? 17 :
x >= 1000000000000000l    ? 16 :
x >= 100000000000000l     ? 15 :
x >= 10000000000000l      ? 14 :
x >= 1000000000000l       ? 13 :
x >= 100000000000l        ? 12 :
x >= 10000000000l         ? 11 : 10;
}
}

/**
* @author https://atcoder.jp/users/suisen
*/
final class BitUtil {
private static final int[] INT_MASK = {
0x0000_0000,
0x0000_0001, 0x0000_0003, 0x0000_0007, 0x0000_000f,
0x0000_001f, 0x0000_003f, 0x0000_007f, 0x0000_00ff,
0x0000_01ff, 0x0000_03ff, 0x0000_07ff, 0x0000_0fff,
0x0000_1fff, 0x0000_3fff, 0x0000_7fff, 0x0000_ffff,
0x0001_ffff, 0x0003_ffff, 0x0007_ffff, 0x000f_ffff,
0x001f_ffff, 0x003f_ffff, 0x007f_ffff, 0x00ff_ffff,
0x01ff_ffff, 0x03ff_ffff, 0x07ff_ffff, 0x0fff_ffff,
0x1fff_ffff, 0x3fff_ffff, 0x7fff_ffff, 0xffff_ffff
};
private static final long[] LONG_MASK = {
0x0000_0000_0000_0000l,
0x0000_0000_0000_0001l, 0x0000_0000_0000_0003l, 0x0000_0000_0000_0007l, 0x0000_0000_0000_000fl,
0x0000_0000_0000_001fl, 0x0000_0000_0000_003fl, 0x0000_0000_0000_007fl, 0x0000_0000_0000_00ffl,
0x0000_0000_0000_01ffl, 0x0000_0000_0000_03ffl, 0x0000_0000_0000_07ffl, 0x0000_0000_0000_0fffl,
0x0000_0000_0000_1fffl, 0x0000_0000_0000_3fffl, 0x0000_0000_0000_7fffl, 0x0000_0000_0000_ffffl,
0x0000_0000_0001_ffffl, 0x0000_0000_0003_ffffl, 0x0000_0000_0007_ffffl, 0x0000_0000_000f_ffffl,
0x0000_0000_001f_ffffl, 0x0000_0000_003f_ffffl, 0x0000_0000_007f_ffffl, 0x0000_0000_00ff_ffffl,
0x0000_0000_01ff_ffffl, 0x0000_0000_03ff_ffffl, 0x0000_0000_07ff_ffffl, 0x0000_0000_0fff_ffffl,
0x0000_0000_1fff_ffffl, 0x0000_0000_3fff_ffffl, 0x0000_0000_7fff_ffffl, 0x0000_0000_ffff_ffffl,
0x0000_0001_ffff_ffffl, 0x0000_0003_ffff_ffffl, 0x0000_0007_ffff_ffffl, 0x0000_000f_ffff_ffffl,
0x0000_001f_ffff_ffffl, 0x0000_003f_ffff_ffffl, 0x0000_007f_ffff_ffffl, 0x0000_00ff_ffff_ffffl,
0x0000_01ff_ffff_ffffl, 0x0000_03ff_ffff_ffffl, 0x0000_07ff_ffff_ffffl, 0x0000_0fff_ffff_ffffl,
0x0000_1fff_ffff_ffffl, 0x0000_3fff_ffff_ffffl, 0x0000_7fff_ffff_ffffl, 0x0000_ffff_ffff_ffffl,
0x0001_ffff_ffff_ffffl, 0x0003_ffff_ffff_ffffl, 0x0007_ffff_ffff_ffffl, 0x000f_ffff_ffff_ffffl,
0x001f_ffff_ffff_ffffl, 0x003f_ffff_ffff_ffffl, 0x007f_ffff_ffff_ffffl, 0x00ff_ffff_ffff_ffffl,
0x01ff_ffff_ffff_ffffl, 0x03ff_ffff_ffff_ffffl, 0x07ff_ffff_ffff_ffffl, 0x0fff_ffff_ffff_ffffl,
0x1fff_ffff_ffff_ffffl, 0x3fff_ffff_ffff_ffffl, 0x7fff_ffff_ffff_ffffl, 0xffff_ffff_ffff_ffffl
};
private BitUtil(){}
public static boolean test (long n, int bit) {return (n & (1l << bit)) != 0;}
public static boolean test (int  n, int bit) {return (n & (1  << bit)) != 0;}

public static int     get  (long n, int bit) {return (n & (1l << bit)) == 0 ? 1 : 0;}
public static int     get  (int  n, int bit) {return (n & (1  << bit)) == 0 ? 1 : 0;}

public static long    set  (long n, int bit)             {return n | (1l << bit);}
public static int     set  (int  n, int bit)             {return n | (1  << bit);}
public static long    set  (long n, int from, int to)    {return n | (LONG_MASK[to - from] << from);}
public static int     set  (int  n, int from, int to)    {return n | (INT_MASK [to - from] << from);}
public static long    set  (long n, int bit,  boolean b) {return b ? n | (1l << bit) : n & ~(1l << bit);}
public static int     set  (int  n, int bit,  boolean b) {return b ? n | (1  << bit) : n & ~(1  << bit);}
public static long    set  (long n, int from, int to, boolean b) {return b ? n | (LONG_MASK[to - from] << from) : n & ~(LONG_MASK[to - from] << from);}
public static int     set  (int  n, int from, int to, boolean b) {return b ? n | (INT_MASK [to - from] << from) : n & ~(INT_MASK [to - from] << from);}

public static long    clear(long n, int bit)          {return n & ~(1l << bit);}
public static int     clear(int  n, int bit)          {return n & ~(1  << bit);}
public static long    clear(long n, int from, int to) {return n & ~(LONG_MASK[to - from] << from);}
public static int     clear(int  n, int from, int to) {return n & ~(INT_MASK [to - from] << from);}

public static long    flip (long n, int bit)          {return n ^ (1l << bit);}
public static int     flip (int  n, int bit)          {return n ^ (1  << bit);}
public static long    flip (long n, int from, int to) {return n ^ (LONG_MASK[to - from] << from);}
public static int     flip (int  n, int from, int to) {return n ^ (INT_MASK [to - from] << from);}

public static long    mask (long n, int bit)          {return n & (1l << bit);}
public static int     mask (int  n, int bit)          {return n & (1  << bit);}
public static long    mask (long n, int from, int to) {return n & (LONG_MASK[to - from] << from);}
public static int     mask (int  n, int from, int to) {return n & (INT_MASK [to - from] << from);}

public static int     bsr  (long n) {return 63 - Long   .numberOfLeadingZeros(n);}
public static int     bsr  (int  n) {return 31 - Integer.numberOfLeadingZeros(n);}

public static int[] toArray(int length, int bits) {
int[] res = new int[length];
for (int i = 0; i < length; i++) {
res[i] = (bits >> i) & 1;
}
return res;
}

public static int[] toArray(int length, long bits) {
int[] res = new int[length];
for (int i = 0; i < length; i++) {
res[i] = (int) ((bits >> i) & 1);
}
return res;
}
}
```

#### 提出情報

提出日時 2020-11-17 18:43:30+0900 G - Mixture Drug suisen Java (OpenJDK 11.0.6) 600 24744 Byte AC 361 ms 109988 KB

#### ジャッジ結果

セット名 Sample All

 AC × 3
 AC × 51
セット名 テストケース
Sample sample_01.txt, sample_02.txt, sample_03.txt
ケース名 結果 実行時間 メモリ
sample_01.txt AC 81 ms 33928 KB
sample_02.txt AC 82 ms 33900 KB
sample_03.txt AC 85 ms 34072 KB
subtask_1_1.txt AC 74 ms 33736 KB
subtask_1_10.txt AC 361 ms 109644 KB
subtask_1_11.txt AC 84 ms 33988 KB
subtask_1_12.txt AC 323 ms 109752 KB
subtask_1_13.txt AC 309 ms 107176 KB
subtask_1_14.txt AC 333 ms 109644 KB
subtask_1_15.txt AC 84 ms 33928 KB
subtask_1_16.txt AC 356 ms 109656 KB
subtask_1_17.txt AC 340 ms 109572 KB
subtask_1_18.txt AC 327 ms 109396 KB
subtask_1_19.txt AC 94 ms 34816 KB
subtask_1_2.txt AC 340 ms 109580 KB
subtask_1_20.txt AC 334 ms 109652 KB
subtask_1_21.txt AC 326 ms 109600 KB
subtask_1_22.txt AC 323 ms 109664 KB
subtask_1_23.txt AC 82 ms 33912 KB
subtask_1_24.txt AC 149 ms 39408 KB
subtask_1_25.txt AC 321 ms 109620 KB
subtask_1_26.txt AC 357 ms 109988 KB
subtask_1_27.txt AC 329 ms 109372 KB
subtask_1_28.txt AC 345 ms 109444 KB
subtask_1_29.txt AC 327 ms 109752 KB
subtask_1_3.txt AC 208 ms 67232 KB
subtask_1_30.txt AC 85 ms 34068 KB
subtask_1_31.txt AC 86 ms 34132 KB
subtask_1_32.txt AC 96 ms 34756 KB
subtask_1_33.txt AC 115 ms 39052 KB
subtask_1_34.txt AC 351 ms 109592 KB
subtask_1_35.txt AC 328 ms 109752 KB
subtask_1_36.txt AC 328 ms 109744 KB
subtask_1_37.txt AC 343 ms 109544 KB
subtask_1_38.txt AC 343 ms 109868 KB
subtask_1_39.txt AC 359 ms 109744 KB
subtask_1_4.txt AC 339 ms 109648 KB
subtask_1_40.txt AC 330 ms 109484 KB
subtask_1_41.txt AC 343 ms 109568 KB
subtask_1_42.txt AC 320 ms 109832 KB
subtask_1_43.txt AC 330 ms 109888 KB
subtask_1_44.txt AC 328 ms 109520 KB
subtask_1_45.txt AC 328 ms 109720 KB
subtask_1_46.txt AC 329 ms 109724 KB
subtask_1_47.txt AC 346 ms 109980 KB
subtask_1_48.txt AC 333 ms 109624 KB
subtask_1_5.txt AC 211 ms 67416 KB
subtask_1_6.txt AC 317 ms 109488 KB
subtask_1_7.txt AC 258 ms 85268 KB
subtask_1_8.txt AC 330 ms 109724 KB
subtask_1_9.txt AC 255 ms 85224 KB