oj.uz

Submission #625896

# Submission time Handle Problem Language Result Execution time Memory
625896 2022-08-11T01:18:23 Z Benq Radio Towers (IOI22_towers) C++17
23 / 100
 4000 ms 257700 KB 
#include "towers.h"

#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: 1D range minimum query. Can also do queries 
   * for any associative operation in $O(1)$ with D\&C
 * Source: KACTL
 * Verification: 
  * https://cses.fi/problemset/stats/1647/
  * http://wcipeg.com/problem/ioi1223
  * https://pastebin.com/ChpniVZL
 * Memory: O(N\log N)
 * Time: O(1)
 */

tcT> struct RMQ {
  int level(int x) { return 31-__builtin_clz(x); }
  V<T> v; V<vi> jmp;
  int cmb(int a, int b) {
    return v[a]==v[b]?min(a,b):(v[a]<v[b]?a:b); }
  void init(const V<T>& _v) {
    v = _v; jmp = {vi(sz(v))};
    iota(all(jmp[0]),0);
    for (int j = 1; 1<<j <= sz(v); ++j) {
      jmp.pb(vi(sz(v)-(1<<j)+1));
      F0R(i,sz(jmp[j])) jmp[j][i] = cmb(jmp[j-1][i],
        jmp[j-1][i+(1<<(j-1))]);
    }
  }
  int index(int l, int r) {
    assert(l <= r); int d = level(r-l+1);
    return cmb(jmp[d][l],jmp[d][r-(1<<d)+1]); }
  T query(int l, int r) { return v[index(l,r)]; }
};

struct PSeg {
  int N;
  struct Node {
    int sum = 0;
    Node *l = nullptr, *r = nullptr;
    Node* upd(int L, int R, int pos, int inc) {
      if (L == R) {
        return new Node{this->sum+inc};
      }
      int M = (L+R)/2;
      if (pos <= M) {
        auto l = this->l->upd(L, M, pos, inc);
        return new Node{l->sum+this->r->sum, l, this->r};
      } else {
        auto r = this->r->upd(M+1, R, pos, inc);
        return new Node{this->l->sum+r->sum, this->l, r};
      }
    }
    int query(int L, int R, int up) {
      if (R <= up) return sum;
      if (up < L) return 0;
      int M = (L+R)/2;
      return l->query(L, M, up) + r->query(M+1, R, up);
    }
  };
  V<Node*> stor;
  Node* build(int L, int R) {
    if (L == R) return new Node{};
    int M = (L+R)/2;
    auto l = build(L, M), r = build(M+1, R);
    return new Node{0,l,r};
  }
  void inc(int pos, int inc) {
    stor.pb(stor.bk->upd(0, N-1, pos, inc));
  }
  int query(int it, int up) {
    return stor.at(it)->query(0, N-1, up);
  }
  void init(int N_) {
    N = N_;
    stor.pb(build(0, N-1));
  }
};


RMQ<int> pos, neg;
vi H, lef, rig;

int qmin(int l, int r) {
  return pos.query(l, r);
}

int qmax(int l, int r) {
  return -neg.query(l, r);
}

V<AR<int,4>> ev;
PSeg a, b;

void init(int N, std::vector<int> H_) {
  H = H_;
  pos.init(H_);
  each(t,H_) t *= -1;
  neg.init(H_);
  lef.rsz(N), rig.rsz(N);
  {
    vi stk{-1};
    F0R(i,N) {
      while (stk.bk != -1 && H[stk.bk] <= H[i]) stk.pop_back();
      lef[i] = stk.bk+1;
      stk.pb(i);
    }
  }
  {
    vi stk{N};
    R0F(i,N) {
      while (stk.bk != N && H[stk.bk] < H[i]) stk.pop_back();
      rig[i] = stk.bk-1;
      stk.pb(i);
    }
  }
  F0R(i,N) if (lef[i] < i) {
    int mn = qmin(lef[i], i);
    int lo = qmax(lef[i], i-1), hi = H[i];
    lo -= mn, hi -= mn;
    assert(lo <= hi);
    if (lo < hi) {
      // dbg("PUSHING L", lef[i], i, lo, hi);
      ev.pb({lo, 1, lef[i], i});
      ev.pb({hi, 0, lef[i], i});
    }
  }
  F0R(i,N) if (rig[i] > i) {
    int mn = qmin(i, rig[i]);
    int lo = qmax(i+1, rig[i]), hi = H[i];
    lo -= mn, hi -= mn;
    assert(lo <= hi);
    if (lo < hi) {
      // dbg("PUSHING R", i, rig[i], lo, hi);
      ev.pb({lo, 1, i, rig[i]});
      ev.pb({hi, 0, i, rig[i]});
    }
  }
  sor(ev);
  a.init(N), b.init(N);
  each(t, ev) {
    a.inc(t[2], (t[1] == 1 ? 1 : -1));
    b.inc(t[3], (t[1] == 1 ? 1 : -1));
  }
}
// # with right <= R - # with

