oj.uz

Submission #339282

# Submission time Handle Problem Language Result Execution time Memory
339282 2020-12-25T03:15:44 Z 12tqian Genetics (BOI18_genetics) C++17
100 / 100
 977 ms 36372 KB 
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <iomanip>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;
template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

typedef long long ll;
typedef long double ld;
typedef double db;
typedef string str;

typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<db, db> pd;

typedef vector<int> vi;
typedef vector<bool> vb;
typedef vector<ll> vl;
typedef vector<db> vd;
typedef vector<str> vs;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<pd> vpd;

#define mp make_pair
#define f first
#define s second
#define sz(x) (int) (x).size()
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define sor(x) sort(all(x))
#define rsz resize
#define resz resize
#define ins insert
#define ft front()
#define bk back()
#define pf push_front
#define pb push_back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound

#define f1r(i, a, b) for (int i = (a); i < (b); ++i)
#define f0r(i, a) f1r(i, 0, a)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define F0R(i, a) FOR(i,0,a)
#define ROF(i, a, b) for (int i = (b) - 1; i >= (a); --i)
#define R0F(i, a) ROF(i, 0, a)
#define trav(a, x) for (auto& a : x)

mt19937 rng((uint32_t) chrono::steady_clock::now().time_since_epoch().count());

template<class T> bool ckmin(T& a, const T& b) { return b < a ? a = b, 1 : 0; }
template<class T> bool ckmax(T& a, const T& b) { return a < b ? a = b, 1 : 0; }
template<class T> using V = vector<T>;

#ifdef LOCAL
#define dbg(...) debug(#__VA_ARGS__, __VA_ARGS__);
#else
#define dbg(...) 17;
#endif

template<typename T, typename S> ostream& operator << (ostream &os, const pair<T, S> &p) { return os << "(" << p.first << ", " << p.second << ")"; }
template<typename C, typename T = decay<decltype(*begin(declval<C>()))>, typename enable_if<!is_same<C, string>::value>::type* = nullptr>
ostream& operator << (ostream &os, const C &c) { bool f = true; os << "{"; for (const auto &x : c) { if (!f) os << ", "; f = false; os << x; } return os << "}"; }
template<typename T> void debug(string s, T x) { cerr << s << " = " << x << "\n"; }
template<typename T, typename... Args> void debug(string s, T x, Args... args) { cerr << s.substr(0, s.find(',')) << " = " << x << " | "; debug(s.substr(s.find(',') + 2), args...); }

constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 31 - __builtin_clz(x); } // floor(log2(x))

namespace input {
    template<class T> void re(complex<T>& x);
    template<class T1, class T2> void re(pair<T1, T2>& p);
    template<class T> void re(vector<T>& a);
    template<class T, int SZ> void re(array<T, SZ>& a);
    template<class T> void re(T& x) { cin >> x; }
    void re(double& x) { string t; re(t); x = stod(t); }
    void re(ld& x) { string t; re(t); x = stold(t); }
    template<class T, class... Ts> void re(T& t, Ts&... ts) {
        re(t); re(ts...); }
    template<class T> void re(complex<T>& x) { T a, b; re(a, b); x = cd(a, b); }
    template<class T1, class T2> void re(pair<T1, T2>& p) { re(p.f, p.s); }
    template<class T> void re(vector<T>& a) { F0R(i, sz(a)) re(a[i]); }
    template<class T, int SZ> void re(array<T, SZ>& a) { F0R(i, SZ) re(a[i]); }
}

using namespace input;

