oj.uz

Submission #627995

# Submission time Handle Problem Language Result Execution time Memory
627995 2022-08-13T02:50:57 Z Benq Thousands Islands (IOI22_islands) C++17
100 / 100
 370 ms 34544 KB 
#include "islands.h"

#include <variant>
#include <vector>

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

/**
 * Description: Disjoint Set Union with path compression
   * and union by size. Add edges and test connectivity. 
   * Use for Kruskal's or Boruvka's minimum spanning tree.
 * Time: O(\alpha(N))
 * Source: CSAcademy, KACTL
 * Verification: *
 */

struct DSU {
  vi e; void init(int N) { e = vi(N,-1); }
  int get(int x) { return e[x] < 0 ? x : e[x] = get(e[x]); } 
  bool sameSet(int a, int b) { return get(a) == get(b); }
  int size(int x) { return -e[get(x)]; }
  bool unite(int x, int y) { // union by size
    x = get(x), y = get(y); if (x == y) return 0;
    if (e[x] > e[y]) swap(x,y);
    e[x] += e[y]; e[y] = x; return 1;
  }
};

/**tcT> T kruskal(int N, vector<pair<T,pi>> ed) {
  sort(all(ed));
  T ans = 0; DSU D; D.init(N); // edges that unite are in MST
  each(a,ed) if (D.unite(a.s.f,a.s.s)) ans += a.f; 
  return ans;
}*/

vi operator+(vi a, vi b) {
  a.ins(end(a),all(b));
  return a;
}

vi rev(vi a) {
  reverse(all(a));
  return a;
}

std::variant<bool, std::vector<int>> find_journey(
    int N, int M, std::vector<int> U, std::vector<int> V) {
  int src = 0;
  vector<map<int,int>> in(N), out(N);
  F0R(i,M) {
    out[U[i]][i] = V[i];
    in[V[i]][i] = U[i];
  }
  queue<int> q;
  F0R(x,N) if (!sz(out[x]) || !sz(in[x])) q.push(x);
  auto remove_from_graph = [&](int x) {
    for (auto y: out[x]) {
      in[y.s].erase(y.f);
      q.push(y.s);
    }
    for (auto y: in[x]) {
      out[y.s].erase(y.f);
      q.push(y.s);
    }
    out[x].clear(), in[x].clear();
  };
  vi stk;
  while (true) {
    if (sz(q)) {
      int x = q.ft; q.pop();
      if (x == src) continue;
      if (!sz(out[x]) || !sz(in[x])) {
        remove_from_graph(x);
      }
      continue;
    }
    if (sz(out[src]) == 0) return false;
    if (sz(out[src]) == 1) {
      stk.pb(begin(out[src])->f);
      int nsrc = begin(out[src])->s;
      remove_from_graph(src);
      src = nsrc;
      continue;
    }
    break;
  }
  dbg("OOPS", stk);
  vi edges;
  F0R(i,N) if (sz(out[i])) {
    edges.pb(begin(out[i])->f);
    if (i == src) {
      assert(sz(out[i]) >= 2);
      edges.pb(next(begin(out[i]))->f);
    }
  }
  dbg("EDGES =", edges);
  F0R(i,N) out[i].clear(), in[i].clear();
  for (int e: edges) {
    out.at(U[e])[e] = V[e];
  }
  F0R(i,N) dbg(i, out[i]);
  vi ans;
  int cur = src;
  multiset<int> toggled;
  auto take_edge = [&](int e) {
    if (sz(ans)) assert(ans.bk != e);
    assert(out[cur].count(e));
    int nex = out[cur].at(e);
    out[cur].erase(e);
    out[nex][e] = cur;
    if (toggled.count(e)) toggled.erase(e);
    else toggled.ins(e);
    cur = nex; ans.pb(e);
    dbg("ANS", ans);
  };
  auto take_only_cand = [&]() {
    vi cand;
    for (auto [e, _]: out[cur]) if (e != ans.bk) cand.pb(e);
    dbg("CAND", cand);
    assert(sz(cand) == 1);
    take_edge(cand[0]);
  };
  take_edge(begin(out[cur])->f);
  while (sz(toggled)) {
    take_only_cand();
  }
  return stk + ans + rev(stk);
}

Compilation message

islands.cpp: In function 'std::variant<bool, std::vector<int, std::allocator<int> > > find_journey(int, int, std::vector<int>, std::vector<int>)':
islands.cpp:240:22: warning: statement has no effect [-Wunused-value]
  240 |     #define dbg(...) 0
      |                      ^
islands.cpp:339:3: note: in expansion of macro 'dbg'
  339 |   dbg("OOPS", stk);
      |   ^~~
islands.cpp:240:22: warning: statement has no effect [-Wunused-value]
  240 |     #define dbg(...) 0
      |                      ^