int max_towers(int L, int R, int D) {
  // dbg("MAX TOWERS", L, R, D);
  auto small_interval = [&](int l, int r) {
    // dbg("TESTING", l, r);
    return l <= r && qmax(l, r) - qmin(l, r) < D;
  };
  if (small_interval(L, R)) return 1;
  int ans = 0;
  {
    int M = fstTrue(L, R, [&](int i) { return qmax(L, i) - qmin(L, i) >= D; } );
    if (M <= R && lef.at(M) < L) ++ans;
  }
  {
    int M = lstTrue(L, R, [&](int i) { return qmax(i, R) - qmin(i, R) >= D; });
    if (M >= L && rig.at(M) > R) ++ans;
  }
  FOR(M,L,R+1) if (lef[M] >= L) {
    if (small_interval(lef[M], M-1) && H.at(M) - qmin(lef[M], M-1) >= D) {
      // dbg("ADD LEF", lef[M], M);
      // ++ans;
    }
  }
  FOR(M,L,R+1) if (rig[M] <= R) {
    if (small_interval(M+1, rig[M]) && H.at(M) - qmin(M+1, rig[M]) >= D) {
      // dbg("ADD RIG", M, rig[M]);
      // ++ans;
    }
  }
  // dbg(ev, L, R, D);
  // dbg("BEFORE", ans);
  int it = lwb(ev, {D, 0, 0, 0});
  ans += b.query(it, R) - a.query(it, L-1);
  // F0R(i,it) {
  //   auto t = ev[i];
  //   if (mp(t[0], t[1]) <= mp(D, -1)) {
  //     if (t[1] == 0) {
  //       ans -= (t[3] <= R) - (t[2] < L);
  //     } else {
  //       ans += (t[3] <= R) - (t[2] < L);
  //     }
  //   }
  // }
  return ans;
}

Compilation message

towers.cpp: In function 'void FileIO::setIn(str)':
towers.cpp:248:31: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  248 |   void setIn(str s)  { freopen(s.c_str(),"r",stdin); }
      |                        ~~~~~~~^~~~~~~~~~~~~~~~~~~~~
towers.cpp: In function 'void FileIO::setOut(str)':
towers.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 setOut(str s) { freopen(s.c_str(),"w",stdout); }
      |                        ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~

Subtask #1
0 / 4.0

# Verdict Execution time Memory Grader output
1 Correct 1432 ms 145936 KB Output is correct
2 Correct 3736 ms 257224 KB Output is correct
3 Correct 3624 ms 257308 KB Output is correct
4 Correct 3461 ms 257544 KB Output is correct
5 Correct 3505 ms 251296 KB Output is correct
6 Execution timed out 4051 ms 257484 KB Time limit exceeded
7 Halted 0 ms 0 KB -

Subtask #2
11.0 / 11.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 848 KB Output is correct
2 Correct 6 ms 3888 KB Output is correct
3 Correct 6 ms 3832 KB Output is correct
4 Correct 5 ms 3792 KB Output is correct
5 Correct 5 ms 3792 KB Output is correct
6 Correct 6 ms 3836 KB Output is correct
7 Correct 8 ms 3788 KB Output is correct
8 Correct 6 ms 3848 KB Output is correct
9 Correct 5 ms 3664 KB Output is correct
10 Correct 5 ms 3792 KB Output is correct
11 Correct 5 ms 3792 KB Output is correct
12 Correct 0 ms 208 KB Output is correct
13 Correct 5 ms 3664 KB Output is correct
14 Correct 4 ms 3664 KB Output is correct
15 Correct 5 ms 3868 KB Output is correct
16 Correct 5 ms 3792 KB Output is correct
17 Correct 5 ms 3792 KB Output is correct
18 Correct 5 ms 3664 KB Output is correct
19 Correct 7 ms 3824 KB Output is correct
20 Correct 6 ms 3792 KB Output is correct
21 Correct 5 ms 3792 KB Output is correct
22 Correct 5 ms 3792 KB Output is correct
23 Correct 4 ms 3664 KB Output is correct
24 Correct 4 ms 3792 KB Output is correct
25 Correct 3 ms 1744 KB Output is correct
26 Correct 5 ms 3836 KB Output is correct
27 Correct 5 ms 3792 KB Output is correct
28 Correct 6 ms 3792 KB Output is correct
29 Correct 6 ms 3792 KB Output is correct
30 Correct 6 ms 3792 KB Output is correct
31 Correct 5 ms 3920 KB Output is correct
32 Correct 5 ms 3792 KB Output is correct
33 Correct 4 ms 3664 KB Output is correct
34 Correct 7 ms 3836 KB Output is correct
35 Correct 5 ms 3772 KB Output is correct