namespace output {
    void pr(int x) { cout << x; }
    void pr(long x) { cout << x; }
    void pr(ll x) { cout << x; }
    void pr(unsigned x) { cout << x; }
    void pr(unsigned long x) { cout << x; }
    void pr(unsigned long long x) { cout << x; }
    void pr(float x) { cout << x; }
    void pr(double x) { cout << x; }
    void pr(ld x) { cout << x; }
    void pr(char x) { cout << x; }
    void pr(const char* x) { cout << x; }
    void pr(const string& x) { cout << x; }
    void pr(bool x) { pr(x ? "true" : "false"); }
    template<class T> void pr(const complex<T>& x) { cout << x; }
    template<class T1, class T2> void pr(const pair<T1, T2>& x);
    template<class T> void pr(const T& x);
    template<class T, class... Ts> void pr(const T& t, const Ts&... ts) {
        pr(t); pr(ts...); }
    template<class T1, class T2> void pr(const pair<T1,T2>& x) {
        pr("{", x.f, ", ", x.s, "}"); }
    template<class T> void pr(const T& x) {
        pr("{"); // const iterator needed for vector<bool>
        bool fst = 1; for (const auto& a: x) pr(!fst ? ", " : "", a), fst = 0;
        pr("}"); }
    void ps() { pr("\n"); } // print w/ spaces
    template<class T, class... Ts> void ps(const T& t, const Ts&... ts) {
        pr(t); if (sizeof...(ts)) pr(" "); ps(ts...); }
    void pc() { pr("]\n"); } // debug w/ commas
    template<class T, class... Ts> void pc(const T& t, const Ts&... ts) {
        pr(t); if (sizeof...(ts)) pr(", "); pc(ts...); }
}

using namespace output;

namespace io {
    void setIn(string s) { freopen(s.c_str(), "r", stdin); }
    void setOut(string s) { freopen(s.c_str(), "w", stdout); }
    void setIO(string s = "") {
        cin.sync_with_stdio(0); cin.tie(0);
        if (sz(s)) { setIn(s + ".in"), setOut(s + ".out"); }
    }
}

using namespace io;

// const int MOD = 1e9 + 7; // 998244353;
// const ld PI = acos((ld) -1);

// typedef std::decay <decltype(MOD)>::type mod_t;
// struct mi {
//     mod_t val;
//     explicit operator mod_t() const { return val; }
//     mi() { val = 0; }
//     mi(const long long& v) {
//         val = (-MOD <= v && v <= MOD) ? v : v % MOD;
//         if (val < 0) val += MOD; }
//     friend std::istream& operator >> (std::istream& in, mi& a) { 
//         long long x; std::cin >> x; a = mi(x); return in; }
//     friend std::ostream& operator << (std::ostream& os, const mi& a) { return os << a.val; }
//     friend void pr(const mi& a) { pr(a.val); }
//     friend void re(mi& a) { long long x; cin >> x; a = mi(x); }
//     friend bool operator == (const mi& a, const mi& b) { return a.val == b.val; }
//     friend bool operator != (const mi& a, const mi& b) { return !(a == b); }    
//     friend bool operator < (const mi& a, const mi& b) { return a.val < b.val; }
//     friend bool operator > (const mi& a, const mi& b) { return a.val > b.val; }
//     friend bool operator <= (const mi& a, const mi& b) { return a.val <= b.val; }
//     friend bool operator >= (const mi& a, const mi& b) { return a.val >= b.val; }
//     mi operator - () const { return mi(-val); }
//     mi& operator += (const mi& m) {
//         if ((val += m.val) >= MOD) val -= MOD;
//         return *this; }
//     mi& operator -= (const mi& m) {
//         if ((val -= m.val) < 0) val += MOD;
//         return *this; }
//     mi& operator *= (const mi& m) { val = (long long) val * m.val % MOD;
//         return *this; }
//     friend mi pow(mi a, long long p) {
//         mi ans = 1; assert(p >= 0);
//         for (; p; p /= 2, a *= a) if (p & 1) ans *= a;
//         return ans; }
//     friend mi inv(const mi& a) { assert(a != 0); return pow(a, MOD - 2); }
//     mi& operator /= (const mi& m) { return (*this) *= inv(m); }
//     friend mi operator + (mi a, const mi& b) { return a += b; }
//     friend mi operator - (mi a, const mi& b) { return a -= b; }
//     friend mi operator * (mi a, const mi& b) { return a *= b; }
//     friend mi operator / (mi a, const mi& b) { return a /= b; }
// };
// typedef pair<mi, mi> pmi;
// typedef vector<mi> vmi;
// typedef vector<pmi> vpmi;
const int MOD = 1000000007;
const ll INF = 1e18;
const int MX = 100001;
 
ll po (ll b, ll p) { return !p?1:po(b*b%MOD,p/2)*(p&1?b:1)%MOD; }
ll inv (ll b) { return po(b,MOD-2); }
 