islands.cpp:348:3: note: in expansion of macro 'dbg'
  348 |   dbg("EDGES =", edges);
      |   ^~~
islands.cpp:240:22: warning: statement has no effect [-Wunused-value]
  240 |     #define dbg(...) 0
      |                      ^
islands.cpp:353:12: note: in expansion of macro 'dbg'
  353 |   F0R(i,N) dbg(i, out[i]);
      |            ^~~
islands.cpp: In lambda function:
islands.cpp:240:22: warning: statement has no effect [-Wunused-value]
  240 |     #define dbg(...) 0
      |                      ^
islands.cpp:366:5: note: in expansion of macro 'dbg'
  366 |     dbg("ANS", ans);
      |     ^~~
islands.cpp: In lambda function:
islands.cpp:240:22: warning: statement has no effect [-Wunused-value]
  240 |     #define dbg(...) 0
      |                      ^
islands.cpp:371:5: note: in expansion of macro 'dbg'
  371 |     dbg("CAND", cand);
      |     ^~~
islands.cpp: In function 'void FileIO::setIn(str)':
islands.cpp:249:31: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  249 |   void setIn(str s)  { freopen(s.c_str(),"r",stdin); }
      |                        ~~~~~~~^~~~~~~~~~~~~~~~~~~~~
islands.cpp: In function 'void FileIO::setOut(str)':
islands.cpp:250:31: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  250 |   void setOut(str s) { freopen(s.c_str(),"w",stdout); }
      |                        ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~

Subtask #1
5.0 / 5.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 0 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 126 ms 22224 KB Output is correct

Subtask #2
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 212 KB Output is correct
2 Correct 1 ms 212 KB Output is correct
3 Correct 0 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 144 ms 17772 KB Output is correct

Subtask #3
21.0 / 21.0

# Verdict Execution time Memory Grader output
1 Correct 2 ms 724 KB Output is correct
2 Correct 1 ms 212 KB Output is correct
3 Correct 0 ms 224 KB Output is correct
4 Correct 1 ms 212 KB Output is correct
5 Correct 1 ms 596 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 1 ms 468 KB Output is correct
8 Correct 1 ms 212 KB Output is correct
9 Correct 0 ms 212 KB Output is correct
10 Correct 1 ms 596 KB Output is correct
11 Correct 0 ms 212 KB Output is correct
12 Correct 2 ms 596 KB Output is correct
13 Correct 0 ms 212 KB Output is correct
14 Correct 1 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 73 ms 11344 KB Output is correct
18 Correct 52 ms 9128 KB Output is correct
19 Correct 1 ms 212 KB Output is correct
20 Correct 1 ms 212 KB Output is correct
21 Correct 0 ms 212 KB Output is correct
22 Correct 1 ms 212 KB Output is correct
23 Correct 143 ms 17936 KB Output is correct

Subtask #4
24.0 / 24.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 340 KB Output is correct
2 Correct 3 ms 724 KB Output is correct
3 Correct 154 ms 20096 KB Output is correct
4 Correct 212 ms 20112 KB Output is correct
5 Correct 2 ms 724 KB Output is correct
6 Correct 2 ms 724 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 0 ms 212 KB Output is correct
10 Correct 3 ms 596 KB Output is correct
11 Correct 2 ms 724 KB Output is correct
12 Correct 2 ms 724 KB Output is correct
13 Correct 3 ms 852 KB Output is correct
14 Correct 2 ms 724 KB Output is correct
15 Correct 3 ms 980 KB Output is correct
16 Correct 1 ms 596 KB Output is correct
17 Correct 0 ms 212 KB Output is correct
18 Correct 3 ms 724 KB Output is correct
19 Correct 2 ms 596 KB Output is correct
20 Correct 200 ms 22324 KB Output is correct
21 Correct 183 ms 20016 KB Output is correct
22 Correct 2 ms 596 KB Output is correct
23 Correct 1 ms 468 KB Output is correct
24 Correct 0 ms 212 KB Output is correct
25 Correct 2 ms 468 KB Output is correct
26 Correct 2 ms 596 KB Output is correct
27 Correct 242 ms 21244 KB Output is correct
28 Correct 177 ms 21236 KB Output is correct
29 Correct 0 ms 212 KB Output is correct
30 Correct 206 ms 22348 KB Output is correct
31 Correct 0 ms 212 KB Output is correct
32 Correct 168 ms 20132 KB Output is correct
33 Correct 178 ms 21272 KB Output is correct
34 Correct 68 ms 11300 KB Output is correct
35 Correct 2 ms 468 KB Output is correct
36 Correct 166 ms 18076 KB Output is correct
37 Correct 172 ms 21248 KB Output is correct
38 Correct 1 ms 468 KB Output is correct
39 Correct 173 ms 17384 KB Output is correct
40 Correct 2 ms 596 KB Output is correct
41 Correct 215 ms 22360 KB Output is correct
42 Correct 204 ms 21196 KB Output is correct
43 Correct 1 ms 212 KB Output is correct
44 Correct 3 ms 724 KB Output is correct
45 Correct 2 ms 596 KB Output is correct
46 Correct 54 ms 9160 KB Output is correct