Subtask #3
12.0 / 12.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 848 KB Output is correct
2 Correct 6 ms 3888 KB Output is correct
3 Correct 6 ms 3832 KB Output is correct
4 Correct 5 ms 3792 KB Output is correct
5 Correct 5 ms 3792 KB Output is correct
6 Correct 6 ms 3836 KB Output is correct
7 Correct 8 ms 3788 KB Output is correct
8 Correct 6 ms 3848 KB Output is correct
9 Correct 5 ms 3664 KB Output is correct
10 Correct 5 ms 3792 KB Output is correct
11 Correct 5 ms 3792 KB Output is correct
12 Correct 0 ms 208 KB Output is correct
13 Correct 5 ms 3664 KB Output is correct
14 Correct 4 ms 3664 KB Output is correct
15 Correct 5 ms 3868 KB Output is correct
16 Correct 5 ms 3792 KB Output is correct
17 Correct 5 ms 3792 KB Output is correct
18 Correct 5 ms 3664 KB Output is correct
19 Correct 7 ms 3824 KB Output is correct
20 Correct 6 ms 3792 KB Output is correct
21 Correct 5 ms 3792 KB Output is correct
22 Correct 5 ms 3792 KB Output is correct
23 Correct 4 ms 3664 KB Output is correct
24 Correct 4 ms 3792 KB Output is correct
25 Correct 3 ms 1744 KB Output is correct
26 Correct 5 ms 3836 KB Output is correct
27 Correct 5 ms 3792 KB Output is correct
28 Correct 6 ms 3792 KB Output is correct
29 Correct 6 ms 3792 KB Output is correct
30 Correct 6 ms 3792 KB Output is correct
31 Correct 5 ms 3920 KB Output is correct
32 Correct 5 ms 3792 KB Output is correct
33 Correct 4 ms 3664 KB Output is correct
34 Correct 7 ms 3836 KB Output is correct
35 Correct 5 ms 3772 KB Output is correct
36 Correct 273 ms 160392 KB Output is correct
37 Correct 435 ms 255704 KB Output is correct
38 Correct 447 ms 255620 KB Output is correct
39 Correct 490 ms 255760 KB Output is correct
40 Correct 425 ms 255624 KB Output is correct
41 Correct 462 ms 255776 KB Output is correct
42 Correct 462 ms 255648 KB Output is correct
43 Correct 275 ms 257632 KB Output is correct
44 Correct 330 ms 251300 KB Output is correct
45 Correct 302 ms 254856 KB Output is correct
46 Correct 280 ms 251308 KB Output is correct
47 Correct 456 ms 255672 KB Output is correct
48 Correct 470 ms 255592 KB Output is correct
49 Correct 440 ms 255576 KB Output is correct
50 Correct 286 ms 251336 KB Output is correct
51 Correct 294 ms 257596 KB Output is correct
52 Correct 482 ms 255696 KB Output is correct
53 Correct 443 ms 255612 KB Output is correct
54 Correct 509 ms 255644 KB Output is correct
55 Correct 274 ms 251348 KB Output is correct
56 Correct 304 ms 257536 KB Output is correct
57 Correct 455 ms 246384 KB Output is correct
58 Correct 437 ms 255700 KB Output is correct
59 Correct 480 ms 255644 KB Output is correct
60 Correct 434 ms 255564 KB Output is correct
61 Correct 442 ms 255640 KB Output is correct
62 Correct 493 ms 255580 KB Output is correct
63 Correct 587 ms 255588 KB Output is correct
64 Correct 313 ms 257700 KB Output is correct
65 Correct 307 ms 251336 KB Output is correct
66 Correct 322 ms 257524 KB Output is correct
67 Correct 285 ms 251336 KB Output is correct

Subtask #4
0 / 14.0

