oj.uz

Submission #625874

# Submission time Handle Problem Language Result Execution time Memory
625874 2022-08-11T00:02:54 Z Benq Catfish Farm (IOI22_fish) C++17
100 / 100
 302 ms 18760 KB 
#include "fish.h"

#include <bits/stdc++.h>
using namespace std;
 
using ll = long long;
using db = long double; // or double, if TL is tight
using str = string; // yay python! 

// pairs
using pi = pair<int,int>;
using pl = pair<ll,ll>;
using pd = pair<db,db>;
#define mp make_pair
#define f first
#define s second

#define tcT template<class T
#define tcTU tcT, class U
// ^ lol this makes everything look weird but I'll try it
tcT> using V = vector<T>; 
tcT, size_t SZ> using AR = array<T,SZ>; 
using vi = V<int>;
using vb = V<bool>;
using vl = V<ll>;
using vd = V<db>;
using vs = V<str>;
using vpi = V<pi>;
using vpl = V<pl>;
using vpd = V<pd>;

// vectors
// oops size(x), rbegin(x), rend(x) need C++17
#define sz(x) int((x).size())
#define bg(x) begin(x)
#define all(x) bg(x), end(x)
#define rall(x) x.rbegin(), x.rend() 
#define sor(x) sort(all(x)) 
#define rsz resize
#define ins insert 
#define pb push_back
#define eb emplace_back
#define ft front()
#define bk back()

#define lb lower_bound
#define ub upper_bound
tcT> int lwb(V<T>& a, const T& b) { return int(lb(all(a),b)-bg(a)); }
tcT> int upb(V<T>& a, const T& b) { return int(ub(all(a),b)-bg(a)); }

// loops
#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 rep(a) F0R(_,a)
#define each(a,x) for (auto& a: x)

const int MOD = 1e9+7; // 998244353;
const int MX = 2e5+5;
const ll BIG = 1e18; // not too close to LLONG_MAX
const db PI = acos((db)-1);
const int dx[4]{1,0,-1,0}, dy[4]{0,1,0,-1}; // for every grid problem!!
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count()); 
template<class T> using pqg = priority_queue<T,vector<T>,greater<T>>;

// bitwise ops
// also see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
constexpr int pct(int x) { return __builtin_popcount(x); } // # of bits set
constexpr int bits(int x) { // assert(x >= 0); // make C++11 compatible until USACO updates ...
    return x == 0 ? 0 : 31-__builtin_clz(x); } // floor(log2(x)) 
constexpr int p2(int x) { return 1<<x; }
constexpr int msk2(int x) { return p2(x)-1; }