int ad(int a, int b) { return (a+b)%MOD; }
int sub(int a, int b) { return (a-b+MOD)%MOD; }
int mul(int a, int b) { return (ll)a*b%MOD; }
 
pi operator+(const pi& l, const pi& r) { return {ad(l.f,r.f),ad(l.s,r.s)}; }
pi operator-(const pi& l, const pi& r) { return {sub(l.f,r.f),sub(l.s,r.s)}; }
pi operator*(const pi& l, const pi& r) { return {mul(l.f,r.f),mul(l.s,r.s)}; }
pi operator*(const pi& l, const int& r) { return l*pi(r,r); }
pi operator*(const int& r, const pi& l) { return l*r; }
 
pi operator+=(pi& l, const pi& r) { return l = l+r; }
pi operator-=(pi& l, const pi& r) { return l = l-r; }
template<class T> pi operator*=(pi& l, const T& r) { return l = l*r; }
 
std::ostream& operator<<(std::ostream &strm, const pi& a) {
    strm << a.f << " " << a.s << " | ";
    return strm;
}
const int N = 4100;
string s[N];
pi hsh[N], ans[N], sum;
int main() {
    setIO("");
    int n, m, k; re(n, m, k);
    f0r(i, n) {
        re(s[i]);
        hsh[i] = {rng()%MOD, rng()%MOD};
        sum += hsh[i];
    }
    auto get = [](char c) -> int {
        if (c == 'A') return 0;
        if (c == 'C') return 1;
        if (c == 'G') return 2;
        return 3;
    };
    f0r(i, m) {
        array<pi, 4> use;
        f0r(j, n) {
            use[get(s[j][i])] += hsh[j];
        }
        f0r(j, n) {
            // sum the hashes that are different
            ans[j] += (sum-use[get(s[j][i])]);
        }
    }
    f0r(i, n) {
        // each of them occur exactly k times
        if (ans[i] == k*(sum-hsh[i])) {
            ps(i+1);
            return 0;
        }
    }
    return 0;
}

Compilation message

genetics.cpp: In function 'void io::setIn(std::string)':
genetics.cpp:153:35: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)', declared with attribute warn_unused_result [-Wunused-result]
  153 |     void setIn(string s) { freopen(s.c_str(), "r", stdin); }
      |                            ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~
genetics.cpp: In function 'void io::setOut(std::string)':
genetics.cpp:154:36: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)', declared with attribute warn_unused_result [-Wunused-result]
  154 |     void setOut(string s) { freopen(s.c_str(), "w", stdout); }
      |                             ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~

Subtask #1
27.0 / 27.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 492 KB Output is correct
2 Correct 1 ms 492 KB Output is correct
3 Correct 1 ms 492 KB Output is correct
4 Correct 1 ms 492 KB Output is correct
5 Correct 1 ms 492 KB Output is correct
6 Correct 1 ms 492 KB Output is correct
7 Correct 1 ms 492 KB Output is correct
8 Correct 1 ms 492 KB Output is correct
9 Correct 1 ms 492 KB Output is correct
10 Correct 1 ms 492 KB Output is correct
11 Correct 1 ms 492 KB Output is correct
12 Correct 1 ms 492 KB Output is correct
13 Correct 1 ms 492 KB Output is correct
14 Correct 1 ms 492 KB Output is correct
15 Correct 1 ms 492 KB Output is correct
16 Correct 1 ms 512 KB Output is correct
17 Correct 1 ms 492 KB Output is correct

Subtask #2
19.0 / 19.0