# Verdict Execution time Memory Grader output
1 Execution timed out 4021 ms 253716 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #5
0 / 17.0

# Verdict Execution time Memory Grader output
1 Execution timed out 4045 ms 54712 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #6
0 / 19.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 848 KB Output is correct
2 Correct 6 ms 3888 KB Output is correct
3 Correct 6 ms 3832 KB Output is correct
4 Correct 5 ms 3792 KB Output is correct
5 Correct 5 ms 3792 KB Output is correct
6 Correct 6 ms 3836 KB Output is correct
7 Correct 8 ms 3788 KB Output is correct
8 Correct 6 ms 3848 KB Output is correct
9 Correct 5 ms 3664 KB Output is correct
10 Correct 5 ms 3792 KB Output is correct
11 Correct 5 ms 3792 KB Output is correct
12 Correct 0 ms 208 KB Output is correct
13 Correct 5 ms 3664 KB Output is correct
14 Correct 4 ms 3664 KB Output is correct
15 Correct 5 ms 3868 KB Output is correct
16 Correct 5 ms 3792 KB Output is correct
17 Correct 5 ms 3792 KB Output is correct
18 Correct 5 ms 3664 KB Output is correct
19 Correct 7 ms 3824 KB Output is correct
20 Correct 6 ms 3792 KB Output is correct
21 Correct 5 ms 3792 KB Output is correct
22 Correct 5 ms 3792 KB Output is correct
23 Correct 4 ms 3664 KB Output is correct
24 Correct 4 ms 3792 KB Output is correct
25 Correct 3 ms 1744 KB Output is correct
26 Correct 5 ms 3836 KB Output is correct
27 Correct 5 ms 3792 KB Output is correct
28 Correct 6 ms 3792 KB Output is correct
29 Correct 6 ms 3792 KB Output is correct
30 Correct 6 ms 3792 KB Output is correct
31 Correct 5 ms 3920 KB Output is correct
32 Correct 5 ms 3792 KB Output is correct
33 Correct 4 ms 3664 KB Output is correct
34 Correct 7 ms 3836 KB Output is correct
35 Correct 5 ms 3772 KB Output is correct
36 Correct 273 ms 160392 KB Output is correct
37 Correct 435 ms 255704 KB Output is correct
38 Correct 447 ms 255620 KB Output is correct
39 Correct 490 ms 255760 KB Output is correct
40 Correct 425 ms 255624 KB Output is correct
41 Correct 462 ms 255776 KB Output is correct
42 Correct 462 ms 255648 KB Output is correct
43 Correct 275 ms 257632 KB Output is correct
44 Correct 330 ms 251300 KB Output is correct
45 Correct 302 ms 254856 KB Output is correct
46 Correct 280 ms 251308 KB Output is correct
47 Correct 456 ms 255672 KB Output is correct
48 Correct 470 ms 255592 KB Output is correct
49 Correct 440 ms 255576 KB Output is correct
50 Correct 286 ms 251336 KB Output is correct
51 Correct 294 ms 257596 KB Output is correct
52 Correct 482 ms 255696 KB Output is correct
53 Correct 443 ms 255612 KB Output is correct
54 Correct 509 ms 255644 KB Output is correct
55 Correct 274 ms 251348 KB Output is correct
56 Correct 304 ms 257536 KB Output is correct
57 Correct 455 ms 246384 KB Output is correct
58 Correct 437 ms 255700 KB Output is correct
59 Correct 480 ms 255644 KB Output is correct
60 Correct 434 ms 255564 KB Output is correct
61 Correct 442 ms 255640 KB Output is correct
62 Correct 493 ms 255580 KB Output is correct
63 Correct 587 ms 255588 KB Output is correct
64 Correct 313 ms 257700 KB Output is correct
65 Correct 307 ms 251336 KB Output is correct
66 Correct 322 ms 257524 KB Output is correct
67 Correct 285 ms 251336 KB Output is correct
68 Execution timed out 4021 ms 253716 KB Time limit exceeded
69 Halted 0 ms 0 KB -

Subtask #7
0 / 23.0

# Verdict Execution time Memory Grader output
1 Correct 1432 ms 145936 KB Output is correct
2 Correct 3736 ms 257224 KB Output is correct
3 Correct 3624 ms 257308 KB Output is correct
4 Correct 3461 ms 257544 KB Output is correct
5 Correct 3505 ms 251296 KB Output is correct
6 Execution timed out 4051 ms 257484 KB Time limit exceeded
7 Halted 0 ms 0 KB -