ll cdiv(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
ll fdiv(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down

tcT> bool ckmin(T& a, const T& b) {
    return b < a ? a = b, 1 : 0; } // set a = min(a,b)
tcT> bool ckmax(T& a, const T& b) {
    return a < b ? a = b, 1 : 0; } // set a = max(a,b)

tcTU> T fstTrue(T lo, T hi, U f) {
    ++hi; assert(lo <= hi); // assuming f is increasing
    while (lo < hi) { // find first index such that f is true 
        T mid = lo+(hi-lo)/2;
        f(mid) ? hi = mid : lo = mid+1; 
    } 
    return lo;
}
tcTU> T lstTrue(T lo, T hi, U f) {
    --lo; assert(lo <= hi); // assuming f is decreasing
    while (lo < hi) { // find first index such that f is true 
        T mid = lo+(hi-lo+1)/2;
        f(mid) ? lo = mid : hi = mid-1;
    } 
    return lo;
}
tcT> void remDup(vector<T>& v) { // sort and remove duplicates
    sort(all(v)); v.erase(unique(all(v)),end(v)); }
tcTU> void erase(T& t, const U& u) { // don't erase
    auto it = t.find(u); assert(it != end(t));
    t.erase(it); } // element that doesn't exist from (multi)set

#define tcTUU tcT, class ...U

inline namespace Helpers {
    //////////// is_iterable
    // https://stackoverflow.com/questions/13830158/check-if-a-variable-type-is-iterable
    // this gets used only when we can call begin() and end() on that type
    tcT, class = void> struct is_iterable : false_type {};
    tcT> struct is_iterable<T, void_t<decltype(begin(declval<T>())),
                                      decltype(end(declval<T>()))
                                     >
                           > : true_type {};
    tcT> constexpr bool is_iterable_v = is_iterable<T>::value;

    //////////// is_readable
    tcT, class = void> struct is_readable : false_type {};
    tcT> struct is_readable<T,
            typename std::enable_if_t<
                is_same_v<decltype(cin >> declval<T&>()), istream&>
            >
        > : true_type {};
    tcT> constexpr bool is_readable_v = is_readable<T>::value;

    //////////// is_printable
    // // https://nafe.es/posts/2020-02-29-is-printable/
    tcT, class = void> struct is_printable : false_type {};
    tcT> struct is_printable<T,
            typename std::enable_if_t<
                is_same_v<decltype(cout << declval<T>()), ostream&>
            >
        > : true_type {};
    tcT> constexpr bool is_printable_v = is_printable<T>::value;
}

inline namespace Input {
    tcT> constexpr bool needs_input_v = !is_readable_v<T> && is_iterable_v<T>;
    tcTUU> void re(T& t, U&... u);
    tcTU> void re(pair<T,U>& p); // pairs

    // re: read
    tcT> typename enable_if<is_readable_v<T>,void>::type re(T& x) { cin >> x; } // default
    tcT> void re(complex<T>& c) { T a,b; re(a,b); c = {a,b}; } // complex
    tcT> typename enable_if<needs_input_v<T>,void>::type re(T& i); // ex. vectors, arrays
    tcTU> void re(pair<T,U>& p) { re(p.f,p.s); }
    tcT> typename enable_if<needs_input_v<T>,void>::type re(T& i) {
        each(x,i) re(x); }
    tcTUU> void re(T& t, U&... u) { re(t); re(u...); } // read multiple

    // rv: resize and read vectors
    void rv(size_t) {}
    tcTUU> void rv(size_t N, V<T>& t, U&... u);
    template<class...U> void rv(size_t, size_t N2, U&... u);
    tcTUU> void rv(size_t N, V<T>& t, U&... u) {
        t.rsz(N); re(t);
        rv(N,u...); }
    template<class...U> void rv(size_t, size_t N2, U&... u) {
        rv(N2,u...); }

    // dumb shortcuts to read in ints
    void decrement() {} // subtract one from each
    tcTUU> void decrement(T& t, U&... u) { --t; decrement(u...); }
    #define ints(...) int __VA_ARGS__; re(__VA_ARGS__);
    #define int1(...) ints(__VA_ARGS__); decrement(__VA_ARGS__);
}

inline namespace ToString {
    tcT> constexpr bool needs_output_v = !is_printable_v<T> && is_iterable_v<T>;

    // ts: string representation to print
    tcT> typename enable_if<is_printable_v<T>,str>::type ts(T v) {
        stringstream ss; ss << fixed << setprecision(15) << v;
        return ss.str(); } // default
    tcT> str bit_vec(T t) { // bit vector to string
        str res = "{"; F0R(i,sz(t)) res += ts(t[i]);
        res += "}"; return res; }
    str ts(V<bool> v) { return bit_vec(v); }
    template<size_t SZ> str ts(bitset<SZ> b) { return bit_vec(b); } // bit vector
    tcTU> str ts(pair<T,U> p); // pairs
    tcT> typename enable_if<needs_output_v<T>,str>::type ts(T v); // vectors, arrays
    tcTU> str ts(pair<T,U> p) { return "("+ts(p.f)+", "+ts(p.s)+")"; }
    tcT> typename enable_if<is_iterable_v<T>,str>::type ts_sep(T v, str sep) {
        // convert container to string w/ separator sep
        bool fst = 1; str res = "";
        for (const auto& x: v) {
            if (!fst) res += sep;
            fst = 0; res += ts(x);
        }
        return res;
    }
    tcT> typename enable_if<needs_output_v<T>,str>::type ts(T v) {
        return "{"+ts_sep(v,", ")+"}"; }

    // for nested DS
    template<int, class T> typename enable_if<!needs_output_v<T>,vs>::type 
      ts_lev(const T& v) { return {ts(v)}; }
    template<int lev, class T> typename enable_if<needs_output_v<T>,vs>::type 
      ts_lev(const T& v) {
        if (lev == 0 || !sz(v)) return {ts(v)};
        vs res;
        for (const auto& t: v) {
            if (sz(res)) res.bk += ",";
            vs tmp = ts_lev<lev-1>(t);
            res.ins(end(res),all(tmp));
        }
        F0R(i,sz(res)) {
            str bef = " "; if (i == 0) bef = "{";
            res[i] = bef+res[i];
        }
        res.bk += "}";
        return res;
    }
}

inline namespace Output {
    template<class T> void pr_sep(ostream& os, str, const T& t) { os << ts(t); }
    template<class T, class... U> void pr_sep(ostream& os, str sep, const T& t, const U&... u) {
        pr_sep(os,sep,t); os << sep; pr_sep(os,sep,u...); }
    // print w/ no spaces
    template<class ...T> void pr(const T&... t) { pr_sep(cout,"",t...); } 
    // print w/ spaces, end with newline
    void ps() { cout << "\n"; }
    template<class ...T> void ps(const T&... t) { pr_sep(cout," ",t...); ps(); } 
    // debug to cerr
    template<class ...T> void dbg_out(const T&... t) {
        pr_sep(cerr," | ",t...); cerr << endl; }
    void loc_info(int line, str names) {
        cerr << "Line(" << line << ") -> [" << names << "]: "; }
    template<int lev, class T> void dbgl_out(const T& t) {
        cerr << "\n\n" << ts_sep(ts_lev<lev>(t),"\n") << "\n" << endl; }
    #ifdef LOCAL
        #define dbg(...) loc_info(__LINE__,#__VA_ARGS__), dbg_out(__VA_ARGS__)
        #define dbgl(lev,x) loc_info(__LINE__,#x), dbgl_out<lev>(x)
    #else // don't actually submit with this
        #define dbg(...) 0
        #define dbgl(lev,x) 0
    #endif

    const clock_t beg = clock();
    #define dbg_time() dbg((db)(clock()-beg)/CLOCKS_PER_SEC)
}

inline namespace FileIO {
    void setIn(str s)  { freopen(s.c_str(),"r",stdin); }
    void setOut(str s) { freopen(s.c_str(),"w",stdout); }
    void setIO(str s = "") {
        cin.tie(0)->sync_with_stdio(0); // unsync C / C++ I/O streams
        // cin.exceptions(cin.failbit);
        // throws exception when do smth illegal
        // ex. try to read letter into int
        if (sz(s)) setIn(s+".in"), setOut(s+".out"); // for old USACO
    }
}

/* stuff you should look for
    * int overflow, array bounds
    * special cases (n=1?)
    * do smth instead of nothing and stay organized
    * WRITE STUFF DOWN
    * DON'T GET STUCK ON ONE APPROACH
*/


/**
 * Description: 1D point update, range query where \texttt{cmb} is
     * any associative operation. If $N=2^p$ then \texttt{seg[1]==query(0,N-1)}.
 * Time: O(\log N)
 * Source: 
    * http://codeforces.com/blog/entry/18051
    * KACTL
 * Verification: SPOJ Fenwick
 */

tcT> struct SegTree { // cmb(ID,b) = b
    const T ID{-BIG}; T cmb(T a, T b) { return max(a,b); } 
    int n; V<T> seg;
    void init(int _n) { // upd, query also work if n = _n
        for (n = 1; n < _n; ) n *= 2; 
        seg.assign(2*n,ID); }
    void pull(int p) { seg[p] = cmb(seg[2*p],seg[2*p+1]); }
    void upd(int p, T val) { // set val at position p
        ckmax(seg[p += n],val); for (p /= 2; p; p /= 2) pull(p); }
    T query(int l, int r) {    // associative op on [l, r]
        T ra = ID, rb = ID;
        for (l += n, r += n+1; l < r; l /= 2, r /= 2) {
            if (l&1) ra = cmb(ra,seg[l++]);
            if (r&1) rb = cmb(seg[--r],rb);
        }
        return cmb(ra,rb);
    }
    /// int first_at_least(int lo, int val, int ind, int l, int r) { // if seg stores max across range
    ///     if (r < lo || val > seg[ind]) return -1;
    ///     if (l == r) return l;
    ///     int m = (l+r)/2;
    ///     int res = first_at_least(lo,val,2*ind,l,m); if (res != -1) return res;
    ///     return first_at_least(lo,val,2*ind+1,m+1,r);
    /// }
};

long long max_weights(int N, int M, std::vector<int> X, std::vector<int> Y,
                      std::vector<int> W) {
    V<vpi> fish(N);
    F0R(i,M) {
        fish.at(X[i]).pb({Y[i],W[i]});
    }
    SegTree<ll> seg_up, seg_down; 
    seg_up.init(N+1); 
    seg_down.init(N+1);
    ll reached_zero = 0;
    F0R(i,N) {
        sor(fish[i]);
        dbg(i, fish[i], sz(fish[i]));
        vl dp_up, dp_down;
        each(t,fish[i]) {
            dp_up.pb(seg_up.query(0, t.f-1) + t.s);
            dp_down.pb(seg_down.query(t.f+1, N) + t.s);
        }
        seg_down.upd(N, max(seg_up.query(0, N), reached_zero));
        {
            ll sum = 0;
            F0R(j,sz(dp_up)) {
                sum += fish[i][j].s;
                ckmax(dp_up.at(j), reached_zero + sum);
            }
        }
        F0R(j,sz(dp_up)) if (j) ckmax(dp_up.at(j), dp_up.at(j-1) + fish[i].at(j).s);
        {
            ll sum = 0;
            F0R(j,sz(dp_up)) {
                ckmax(dp_up[j], dp_down[j] + sum);
                ckmax(reached_zero, dp_down[j] + sum);
                sum += fish[i][j].s;
            }
        }
        R0F(j,sz(dp_down)) if (j+1 < sz(dp_down)) ckmax(dp_down.at(j), dp_down.at(j+1) + fish[i].at(j).s);
        dbg("HA", dp_up, dp_down, seg_down.query(N, N));
        F0R(j,sz(dp_up)) {
            seg_up.upd(fish[i][j].f, dp_up[j]);
            seg_down.upd(fish[i][j].f, dp_down[j]);
        }
    }
    return max({reached_zero, seg_down.query(0, N)});
}

Compilation message

fish.cpp: In function 'long long int max_weights(int, int, std::vector<int>, std::vector<int>, std::vector<int>)':
fish.cpp:237:26: warning: statement has no effect [-Wunused-value]
  237 |         #define dbg(...) 0
      |                          ^
fish.cpp:314:9: note: in expansion of macro 'dbg'
  314 |         dbg(i, fish[i], sz(fish[i]));
      |         ^~~
fish.cpp:237:26: warning: statement has no effect [-Wunused-value]
  237 |         #define dbg(...) 0
      |                          ^
fish.cpp:338:9: note: in expansion of macro 'dbg'
  338 |         dbg("HA", dp_up, dp_down, seg_down.query(N, N));
      |         ^~~
fish.cpp: In function 'void FileIO::setIn(str)':
fish.cpp:246:33: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  246 |     void setIn(str s)  { freopen(s.c_str(),"r",stdin); }
      |                          ~~~~~~~^~~~~~~~~~~~~~~~~~~~~
fish.cpp: In function 'void FileIO::setOut(str)':
fish.cpp:247:33: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  247 |     void setOut(str s) { freopen(s.c_str(),"w",stdout); }
      |                          ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~

Subtask #1
3.0 / 3.0

# Verdict Execution time Memory Grader output
1 Correct 55 ms 11584 KB Output is correct
2 Correct 65 ms 12236 KB Output is correct
3 Correct 10 ms 6740 KB Output is correct
4 Correct 10 ms 6740 KB Output is correct
5 Correct 189 ms 18760 KB Output is correct
6 Correct 236 ms 18152 KB Output is correct

Subtask #2
6.0 / 6.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 115 ms 14176 KB Output is correct
3 Correct 126 ms 15984 KB Output is correct
4 Correct 54 ms 11456 KB Output is correct
5 Correct 66 ms 12200 KB Output is correct
6 Correct 0 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 1 ms 212 KB Output is correct
10 Correct 13 ms 6740 KB Output is correct
11 Correct 13 ms 6772 KB Output is correct
12 Correct 63 ms 11516 KB Output is correct
13 Correct 65 ms 12220 KB Output is correct
14 Correct 54 ms 10236 KB Output is correct
15 Correct 61 ms 10780 KB Output is correct
16 Correct 54 ms 10232 KB Output is correct
17 Correct 59 ms 10760 KB Output is correct

Subtask #3
9.0 / 9.0

# Verdict Execution time Memory Grader output
1 Correct 11 ms 6740 KB Output is correct
2 Correct 10 ms 6740 KB Output is correct
3 Correct 43 ms 9468 KB Output is correct
4 Correct 41 ms 8660 KB Output is correct
5 Correct 72 ms 12236 KB Output is correct
6 Correct 63 ms 12228 KB Output is correct
7 Correct 67 ms 12232 KB Output is correct
8 Correct 69 ms 12232 KB Output is correct

Subtask #4
14.0 / 14.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 0 ms 212 KB Output is correct
6 Correct 0 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 1 ms 212 KB Output is correct
10 Correct 2 ms 340 KB Output is correct
11 Correct 1 ms 340 KB Output is correct
12 Correct 1 ms 280 KB Output is correct
13 Correct 0 ms 212 KB Output is correct
14 Correct 1 ms 340 KB Output is correct

Subtask #5
21.0 / 21.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 0 ms 212 KB Output is correct
6 Correct 0 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 1 ms 212 KB Output is correct
10 Correct 2 ms 340 KB Output is correct
11 Correct 1 ms 340 KB Output is correct
12 Correct 1 ms 280 KB Output is correct
13 Correct 0 ms 212 KB Output is correct
14 Correct 1 ms 340 KB Output is correct
15 Correct 0 ms 276 KB Output is correct
16 Correct 1 ms 296 KB Output is correct
17 Correct 19 ms 1876 KB Output is correct
18 Correct 18 ms 2132 KB Output is correct
19 Correct 20 ms 1992 KB Output is correct
20 Correct 19 ms 2112 KB Output is correct
21 Correct 18 ms 2004 KB Output is correct
22 Correct 50 ms 3788 KB Output is correct
23 Correct 5 ms 596 KB Output is correct
24 Correct 15 ms 1364 KB Output is correct
25 Correct 1 ms 340 KB Output is correct
26 Correct 5 ms 596 KB Output is correct

Subtask #6
17.0 / 17.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 0 ms 212 KB Output is correct
6 Correct 0 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 1 ms 212 KB Output is correct
10 Correct 2 ms 340 KB Output is correct
11 Correct 1 ms 340 KB Output is correct
12 Correct 1 ms 280 KB Output is correct
13 Correct 0 ms 212 KB Output is correct
14 Correct 1 ms 340 KB Output is correct
15 Correct 0 ms 276 KB Output is correct
16 Correct 1 ms 296 KB Output is correct
17 Correct 19 ms 1876 KB Output is correct
18 Correct 18 ms 2132 KB Output is correct
19 Correct 20 ms 1992 KB Output is correct
20 Correct 19 ms 2112 KB Output is correct
21 Correct 18 ms 2004 KB Output is correct
22 Correct 50 ms 3788 KB Output is correct
23 Correct 5 ms 596 KB Output is correct
24 Correct 15 ms 1364 KB Output is correct
25 Correct 1 ms 340 KB Output is correct
26 Correct 5 ms 596 KB Output is correct
27 Correct 2 ms 596 KB Output is correct
28 Correct 97 ms 8652 KB Output is correct
29 Correct 147 ms 11424 KB Output is correct
30 Correct 157 ms 10864 KB Output is correct
31 Correct 172 ms 10956 KB Output is correct
32 Correct 124 ms 12344 KB Output is correct
33 Correct 154 ms 10912 KB Output is correct
34 Correct 148 ms 10828 KB Output is correct
35 Correct 60 ms 4812 KB Output is correct
36 Correct 153 ms 11768 KB Output is correct

Subtask #7
14.0 / 14.0

# Verdict Execution time Memory Grader output
1 Correct 11 ms 6740 KB Output is correct
2 Correct 10 ms 6740 KB Output is correct
3 Correct 43 ms 9468 KB Output is correct
4 Correct 41 ms 8660 KB Output is correct
5 Correct 72 ms 12236 KB Output is correct
6 Correct 63 ms 12228 KB Output is correct
7 Correct 67 ms 12232 KB Output is correct
8 Correct 69 ms 12232 KB Output is correct
9 Correct 74 ms 12232 KB Output is correct
10 Correct 60 ms 7352 KB Output is correct
11 Correct 140 ms 14696 KB Output is correct
12 Correct 0 ms 212 KB Output is correct
13 Correct 0 ms 212 KB Output is correct
14 Correct 0 ms 212 KB Output is correct
15 Correct 0 ms 212 KB Output is correct
16 Correct 0 ms 212 KB Output is correct
17 Correct 0 ms 212 KB Output is correct
18 Correct 10 ms 6776 KB Output is correct
19 Correct 10 ms 6740 KB Output is correct
20 Correct 10 ms 6776 KB Output is correct
21 Correct 10 ms 6740 KB Output is correct
22 Correct 88 ms 11196 KB Output is correct
23 Correct 142 ms 14600 KB Output is correct
24 Correct 160 ms 14592 KB Output is correct

Subtask #8
16.0 / 16.0

# Verdict Execution time Memory Grader output
1 Correct 55 ms 11584 KB Output is correct
2 Correct 65 ms 12236 KB Output is correct
3 Correct 10 ms 6740 KB Output is correct
4 Correct 10 ms 6740 KB Output is correct
5 Correct 189 ms 18760 KB Output is correct
6 Correct 236 ms 18152 KB Output is correct
7 Correct 1 ms 212 KB Output is correct
8 Correct 115 ms 14176 KB Output is correct
9 Correct 126 ms 15984 KB Output is correct
10 Correct 54 ms 11456 KB Output is correct
11 Correct 66 ms 12200 KB Output is correct
12 Correct 0 ms 212 KB Output is correct
13 Correct 0 ms 212 KB Output is correct
14 Correct 0 ms 212 KB Output is correct
15 Correct 1 ms 212 KB Output is correct
16 Correct 13 ms 6740 KB Output is correct
17 Correct 13 ms 6772 KB Output is correct
18 Correct 63 ms 11516 KB Output is correct
19 Correct 65 ms 12220 KB Output is correct
20 Correct 54 ms 10236 KB Output is correct
21 Correct 61 ms 10780 KB Output is correct
22 Correct 54 ms 10232 KB Output is correct
23 Correct 59 ms 10760 KB Output is correct
24 Correct 11 ms 6740 KB Output is correct
25 Correct 10 ms 6740 KB Output is correct
26 Correct 43 ms 9468 KB Output is correct
27 Correct 41 ms 8660 KB Output is correct
28 Correct 72 ms 12236 KB Output is correct
29 Correct 63 ms 12228 KB Output is correct
30 Correct 67 ms 12232 KB Output is correct
31 Correct 69 ms 12232 KB Output is correct
32 Correct 0 ms 212 KB Output is correct
33 Correct 0 ms 212 KB Output is correct
34 Correct 1 ms 212 KB Output is correct
35 Correct 0 ms 212 KB Output is correct
36 Correct 0 ms 212 KB Output is correct
37 Correct 0 ms 212 KB Output is correct
38 Correct 0 ms 212 KB Output is correct
39 Correct 0 ms 212 KB Output is correct
40 Correct 1 ms 212 KB Output is correct
41 Correct 2 ms 340 KB Output is correct
42 Correct 1 ms 340 KB Output is correct
43 Correct 1 ms 280 KB Output is correct
44 Correct 0 ms 212 KB Output is correct
45 Correct 1 ms 340 KB Output is correct
46 Correct 0 ms 276 KB Output is correct
47 Correct 1 ms 296 KB Output is correct
48 Correct 19 ms 1876 KB Output is correct
49 Correct 18 ms 2132 KB Output is correct
50 Correct 20 ms 1992 KB Output is correct
51 Correct 19 ms 2112 KB Output is correct
52 Correct 18 ms 2004 KB Output is correct
53 Correct 50 ms 3788 KB Output is correct
54 Correct 5 ms 596 KB Output is correct
55 Correct 15 ms 1364 KB Output is correct
56 Correct 1 ms 340 KB Output is correct
57 Correct 5 ms 596 KB Output is correct
58 Correct 2 ms 596 KB Output is correct
59 Correct 97 ms 8652 KB Output is correct
60 Correct 147 ms 11424 KB Output is correct
61 Correct 157 ms 10864 KB Output is correct
62 Correct 172 ms 10956 KB Output is correct
63 Correct 124 ms 12344 KB Output is correct
64 Correct 154 ms 10912 KB Output is correct
65 Correct 148 ms 10828 KB Output is correct
66 Correct 60 ms 4812 KB Output is correct
67 Correct 153 ms 11768 KB Output is correct
68 Correct 74 ms 12232 KB Output is correct
69 Correct 60 ms 7352 KB Output is correct
70 Correct 140 ms 14696 KB Output is correct
71 Correct 0 ms 212 KB Output is correct
72 Correct 0 ms 212 KB Output is correct
73 Correct 0 ms 212 KB Output is correct
74 Correct 0 ms 212 KB Output is correct
75 Correct 0 ms 212 KB Output is correct
76 Correct 0 ms 212 KB Output is correct
77 Correct 10 ms 6776 KB Output is correct
78 Correct 10 ms 6740 KB Output is correct
79 Correct 10 ms 6776 KB Output is correct
80 Correct 10 ms 6740 KB Output is correct
81 Correct 88 ms 11196 KB Output is correct
82 Correct 142 ms 14600 KB Output is correct
83 Correct 160 ms 14592 KB Output is correct
84 Correct 184 ms 17248 KB Output is correct
85 Correct 181 ms 17284 KB Output is correct
86 Correct 237 ms 18380 KB Output is correct
87 Correct 302 ms 18656 KB Output is correct
88 Correct 0 ms 212 KB Output is correct
89 Correct 236 ms 18732 KB Output is correct
90 Correct 174 ms 18164 KB Output is correct
91 Correct 192 ms 17920 KB Output is correct