Subtask #5
45.0 / 45.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 0 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 126 ms 22224 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 1 ms 212 KB Output is correct
10 Correct 0 ms 212 KB Output is correct
11 Correct 0 ms 212 KB Output is correct
12 Correct 0 ms 212 KB Output is correct
13 Correct 144 ms 17772 KB Output is correct
14 Correct 2 ms 724 KB Output is correct
15 Correct 1 ms 212 KB Output is correct
16 Correct 0 ms 224 KB Output is correct
17 Correct 1 ms 212 KB Output is correct
18 Correct 1 ms 596 KB Output is correct
19 Correct 1 ms 212 KB Output is correct
20 Correct 1 ms 468 KB Output is correct
21 Correct 1 ms 212 KB Output is correct
22 Correct 0 ms 212 KB Output is correct
23 Correct 1 ms 596 KB Output is correct
24 Correct 0 ms 212 KB Output is correct
25 Correct 2 ms 596 KB Output is correct
26 Correct 0 ms 212 KB Output is correct
27 Correct 1 ms 212 KB Output is correct
28 Correct 0 ms 212 KB Output is correct
29 Correct 0 ms 212 KB Output is correct
30 Correct 73 ms 11344 KB Output is correct
31 Correct 52 ms 9128 KB Output is correct
32 Correct 1 ms 212 KB Output is correct
33 Correct 1 ms 212 KB Output is correct
34 Correct 0 ms 212 KB Output is correct
35 Correct 1 ms 212 KB Output is correct
36 Correct 143 ms 17936 KB Output is correct
37 Correct 1 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 340 KB Output is correct
41 Correct 92 ms 10288 KB Output is correct
42 Correct 3 ms 852 KB Output is correct
43 Correct 88 ms 15936 KB Output is correct
44 Correct 97 ms 15952 KB Output is correct
45 Correct 93 ms 15852 KB Output is correct
46 Correct 0 ms 212 KB Output is correct
47 Correct 0 ms 212 KB Output is correct
48 Correct 0 ms 212 KB Output is correct
49 Correct 2 ms 468 KB Output is correct
50 Correct 287 ms 25084 KB Output is correct
51 Correct 225 ms 31656 KB Output is correct
52 Correct 212 ms 31572 KB Output is correct
53 Correct 246 ms 31728 KB Output is correct
54 Correct 254 ms 31736 KB Output is correct
55 Correct 253 ms 31576 KB Output is correct
56 Correct 219 ms 31624 KB Output is correct
57 Correct 198 ms 28084 KB Output is correct
58 Correct 331 ms 25480 KB Output is correct
59 Correct 257 ms 31888 KB Output is correct
60 Correct 273 ms 32064 KB Output is correct
61 Correct 249 ms 32108 KB Output is correct
62 Correct 23 ms 8148 KB Output is correct
63 Correct 249 ms 30764 KB Output is correct
64 Correct 98 ms 11460 KB Output is correct
65 Correct 1 ms 212 KB Output is correct
66 Correct 1 ms 340 KB Output is correct
67 Correct 265 ms 32072 KB Output is correct
68 Correct 277 ms 22216 KB Output is correct
69 Correct 100 ms 20932 KB Output is correct
70 Correct 3 ms 660 KB Output is correct
71 Correct 206 ms 21572 KB Output is correct
72 Correct 0 ms 288 KB Output is correct
73 Correct 240 ms 29148 KB Output is correct
74 Correct 316 ms 24672 KB Output is correct
75 Correct 7 ms 1492 KB Output is correct
76 Correct 84 ms 12044 KB Output is correct
77 Correct 92 ms 20676 KB Output is correct
78 Correct 285 ms 32060 KB Output is correct
79 Correct 0 ms 212 KB Output is correct
80 Correct 370 ms 34544 KB Output is correct
81 Correct 2 ms 596 KB Output is correct
82 Correct 189 ms 22480 KB Output is correct
83 Correct 1 ms 468 KB Output is correct
84 Correct 0 ms 212 KB Output is correct
85 Correct 102 ms 12420 KB Output is correct
86 Correct 3 ms 596 KB Output is correct
87 Correct 7 ms 8260 KB Output is correct
88 Correct 4 ms 980 KB Output is correct
89 Correct 262 ms 31952 KB Output is correct
90 Correct 261 ms 32176 KB Output is correct
91 Correct 346 ms 33820 KB Output is correct
92 Correct 0 ms 212 KB Output is correct