# Verdict Execution time Memory Grader output
1 Correct 62 ms 5888 KB Output is correct
2 Correct 56 ms 7148 KB Output is correct
3 Correct 71 ms 6784 KB Output is correct
4 Correct 17 ms 1900 KB Output is correct
5 Correct 66 ms 7148 KB Output is correct
6 Correct 68 ms 7172 KB Output is correct
7 Correct 30 ms 3308 KB Output is correct
8 Correct 26 ms 3308 KB Output is correct
9 Correct 69 ms 6636 KB Output is correct
10 Correct 69 ms 6636 KB Output is correct
11 Correct 62 ms 5868 KB Output is correct
12 Correct 61 ms 5868 KB Output is correct
13 Correct 60 ms 5868 KB Output is correct
14 Correct 51 ms 5100 KB Output is correct
15 Correct 53 ms 5100 KB Output is correct
16 Correct 53 ms 5100 KB Output is correct
17 Correct 76 ms 6892 KB Output is correct
18 Correct 71 ms 6764 KB Output is correct
19 Correct 71 ms 6892 KB Output is correct
20 Correct 70 ms 6764 KB Output is correct
21 Correct 74 ms 6764 KB Output is correct
22 Correct 71 ms 6764 KB Output is correct
23 Correct 74 ms 6764 KB Output is correct
24 Correct 70 ms 6764 KB Output is correct
25 Correct 70 ms 6764 KB Output is correct
26 Correct 74 ms 6892 KB Output is correct
27 Correct 70 ms 6764 KB Output is correct
28 Correct 87 ms 6820 KB Output is correct
29 Correct 71 ms 6764 KB Output is correct
30 Correct 71 ms 7148 KB Output is correct
31 Correct 55 ms 7020 KB Output is correct
32 Correct 76 ms 7148 KB Output is correct
33 Correct 1 ms 492 KB Output is correct
34 Correct 1 ms 492 KB Output is correct
35 Correct 1 ms 492 KB Output is correct

Subtask #3
28.0 / 28.0

# Verdict Execution time Memory Grader output
1 Correct 62 ms 5888 KB Output is correct
2 Correct 56 ms 7148 KB Output is correct
3 Correct 71 ms 6784 KB Output is correct
4 Correct 17 ms 1900 KB Output is correct
5 Correct 66 ms 7148 KB Output is correct
6 Correct 68 ms 7172 KB Output is correct
7 Correct 30 ms 3308 KB Output is correct
8 Correct 26 ms 3308 KB Output is correct
9 Correct 69 ms 6636 KB Output is correct
10 Correct 69 ms 6636 KB Output is correct
11 Correct 62 ms 5868 KB Output is correct
12 Correct 61 ms 5868 KB Output is correct
13 Correct 60 ms 5868 KB Output is correct
14 Correct 51 ms 5100 KB Output is correct
15 Correct 53 ms 5100 KB Output is correct
16 Correct 53 ms 5100 KB Output is correct
17 Correct 76 ms 6892 KB Output is correct
18 Correct 71 ms 6764 KB Output is correct
19 Correct 71 ms 6892 KB Output is correct
20 Correct 70 ms 6764 KB Output is correct
21 Correct 74 ms 6764 KB Output is correct
22 Correct 71 ms 6764 KB Output is correct
23 Correct 74 ms 6764 KB Output is correct
24 Correct 70 ms 6764 KB Output is correct
25 Correct 70 ms 6764 KB Output is correct
26 Correct 74 ms 6892 KB Output is correct
27 Correct 70 ms 6764 KB Output is correct
28 Correct 87 ms 6820 KB Output is correct
29 Correct 71 ms 6764 KB Output is correct
30 Correct 71 ms 7148 KB Output is correct
31 Correct 55 ms 7020 KB Output is correct
32 Correct 76 ms 7148 KB Output is correct
33 Correct 1 ms 492 KB Output is correct
34 Correct 1 ms 492 KB Output is correct
35 Correct 1 ms 492 KB Output is correct
36 Correct 556 ms 31980 KB Output is correct
37 Correct 513 ms 35820 KB Output is correct
38 Correct 646 ms 35564 KB Output is correct
39 Correct 162 ms 12648 KB Output is correct
40 Correct 561 ms 35820 KB Output is correct
41 Correct 290 ms 18156 KB Output is correct
42 Correct 247 ms 18156 KB Output is correct
43 Correct 396 ms 25188 KB Output is correct
44 Correct 691 ms 36216 KB Output is correct
45 Correct 672 ms 36312 KB Output is correct
46 Correct 672 ms 36372 KB Output is correct
47 Correct 584 ms 31980 KB Output is correct
48 Correct 573 ms 31980 KB Output is correct
49 Correct 470 ms 27244 KB Output is correct
50 Correct 482 ms 27280 KB Output is correct
51 Correct 541 ms 30200 KB Output is correct
52 Correct 668 ms 35440 KB Output is correct
53 Correct 678 ms 35468 KB Output is correct
54 Correct 507 ms 33912 KB Output is correct
55 Correct 507 ms 34000 KB Output is correct
56 Correct 548 ms 33948 KB Output is correct
57 Correct 671 ms 35552 KB Output is correct
58 Correct 669 ms 35648 KB Output is correct
59 Correct 666 ms 35444 KB Output is correct
60 Correct 675 ms 35456 KB Output is correct
61 Correct 667 ms 35308 KB Output is correct
62 Correct 671 ms 35276 KB Output is correct
63 Correct 673 ms 35528 KB Output is correct
64 Correct 660 ms 35444 KB Output is correct
65 Correct 671 ms 35568 KB Output is correct
66 Correct 667 ms 35540 KB Output is correct
67 Correct 665 ms 35636 KB Output is correct
68 Correct 676 ms 35508 KB Output is correct
69 Correct 678 ms 35504 KB Output is correct
70 Correct 666 ms 35528 KB Output is correct
71 Correct 657 ms 35364 KB Output is correct
72 Correct 677 ms 35556 KB Output is correct
73 Correct 666 ms 35408 KB Output is correct
74 Correct 1 ms 492 KB Output is correct
75 Correct 1 ms 492 KB Output is correct
76 Correct 1 ms 492 KB Output is correct

Subtask #4
26.0 / 26.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 492 KB Output is correct
2 Correct 1 ms 492 KB Output is correct
3 Correct 1 ms 492 KB Output is correct
4 Correct 1 ms 492 KB Output is correct
5 Correct 1 ms 492 KB Output is correct
6 Correct 1 ms 492 KB Output is correct
7 Correct 1 ms 492 KB Output is correct
8 Correct 1 ms 492 KB Output is correct
9 Correct 1 ms 492 KB Output is correct
10 Correct 1 ms 492 KB Output is correct
11 Correct 1 ms 492 KB Output is correct
12 Correct 1 ms 492 KB Output is correct
13 Correct 1 ms 492 KB Output is correct
14 Correct 1 ms 492 KB Output is correct
15 Correct 1 ms 492 KB Output is correct
16 Correct 1 ms 512 KB Output is correct
17 Correct 1 ms 492 KB Output is correct
18 Correct 62 ms 5888 KB Output is correct
19 Correct 56 ms 7148 KB Output is correct
20 Correct 71 ms 6784 KB Output is correct
21 Correct 17 ms 1900 KB Output is correct
22 Correct 66 ms 7148 KB Output is correct
23 Correct 68 ms 7172 KB Output is correct
24 Correct 30 ms 3308 KB Output is correct
25 Correct 26 ms 3308 KB Output is correct
26 Correct 69 ms 6636 KB Output is correct
27 Correct 69 ms 6636 KB Output is correct
28 Correct 62 ms 5868 KB Output is correct
29 Correct 61 ms 5868 KB Output is correct
30 Correct 60 ms 5868 KB Output is correct
31 Correct 51 ms 5100 KB Output is correct
32 Correct 53 ms 5100 KB Output is correct
33 Correct 53 ms 5100 KB Output is correct
34 Correct 76 ms 6892 KB Output is correct
35 Correct 71 ms 6764 KB Output is correct
36 Correct 71 ms 6892 KB Output is correct
37 Correct 70 ms 6764 KB Output is correct
38 Correct 74 ms 6764 KB Output is correct
39 Correct 71 ms 6764 KB Output is correct
40 Correct 74 ms 6764 KB Output is correct
41 Correct 70 ms 6764 KB Output is correct
42 Correct 70 ms 6764 KB Output is correct
43 Correct 74 ms 6892 KB Output is correct
44 Correct 70 ms 6764 KB Output is correct
45 Correct 87 ms 6820 KB Output is correct
46 Correct 71 ms 6764 KB Output is correct
47 Correct 71 ms 7148 KB Output is correct
48 Correct 55 ms 7020 KB Output is correct
49 Correct 76 ms 7148 KB Output is correct
50 Correct 1 ms 492 KB Output is correct
51 Correct 1 ms 492 KB Output is correct
52 Correct 1 ms 492 KB Output is correct
53 Correct 556 ms 31980 KB Output is correct
54 Correct 513 ms 35820 KB Output is correct
55 Correct 646 ms 35564 KB Output is correct
56 Correct 162 ms 12648 KB Output is correct
57 Correct 561 ms 35820 KB Output is correct
58 Correct 290 ms 18156 KB Output is correct
59 Correct 247 ms 18156 KB Output is correct
60 Correct 396 ms 25188 KB Output is correct
61 Correct 691 ms 36216 KB Output is correct
62 Correct 672 ms 36312 KB Output is correct
63 Correct 672 ms 36372 KB Output is correct
64 Correct 584 ms 31980 KB Output is correct
65 Correct 573 ms 31980 KB Output is correct
66 Correct 470 ms 27244 KB Output is correct
67 Correct 482 ms 27280 KB Output is correct
68 Correct 541 ms 30200 KB Output is correct
69 Correct 668 ms 35440 KB Output is correct
70 Correct 678 ms 35468 KB Output is correct
71 Correct 507 ms 33912 KB Output is correct
72 Correct 507 ms 34000 KB Output is correct
73 Correct 548 ms 33948 KB Output is correct
74 Correct 671 ms 35552 KB Output is correct
75 Correct 669 ms 35648 KB Output is correct
76 Correct 666 ms 35444 KB Output is correct
77 Correct 675 ms 35456 KB Output is correct
78 Correct 667 ms 35308 KB Output is correct
79 Correct 671 ms 35276 KB Output is correct
80 Correct 673 ms 35528 KB Output is correct
81 Correct 660 ms 35444 KB Output is correct
82 Correct 671 ms 35568 KB Output is correct
83 Correct 667 ms 35540 KB Output is correct
84 Correct 665 ms 35636 KB Output is correct
85 Correct 676 ms 35508 KB Output is correct
86 Correct 678 ms 35504 KB Output is correct
87 Correct 666 ms 35528 KB Output is correct
88 Correct 657 ms 35364 KB Output is correct
89 Correct 677 ms 35556 KB Output is correct
90 Correct 666 ms 35408 KB Output is correct
91 Correct 1 ms 492 KB Output is correct
92 Correct 1 ms 492 KB Output is correct
93 Correct 1 ms 492 KB Output is correct
94 Correct 901 ms 34484 KB Output is correct
95 Correct 680 ms 35844 KB Output is correct
96 Correct 947 ms 35796 KB Output is correct
97 Correct 367 ms 19436 KB Output is correct
98 Correct 197 ms 12652 KB Output is correct
99 Correct 619 ms 35908 KB Output is correct
100 Correct 344 ms 18284 KB Output is correct
101 Correct 342 ms 18156 KB Output is correct
102 Correct 433 ms 25356 KB Output is correct
103 Correct 697 ms 36336 KB Output is correct
104 Correct 977 ms 36360 KB Output is correct
105 Correct 966 ms 36328 KB Output is correct
106 Correct 916 ms 34584 KB Output is correct
107 Correct 586 ms 32088 KB Output is correct
108 Correct 473 ms 27280 KB Output is correct
109 Correct 797 ms 31520 KB Output is correct
110 Correct 526 ms 29316 KB Output is correct
111 Correct 791 ms 36368 KB Output is correct
112 Correct 965 ms 35784 KB Output is correct
113 Correct 591 ms 33948 KB Output is correct
114 Correct 507 ms 34008 KB Output is correct
115 Correct 619 ms 33952 KB Output is correct
116 Correct 948 ms 35904 KB Output is correct
117 Correct 960 ms 35940 KB Output is correct
118 Correct 970 ms 35932 KB Output is correct
119 Correct 966 ms 35844 KB Output is correct
120 Correct 968 ms 35920 KB Output is correct
121 Correct 577 ms 31980 KB Output is correct
122 Correct 615 ms 35832 KB Output is correct
123 Correct 685 ms 35652 KB Output is correct
124 Correct 1 ms 492 KB Output is correct
125 Correct 1 ms 492 KB Output is correct
126 Correct 1 ms 492 KB Output is correct