/*
* ___
* _ / _\_
* / | |___|
* | | |
* \_| __ |
* \_/ \_/
* uwu amogus
*/
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
/**
* date : 2020-11-26 16:01:43
*/
#pragma region kyopro_template
#define Nyaan_template
#include <immintrin.h>
#include <bits/stdc++.h>
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define each(x, v) for (auto &x : v)
#define all(v) (v).begin(), (v).end()
#define sz(v) ((int)(v).size())
#define mem(a, val) memset(a, val, sizeof(a))
#define ini(...) \
int __VA_ARGS__; \
in(__VA_ARGS__)
#define inl(...) \
long long __VA_ARGS__; \
in(__VA_ARGS__)
#define ins(...) \
string __VA_ARGS__; \
in(__VA_ARGS__)
#define inc(...) \
char __VA_ARGS__; \
in(__VA_ARGS__)
#define in2(s, t) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i]); \
}
#define in3(s, t, u) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i]); \
}
#define in4(s, t, u, v) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i], v[i]); \
}
#define rep(i, N) for (long long i = 0; i < (long long)(N); i++)
#define repr(i, N) for (long long i = (long long)(N)-1; i >= 0; i--)
#define rep1(i, N) for (long long i = 1; i <= (long long)(N); i++)
#define repr1(i, N) for (long long i = (N); (long long)(i) > 0; i--)
#define reg(i, a, b) for (long long i = (a); i < (b); i++)
#define die(...) \
do { \
out(__VA_ARGS__); \
return; \
} while (0)
using namespace std;
using ll = long long;
template <class T>
using V = vector<T>;
using vi = vector<int>;
using vl = vector<long long>;
using vvi = vector<vector<int>>;
using vd = V<double>;
using vs = V<string>;
using vvl = vector<vector<long long>>;
using P = pair<long long, long long>;
using vp = vector<P>;
using pii = pair<int, int>;
using vpi = vector<pair<int, int>>;
constexpr int inf = 1001001001;
constexpr long long infLL = (1LL << 61) - 1;
template <typename T, typename U>
inline bool amin(T &x, U y) {
return (y < x) ? (x = y, true) : false;
}
template <typename T, typename U>
inline bool amax(T &x, U y) {
return (x < y) ? (x = y, true) : false;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
int s = (int)v.size();
for (int i = 0; i < s; i++) os << (i ? " " : "") << v[i];
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v) is >> x;
return is;
}
void in() {}
template <typename T, class... U>
void in(T &t, U &... u) {
cin >> t;
in(u...);
}
void out() { cout << "\n"; }
template <typename T, class... U>
void out(const T &t, const U &... u) {
cout << t;
if (sizeof...(u)) cout << " ";
out(u...);
}
#ifdef NyaanDebug
#define trc(...) \
do { \
cerr << #__VA_ARGS__ << " = "; \
dbg_out(__VA_ARGS__); \
} while (0)
#define trca(v, N) \
do { \
cerr << #v << " = "; \
array_out(v, N); \
} while (0)
#define trcc(v) \
do { \
cerr << #v << " = {"; \
each(x, v) { cerr << " " << x << ","; } \
cerr << "}" << endl; \
} while (0)
template <typename T>
void _cout(const T &c) {
cerr << c;
}
void _cout(const int &c) {
if (c == 1001001001)
cerr << "inf";
else if (c == -1001001001)
cerr << "-inf";
else
cerr << c;
}
void _cout(const unsigned int &c) {
if (c == 1001001001)
cerr << "inf";
else
cerr << c;
}
void _cout(const long long &c) {
if (c == 1001001001 || c == (1LL << 61) - 1)
cerr << "inf";
else if (c == -1001001001 || c == -((1LL << 61) - 1))
cerr << "-inf";
else
cerr << c;
}
void _cout(const unsigned long long &c) {
if (c == 1001001001 || c == (1LL << 61) - 1)
cerr << "inf";
else
cerr << c;
}
template <typename T, typename U>
void _cout(const pair<T, U> &p) {
cerr << "{ ";
_cout(p.fi);
cerr << ", ";
_cout(p.se);
cerr << " } ";
}
template <typename T>
void _cout(const vector<T> &v) {
int s = v.size();
cerr << "{ ";
for (int i = 0; i < s; i++) {
cerr << (i ? ", " : "");
_cout(v[i]);
}
cerr << " } ";
}
template <typename T>
void _cout(const vector<vector<T>> &v) {
cerr << "[ ";
for (const auto &x : v) {
cerr << endl;
_cout(x);
cerr << ", ";
}
cerr << endl << " ] ";
}
void dbg_out() { cerr << endl; }
template <typename T, class... U>
void dbg_out(const T &t, const U &... u) {
_cout(t);
if (sizeof...(u)) cerr << ", ";
dbg_out(u...);
}
template <typename T>
void array_out(const T &v, int s) {
cerr << "{ ";
for (int i = 0; i < s; i++) {
cerr << (i ? ", " : "");
_cout(v[i]);
}
cerr << " } " << endl;
}
template <typename T>
void array_out(const T &v, int H, int W) {
cerr << "[ ";
for (int i = 0; i < H; i++) {
cerr << (i ? ", " : "");
array_out(v[i], W);
}
cerr << " ] " << endl;
}
#else
#define trc(...)
#define trca(...)
#define trcc(...)
#endif
inline int popcnt(unsigned long long a) { return __builtin_popcountll(a); }
inline int lsb(unsigned long long a) { return __builtin_ctzll(a); }
inline int msb(unsigned long long a) { return 63 - __builtin_clzll(a); }
template <typename T>
inline int getbit(T a, int i) {
return (a >> i) & 1;
}
template <typename T>
inline void setbit(T &a, int i) {
a |= (1LL << i);
}
template <typename T>
inline void delbit(T &a, int i) {
a &= ~(1LL << i);
}
template <typename T>
int lb(const vector<T> &v, const T &a) {
return lower_bound(begin(v), end(v), a) - begin(v);
}
template <typename T>
int ub(const vector<T> &v, const T &a) {
return upper_bound(begin(v), end(v), a) - begin(v);
}
template <typename T>
int btw(T a, T x, T b) {
return a <= x && x < b;
}
template <typename T, typename U>
T ceil(T a, U b) {
return (a + b - 1) / b;
}
constexpr long long TEN(int n) {
long long ret = 1, x = 10;
while (n) {
if (n & 1) ret *= x;
x *= x;
n >>= 1;
}
return ret;
}
template <typename T>
vector<T> mkrui(const vector<T> &v) {
vector<T> ret(v.size() + 1);
for (int i = 0; i < int(v.size()); i++) ret[i + 1] = ret[i] + v[i];
return ret;
};
template <typename T>
vector<T> mkuni(const vector<T> &v) {
vector<T> ret(v);
sort(ret.begin(), ret.end());
ret.erase(unique(ret.begin(), ret.end()), ret.end());
return ret;
}
template <typename F>
vector<int> mkord(int N, F f) {
vector<int> ord(N);
iota(begin(ord), end(ord), 0);
sort(begin(ord), end(ord), f);
return ord;
}
template <typename T = int>
vector<T> mkiota(int N) {
vector<T> ret(N);
iota(begin(ret), end(ret), 0);
return ret;
}
template <typename T>
vector<int> mkinv(vector<T> &v) {
vector<int> inv(v.size());
for (int i = 0; i < (int)v.size(); i++) inv[v[i]] = i;
return inv;
}
struct IoSetupNya {
IoSetupNya() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
cerr << fixed << setprecision(7);
}
} iosetupnya;
#pragma endregion
using namespace std;
template <typename T>
struct BinaryIndexedTree {
int N;
vector<T> data;
BinaryIndexedTree() = default;
BinaryIndexedTree(int size) { init(size); }
void init(int size) {
N = size + 2;
data.assign(N + 1, 0);
}
// get sum of [0,k]
T sum(int k) const {
if (k < 0) return 0; // return 0 if k < 0
T ret = 0;
for (++k; k > 0; k -= k & -k) ret += data[k];
return ret;
}
// getsum of [l,r]
inline T sum(int l, int r) const { return sum(r) - sum(l - 1); }
// get value of k
inline T operator[](int k) const { return sum(k) - sum(k - 1); }
// data[k] += x
void add(int k, T x) {
for (++k; k < N; k += k & -k) data[k] += x;
}
// range add x to [l,r]
void imos(int l, int r, T x) {
add(l, x);
add(r + 1, -x);
}
// minimize i s.t. sum(i) >= w
int lower_bound(T w) {
if (w <= 0) return 0;
int x = 0;
for (int k = 1 << __lg(N); k; k >>= 1) {
if (x + k <= N - 1 && data[x + k] < w) {
w -= data[x + k];
x += k;
}
}
return x;
}
// minimize i s.t. sum(i) > w
int upper_bound(T w) {
if (w < 0) return 0;
int x = 0;
for (int k = 1 << __lg(N); k; k >>= 1) {
if (x + k <= N - 1 && data[x + k] <= w) {
w -= data[x + k];
x += k;
}
}
return x;
}
};
/**
* @brief Binary Indexed Tree(Fenwick Tree)
* @docs docs/data-structure/binary-indexed-tree.md
*/
using namespace std;
namespace StaticGraphImpl {
template <typename T, bool Cond = is_void<T>::value>
struct E;
template <typename T>
struct E<T, false> {
int to;
T cost;
E() {}
E(const int& v, const T& c) : to(v), cost(c) {}
operator int() const { return to; }
};
template <typename T>
struct E<T, true> {
int to;
E() {}
E(const int& v) : to(v) {}
operator int() const { return to; }
};
template <typename T = void>
struct StaticGraph {
private:
template <typename It>
struct Es {
It b, e;
It begin() const { return b; }
It end() const { return e; }
int size() const { return int(e - b); }
};
int N, M, ec;
vector<int> head;
vector<pair<int, E<T>>> buf;
vector<E<T>> es;
void build() {
partial_sum(begin(head), end(head), begin(head));
es.resize(M);
for (auto&& [u, e] : buf) es[--head[u]] = e;
}
public:
StaticGraph(int _n, int _m) : N(_n), M(_m), ec(0), head(N + 1, 0) {
buf.reserve(M);
}
template <typename... Args>
void add_edge(int u, Args&&... args) {
buf.emplace_back(u, E<T>{std::forward<Args>(args)...});
++head[u];
if ((int)buf.size() == M) build();
}
Es<typename vector<E<T>>::iterator> operator[](int u) {
return {begin(es) + head[u], begin(es) + head[u + 1]};
}
const Es<typename vector<E<T>>::const_iterator> operator[](int u) const {
return {begin(es) + head[u], begin(es) + head[u + 1]};
}
int size() const { return N; }
};
} // namespace StaticGraphImpl
using StaticGraphImpl::StaticGraph;
/**
* @brief Static Graph
*/
using namespace std;
namespace fastio {
static constexpr int SZ = 1 << 17;
char ibuf[SZ], obuf[SZ];
int pil = 0, pir = 0, por = 0;
struct Pre {
char num[40000];
constexpr Pre() : num() {
for (int i = 0; i < 10000; i++) {
int n = i;
for (int j = 3; j >= 0; j--) {
num[i * 4 + j] = n % 10 + '0';
n /= 10;
}
}
}
} constexpr pre;
inline void load() {
memcpy(ibuf, ibuf + pil, pir - pil);
pir = pir - pil + fread(ibuf + pir - pil, 1, SZ - pir + pil, stdin);
pil = 0;
}
inline void flush() {
fwrite(obuf, 1, por, stdout);
por = 0;
}
inline void rd(char& c) { c = ibuf[pil++]; }
template <typename T>
inline void rd(T& x) {
if (pil + 32 > pir) load();
char c;
do
c = ibuf[pil++];
while (c < '-');
bool minus = 0;
if (c == '-') {
minus = 1;
c = ibuf[pil++];
}
x = 0;
while (c >= '0') {
x = x * 10 + (c & 15);
c = ibuf[pil++];
}
if (minus) x = -x;
}
inline void rd() {}
template <typename Head, typename... Tail>
inline void rd(Head& head, Tail&... tail) {
rd(head);
rd(tail...);
}
inline void wt(char c) { obuf[por++] = c; }
template <typename T>
inline void wt(T x) {
if (por > SZ - 32) flush();
if (!x) {
obuf[por++] = '0';
return;
}
if (x < 0) {
obuf[por++] = '-';
x = -x;
}
int i = 12;
char buf[16];
while (x >= 10000) {
memcpy(buf + i, pre.num + (x % 10000) * 4, 4);
x /= 10000;
i -= 4;
}
if (x < 100) {
if (x < 10) {
wt(char('0' + char(x)));
} else {
uint32_t q = (uint32_t(x) * 205) >> 11;
uint32_t r = uint32_t(x) - q * 10;
obuf[por + 0] = '0' + q;
obuf[por + 1] = '0' + r;
por += 2;
}
} else {
if (x < 1000) {
memcpy(obuf + por, pre.num + (x << 2) + 1, 3);
por += 3;
} else {
memcpy(obuf + por, pre.num + (x << 2), 4);
por += 4;
}
}
memcpy(obuf + por, buf + i + 4, 12 - i);
por += 12 - i;
}
inline void wt() {}
template <typename Head, typename... Tail>
inline void wt(Head head, Tail... tail) {
wt(head);
wt(tail...);
}
template <typename T>
inline void wtn(T x) {
wt(x, '\n');
}
struct Dummy {
Dummy() { atexit(flush); }
} dummy;
} // namespace fastio
using fastio::rd;
using fastio::wt;
using fastio::wtn;
using namespace std;
using namespace std;
template <typename T>
struct edge {
int src, to;
T cost;
edge(int _to, T _cost) : src(-1), to(_to), cost(_cost) {}
edge(int _src, int _to, T _cost) : src(_src), to(_to), cost(_cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T>
using Edges = vector<edge<T>>;
template <typename T>
using WeightedGraph = vector<Edges<T>>;
using UnweightedGraph = vector<vector<int>>;
// Input of (Unweighted) Graph
UnweightedGraph graph(int N, int M = -1, bool is_directed = false,
bool is_1origin = true) {
UnweightedGraph g(N);
if (M == -1) M = N - 1;
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
if (is_1origin) x--, y--;
g[x].push_back(y);
if (!is_directed) g[y].push_back(x);
}
return g;
}
// Input of Weighted Graph
template <typename T>
WeightedGraph<T> wgraph(int N, int M = -1, bool is_directed = false,
bool is_1origin = true) {
WeightedGraph<T> g(N);
if (M == -1) M = N - 1;
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
T c;
cin >> c;
if (is_1origin) x--, y--;
g[x].eb(x, y, c);
if (!is_directed) g[y].eb(y, x, c);
}
return g;
}
// Input of Edges
template <typename T>
Edges<T> esgraph(int N, int M, int is_weighted = true, bool is_1origin = true) {
Edges<T> es;
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
T c;
if (is_weighted)
cin >> c;
else
c = 1;
if (is_1origin) x--, y--;
es.emplace_back(x, y, c);
}
return es;
}
// Input of Adjacency Matrix
template <typename T>
vector<vector<T>> adjgraph(int N, int M, T INF, int is_weighted = true,
bool is_directed = false, bool is_1origin = true) {
vector<vector<T>> d(N, vector<T>(N, INF));
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
T c;
if (is_weighted)
cin >> c;
else
c = 1;
if (is_1origin) x--, y--;
d[x][y] = c;
if (!is_directed) d[y][x] = c;
}
return d;
}
template <typename G>
struct EulerTour {
private:
struct RMQ {
int s;
using P = pair<int, int>;
vector<P> seg;
P UNIT = P(1 << 30, -1);
RMQ(int N) : s(1) {
while (s < N) s <<= 1;
seg.assign(2 * s, UNIT);
}
void set(int k, P x) { seg[k + s] = x; }
P operator[](int k) const { return seg[k + s]; }
void build() {
for (int k = s - 1; k > 0; k--) {
seg[k] = min(seg[2 * k], seg[2 * k + 1]);
}
}
P query(int a, int b) const {
P R = UNIT;
for (a += s, b += s; a < b; a >>= 1, b >>= 1) {
if (a & 1) R = min(R, seg[a++]);
if (b & 1) R = min(R, seg[--b]);
}
return R;
}
int size() const { return s; }
};
vector<int> down, up;
int id;
RMQ rmq;
void init(G &g, int root) {
rmq.set(id++, {-1, -1});
dfs(g, root, -1, 0);
for (int i = 0; i < (int)g.size(); i++) {
if (down[i] == -1) {
rmq.set(id++, {-1, -1});
dfs(g, i, -1, 0);
}
}
rmq.build();
}
void dfs(G &g, int c, int p, int dp) {
down[c] = id;
rmq.set(id++, {dp, c});
for (auto &d : g[c]) {
if (d == p) continue;
dfs(g, d, c, dp + 1);
}
up[c] = id;
rmq.set(id++, {dp - 1, p});
}
public:
// remind : because of additional node,
// DS on tour should reserve 2 * n + 2 nodes.
EulerTour(G &g, int root = 0)
: down(g.size(), -1), up(g.size(), -1), id(0), rmq(2 * g.size() + 2) {
init(g, root);
trc(down);
trc(up);
}
pair<int, int> idx(int i) const { return {down[i], up[i]}; }
int lca(int a, int b) const {
if (down[a] > down[b]) swap(a, b);
return rmq.query(down[a], down[b] + 1).second;
}
template <typename F>
void node_query(int a, int b, F &f) {
int l = lca(a, b);
f(down[l], down[a] + 1);
f(down[l] + 1, down[b] + 1);
}
template <typename F>
void edge_query(int a, int b, F &f) {
int l = lca(a, b);
f(down[l] + 1, down[a] + 1);
f(down[l] + 1, down[b] + 1);
}
int size() const { return int(rmq.size()); }
};
using namespace std;
#define ll long long
#define inf 0x7FFFFFFF
#define llinf 0x7FFFFFFFFFFFFFFF
#define ff first
#define ss second
#define FOR(i, a, b) for(int i = a; i < b; i++)
#define ROF(i, a, b) for(int i = a - 1; i >= b; i--)
//#define assert void
//#pragma GCC optimize("O3")
//#pragma GCC optimize("unroll-loops")
//#define int ll
struct dsu {
dsu(int n) {
p.resize(n, -1);
pp.resize(n); for (int i = 0; i < n; i++) pp[i] = i;
r.resize(n, 0);
}
inline int par(int x) {
return pp[_par(x)];
}
inline int _par(int x) {
return p[x] == -1 ? x : p[x] = _par(p[x]);
}
inline void merge(int a, int b) {
a = _par(a); b = _par(b);
if (a == b)return;
if (r[a] < r[b]) {
swap(a, b);
swap(pp[a], pp[b]);
}
if (r[a] == r[b]) r[a]++;
p[b] = a;
}
vector<int> p, r, pp;
};
signed main() {
ios_base::sync_with_stdio(false); cin.tie(NULL);
int N, D, T; rd(N, D, T);
vector<int> t(N);
for (int i = 0; i < N; i++)
rd(t[i]);
int l = 0, r = 2e6, m = 0;
int ans = 0;
while (l < r) {//aliens HAHAHAhaha ha ha :sob:
m = (l + r) / 2;
vector<pair<int,int>> st; st.reserve(N);
struct node {
int p = -1;//prev
int n = -1;//next
int lz = 0;
double v = 0;
int c = 0; // count owo!!!
node() {};
node(double v, int c) : v(v), c(c) {};
};
vector<node> st2; st2.reserve(N);
dsu pls(N);
int start = 0;
int amt = 0;//amount added
function<void(int)> kill = [&](int i) {
int n = st2[i].n;
//assert(n != -1);
if (n == -1) return;
if ((st2[i].v + (double)st2[i].lz > st2[n].v)) {
int p = st2[i].p;
st2[n].p = p;
if (p != -1) {
st2[p].lz += st2[i].lz;
st2[p].n = n;
pls.merge(p, i); //merge i to p
kill(p);
}
else {
// DEAD
amt -= st2[i].lz; //recycle owo
start = n;
}
}
};
for (int i = 0; i < N; i++) {
//create and then upd
if (st2.size()) {
st2.push_back(node(st2[start].v + (double)amt + m, st2[start].c+1));
st2[i - 1].n = i; st2[i].p = i - 1;
kill(i - 1);
}
else {
st2.push_back(node());
}
int o = i;
if (t[i] <= T) {
while (st.size() && st.back().ff >= t[i] - i) {
st.pop_back();
}
st.push_back({ t[i] - i, i});
}
else {
while (st.size() && st.back().ff > T - i) st.pop_back();
if (st.size()) {
o = st.back().ss;
}
else o = -1;
}
//cout << o << ",";
if(o >= start){
int t = pls.par(o);
st2[t].lz++; amt++;
kill(t);
}
//cout << amt << ",";
}
//cout << endl;
int c = st2[start].c;
//cout << c << endl;
if (c <= D) {
r = m;
ans = round((double)st2[start].v + (double)amt - (double)D * m);
}
else {
//cout << "fuck" << endl;
l = m + 1;
}
}
cout << ans << endl;
// n log n inverse ackermann n please pass i swear to god
}
Compilation message
prison.cpp:17: warning: ignoring '#pragma region kyopro_template' [-Wunknown-pragmas]
17 | #pragma region kyopro_template
|
prison.cpp:314: warning: ignoring '#pragma endregion ' [-Wunknown-pragmas]
314 | #pragma endregion
|
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
1 ms |
348 KB |
Output is correct |
2 |
Correct |
1 ms |
468 KB |
Output is correct |
3 |
Correct |
1 ms |
348 KB |
Output is correct |
4 |
Correct |
2 ms |
348 KB |
Output is correct |
5 |
Correct |
1 ms |
348 KB |
Output is correct |
6 |
Correct |
1 ms |
348 KB |
Output is correct |
7 |
Correct |
1 ms |
348 KB |
Output is correct |
8 |
Correct |
1 ms |
348 KB |
Output is correct |
9 |
Correct |
1 ms |
348 KB |
Output is correct |
10 |
Correct |
1 ms |
472 KB |
Output is correct |
11 |
Correct |
1 ms |
348 KB |
Output is correct |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
0 ms |
348 KB |
Output is correct |
2 |
Correct |
546 ms |
26892 KB |
Output is correct |
3 |
Correct |
533 ms |
26704 KB |
Output is correct |
4 |
Correct |
520 ms |
31232 KB |
Output is correct |
5 |
Correct |
485 ms |
25364 KB |
Output is correct |
6 |
Correct |
395 ms |
37336 KB |
Output is correct |
7 |
Correct |
578 ms |
85564 KB |
Output is correct |
8 |
Correct |
391 ms |
27244 KB |
Output is correct |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
1 ms |
348 KB |
Output is correct |
2 |
Correct |
1 ms |
468 KB |
Output is correct |
3 |
Correct |
1 ms |
348 KB |
Output is correct |
4 |
Correct |
2 ms |
348 KB |
Output is correct |
5 |
Correct |
1 ms |
348 KB |
Output is correct |
6 |
Correct |
1 ms |
348 KB |
Output is correct |
7 |
Correct |
1 ms |
348 KB |
Output is correct |
8 |
Correct |
1 ms |
348 KB |
Output is correct |
9 |
Correct |
1 ms |
348 KB |
Output is correct |
10 |
Correct |
1 ms |
472 KB |
Output is correct |
11 |
Correct |
1 ms |
348 KB |
Output is correct |
12 |
Correct |
0 ms |
348 KB |
Output is correct |
13 |
Correct |
1 ms |
348 KB |
Output is correct |
14 |
Correct |
1 ms |
344 KB |
Output is correct |
15 |
Correct |
1 ms |
348 KB |
Output is correct |
16 |
Correct |
2 ms |
348 KB |
Output is correct |
17 |
Correct |
1 ms |
344 KB |
Output is correct |
18 |
Correct |
1 ms |
344 KB |
Output is correct |
19 |
Correct |
1 ms |
344 KB |
Output is correct |
20 |
Correct |
2 ms |
348 KB |
Output is correct |
21 |
Correct |
1 ms |
344 KB |
Output is correct |
22 |
Correct |
1 ms |
344 KB |
Output is correct |
23 |
Correct |
5 ms |
604 KB |
Output is correct |
24 |
Correct |
6 ms |
504 KB |
Output is correct |
25 |
Correct |
4 ms |
604 KB |
Output is correct |
26 |
Correct |
4 ms |
604 KB |
Output is correct |
27 |
Correct |
6 ms |
604 KB |
Output is correct |
28 |
Correct |
4 ms |
604 KB |
Output is correct |
29 |
Correct |
6 ms |
604 KB |
Output is correct |
30 |
Correct |
3 ms |
600 KB |
Output is correct |
31 |
Correct |
3 ms |
604 KB |
Output is correct |
32 |
Correct |
3 ms |
604 KB |
Output is correct |
33 |
Correct |
3 ms |
600 KB |
Output is correct |
34 |
Correct |
5 ms |
600 KB |
Output is correct |
35 |
Correct |
6 ms |
600 KB |
Output is correct |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
1 ms |
344 KB |
Output is correct |
2 |
Correct |
72 ms |
4836 KB |
Output is correct |
3 |
Correct |
77 ms |
4788 KB |
Output is correct |
4 |
Correct |
50 ms |
4444 KB |
Output is correct |
5 |
Correct |
56 ms |
8104 KB |
Output is correct |
6 |
Correct |
42 ms |
7204 KB |
Output is correct |
7 |
Correct |
51 ms |
6776 KB |
Output is correct |
8 |
Correct |
74 ms |
8284 KB |
Output is correct |
9 |
Correct |
65 ms |
13768 KB |
Output is correct |
10 |
Correct |
60 ms |
4736 KB |
Output is correct |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
1 ms |
348 KB |
Output is correct |
2 |
Correct |
1 ms |
468 KB |
Output is correct |
3 |
Correct |
1 ms |
348 KB |
Output is correct |
4 |
Correct |
2 ms |
348 KB |
Output is correct |
5 |
Correct |
1 ms |
348 KB |
Output is correct |
6 |
Correct |
1 ms |
348 KB |
Output is correct |
7 |
Correct |
1 ms |
348 KB |
Output is correct |
8 |
Correct |
1 ms |
348 KB |
Output is correct |
9 |
Correct |
1 ms |
348 KB |
Output is correct |
10 |
Correct |
1 ms |
472 KB |
Output is correct |
11 |
Correct |
1 ms |
348 KB |
Output is correct |
12 |
Correct |
0 ms |
348 KB |
Output is correct |
13 |
Correct |
1 ms |
348 KB |
Output is correct |
14 |
Correct |
1 ms |
344 KB |
Output is correct |
15 |
Correct |
1 ms |
348 KB |
Output is correct |
16 |
Correct |
2 ms |
348 KB |
Output is correct |
17 |
Correct |
1 ms |
344 KB |
Output is correct |
18 |
Correct |
1 ms |
344 KB |
Output is correct |
19 |
Correct |
1 ms |
344 KB |
Output is correct |
20 |
Correct |
2 ms |
348 KB |
Output is correct |
21 |
Correct |
1 ms |
344 KB |
Output is correct |
22 |
Correct |
1 ms |
344 KB |
Output is correct |
23 |
Correct |
5 ms |
604 KB |
Output is correct |
24 |
Correct |
6 ms |
504 KB |
Output is correct |
25 |
Correct |
4 ms |
604 KB |
Output is correct |
26 |
Correct |
4 ms |
604 KB |
Output is correct |
27 |
Correct |
6 ms |
604 KB |
Output is correct |
28 |
Correct |
4 ms |
604 KB |
Output is correct |
29 |
Correct |
6 ms |
604 KB |
Output is correct |
30 |
Correct |
3 ms |
600 KB |
Output is correct |
31 |
Correct |
3 ms |
604 KB |
Output is correct |
32 |
Correct |
3 ms |
604 KB |
Output is correct |
33 |
Correct |
3 ms |
600 KB |
Output is correct |
34 |
Correct |
5 ms |
600 KB |
Output is correct |
35 |
Correct |
6 ms |
600 KB |
Output is correct |
36 |
Correct |
1 ms |
344 KB |
Output is correct |
37 |
Correct |
72 ms |
4836 KB |
Output is correct |
38 |
Correct |
77 ms |
4788 KB |
Output is correct |
39 |
Correct |
50 ms |
4444 KB |
Output is correct |
40 |
Correct |
56 ms |
8104 KB |
Output is correct |
41 |
Correct |
42 ms |
7204 KB |
Output is correct |
42 |
Correct |
51 ms |
6776 KB |
Output is correct |
43 |
Correct |
74 ms |
8284 KB |
Output is correct |
44 |
Correct |
65 ms |
13768 KB |
Output is correct |
45 |
Correct |
60 ms |
4736 KB |
Output is correct |
46 |
Correct |
0 ms |
344 KB |
Output is correct |
47 |
Correct |
1 ms |
476 KB |
Output is correct |
48 |
Correct |
1 ms |
348 KB |
Output is correct |
49 |
Correct |
1 ms |
468 KB |
Output is correct |
50 |
Correct |
1 ms |
508 KB |
Output is correct |
51 |
Correct |
1 ms |
352 KB |
Output is correct |
52 |
Correct |
1 ms |
352 KB |
Output is correct |
53 |
Correct |
1 ms |
608 KB |
Output is correct |
54 |
Correct |
1 ms |
348 KB |
Output is correct |
55 |
Correct |
1 ms |
616 KB |
Output is correct |
56 |
Correct |
1 ms |
356 KB |
Output is correct |
57 |
Correct |
6 ms |
740 KB |
Output is correct |
58 |
Correct |
4 ms |
616 KB |
Output is correct |
59 |
Correct |
4 ms |
752 KB |
Output is correct |
60 |
Correct |
5 ms |
740 KB |
Output is correct |
61 |
Correct |
6 ms |
744 KB |
Output is correct |
62 |
Correct |
5 ms |
604 KB |
Output is correct |
63 |
Correct |
5 ms |
504 KB |
Output is correct |
64 |
Correct |
3 ms |
608 KB |
Output is correct |
65 |
Correct |
4 ms |
604 KB |
Output is correct |
66 |
Correct |
2 ms |
692 KB |
Output is correct |
67 |
Correct |
3 ms |
608 KB |
Output is correct |
68 |
Correct |
5 ms |
472 KB |
Output is correct |
69 |
Correct |
4 ms |
608 KB |
Output is correct |
70 |
Correct |
1 ms |
356 KB |
Output is correct |
71 |
Correct |
79 ms |
4872 KB |
Output is correct |
72 |
Correct |
77 ms |
4876 KB |
Output is correct |
73 |
Correct |
59 ms |
4464 KB |
Output is correct |
74 |
Correct |
46 ms |
7908 KB |
Output is correct |
75 |
Correct |
57 ms |
7208 KB |
Output is correct |
76 |
Correct |
56 ms |
6840 KB |
Output is correct |
77 |
Correct |
59 ms |
8284 KB |
Output is correct |
78 |
Correct |
63 ms |
13632 KB |
Output is correct |
79 |
Correct |
42 ms |
4748 KB |
Output is correct |
80 |
Correct |
81 ms |
4836 KB |
Output is correct |
81 |
Correct |
77 ms |
4864 KB |
Output is correct |
82 |
Correct |
82 ms |
4944 KB |
Output is correct |
83 |
Correct |
66 ms |
6408 KB |
Output is correct |
84 |
Correct |
76 ms |
4308 KB |
Output is correct |
85 |
Correct |
49 ms |
6188 KB |
Output is correct |
86 |
Correct |
53 ms |
5796 KB |
Output is correct |
87 |
Correct |
50 ms |
5040 KB |
Output is correct |
88 |
Correct |
55 ms |
12828 KB |
Output is correct |
89 |
Correct |
72 ms |
13492 KB |
Output is correct |
90 |
Correct |
63 ms |
11284 KB |
Output is correct |
# |
Verdict |
Execution time |
Memory |
Grader output |
1 |
Correct |
1 ms |
348 KB |
Output is correct |
2 |
Correct |
1 ms |
468 KB |
Output is correct |
3 |
Correct |
1 ms |
348 KB |
Output is correct |
4 |
Correct |
2 ms |
348 KB |
Output is correct |
5 |
Correct |
1 ms |
348 KB |
Output is correct |
6 |
Correct |
1 ms |
348 KB |
Output is correct |
7 |
Correct |
1 ms |
348 KB |
Output is correct |
8 |
Correct |
1 ms |
348 KB |
Output is correct |
9 |
Correct |
1 ms |
348 KB |
Output is correct |
10 |
Correct |
1 ms |
472 KB |
Output is correct |
11 |
Correct |
1 ms |
348 KB |
Output is correct |
12 |
Correct |
0 ms |
348 KB |
Output is correct |
13 |
Correct |
546 ms |
26892 KB |
Output is correct |
14 |
Correct |
533 ms |
26704 KB |
Output is correct |
15 |
Correct |
520 ms |
31232 KB |
Output is correct |
16 |
Correct |
485 ms |
25364 KB |
Output is correct |
17 |
Correct |
395 ms |
37336 KB |
Output is correct |
18 |
Correct |
578 ms |
85564 KB |
Output is correct |
19 |
Correct |
391 ms |
27244 KB |
Output is correct |
20 |
Correct |
0 ms |
348 KB |
Output is correct |
21 |
Correct |
1 ms |
348 KB |
Output is correct |
22 |
Correct |
1 ms |
344 KB |
Output is correct |
23 |
Correct |
1 ms |
348 KB |
Output is correct |
24 |
Correct |
2 ms |
348 KB |
Output is correct |
25 |
Correct |
1 ms |
344 KB |
Output is correct |
26 |
Correct |
1 ms |
344 KB |
Output is correct |
27 |
Correct |
1 ms |
344 KB |
Output is correct |
28 |
Correct |
2 ms |
348 KB |
Output is correct |
29 |
Correct |
1 ms |
344 KB |
Output is correct |
30 |
Correct |
1 ms |
344 KB |
Output is correct |
31 |
Correct |
5 ms |
604 KB |
Output is correct |
32 |
Correct |
6 ms |
504 KB |
Output is correct |
33 |
Correct |
4 ms |
604 KB |
Output is correct |
34 |
Correct |
4 ms |
604 KB |
Output is correct |
35 |
Correct |
6 ms |
604 KB |
Output is correct |
36 |
Correct |
4 ms |
604 KB |
Output is correct |
37 |
Correct |
6 ms |
604 KB |
Output is correct |
38 |
Correct |
3 ms |
600 KB |
Output is correct |
39 |
Correct |
3 ms |
604 KB |
Output is correct |
40 |
Correct |
3 ms |
604 KB |
Output is correct |
41 |
Correct |
3 ms |
600 KB |
Output is correct |
42 |
Correct |
5 ms |
600 KB |
Output is correct |
43 |
Correct |
6 ms |
600 KB |
Output is correct |
44 |
Correct |
1 ms |
344 KB |
Output is correct |
45 |
Correct |
72 ms |
4836 KB |
Output is correct |
46 |
Correct |
77 ms |
4788 KB |
Output is correct |
47 |
Correct |
50 ms |
4444 KB |
Output is correct |
48 |
Correct |
56 ms |
8104 KB |
Output is correct |
49 |
Correct |
42 ms |
7204 KB |
Output is correct |
50 |
Correct |
51 ms |
6776 KB |
Output is correct |
51 |
Correct |
74 ms |
8284 KB |
Output is correct |
52 |
Correct |
65 ms |
13768 KB |
Output is correct |
53 |
Correct |
60 ms |
4736 KB |
Output is correct |
54 |
Correct |
0 ms |
344 KB |
Output is correct |
55 |
Correct |
1 ms |
476 KB |
Output is correct |
56 |
Correct |
1 ms |
348 KB |
Output is correct |
57 |
Correct |
1 ms |
468 KB |
Output is correct |
58 |
Correct |
1 ms |
508 KB |
Output is correct |
59 |
Correct |
1 ms |
352 KB |
Output is correct |
60 |
Correct |
1 ms |
352 KB |
Output is correct |
61 |
Correct |
1 ms |
608 KB |
Output is correct |
62 |
Correct |
1 ms |
348 KB |
Output is correct |
63 |
Correct |
1 ms |
616 KB |
Output is correct |
64 |
Correct |
1 ms |
356 KB |
Output is correct |
65 |
Correct |
6 ms |
740 KB |
Output is correct |
66 |
Correct |
4 ms |
616 KB |
Output is correct |
67 |
Correct |
4 ms |
752 KB |
Output is correct |
68 |
Correct |
5 ms |
740 KB |
Output is correct |
69 |
Correct |
6 ms |
744 KB |
Output is correct |
70 |
Correct |
5 ms |
604 KB |
Output is correct |
71 |
Correct |
5 ms |
504 KB |
Output is correct |
72 |
Correct |
3 ms |
608 KB |
Output is correct |
73 |
Correct |
4 ms |
604 KB |
Output is correct |
74 |
Correct |
2 ms |
692 KB |
Output is correct |
75 |
Correct |
3 ms |
608 KB |
Output is correct |
76 |
Correct |
5 ms |
472 KB |
Output is correct |
77 |
Correct |
4 ms |
608 KB |
Output is correct |
78 |
Correct |
1 ms |
356 KB |
Output is correct |
79 |
Correct |
79 ms |
4872 KB |
Output is correct |
80 |
Correct |
77 ms |
4876 KB |
Output is correct |
81 |
Correct |
59 ms |
4464 KB |
Output is correct |
82 |
Correct |
46 ms |
7908 KB |
Output is correct |
83 |
Correct |
57 ms |
7208 KB |
Output is correct |
84 |
Correct |
56 ms |
6840 KB |
Output is correct |
85 |
Correct |
59 ms |
8284 KB |
Output is correct |
86 |
Correct |
63 ms |
13632 KB |
Output is correct |
87 |
Correct |
42 ms |
4748 KB |
Output is correct |
88 |
Correct |
81 ms |
4836 KB |
Output is correct |
89 |
Correct |
77 ms |
4864 KB |
Output is correct |
90 |
Correct |
82 ms |
4944 KB |
Output is correct |
91 |
Correct |
66 ms |
6408 KB |
Output is correct |
92 |
Correct |
76 ms |
4308 KB |
Output is correct |
93 |
Correct |
49 ms |
6188 KB |
Output is correct |
94 |
Correct |
53 ms |
5796 KB |
Output is correct |
95 |
Correct |
50 ms |
5040 KB |
Output is correct |
96 |
Correct |
55 ms |
12828 KB |
Output is correct |
97 |
Correct |
72 ms |
13492 KB |
Output is correct |
98 |
Correct |
63 ms |
11284 KB |
Output is correct |
99 |
Correct |
0 ms |
484 KB |
Output is correct |
100 |
Correct |
1 ms |
624 KB |
Output is correct |
101 |
Correct |
1 ms |
360 KB |
Output is correct |
102 |
Correct |
1 ms |
360 KB |
Output is correct |
103 |
Correct |
1 ms |
360 KB |
Output is correct |
104 |
Correct |
1 ms |
360 KB |
Output is correct |
105 |
Correct |
1 ms |
632 KB |
Output is correct |
106 |
Correct |
1 ms |
476 KB |
Output is correct |
107 |
Correct |
1 ms |
360 KB |
Output is correct |
108 |
Correct |
1 ms |
360 KB |
Output is correct |
109 |
Correct |
1 ms |
360 KB |
Output is correct |
110 |
Correct |
0 ms |
360 KB |
Output is correct |
111 |
Correct |
534 ms |
26904 KB |
Output is correct |
112 |
Correct |
525 ms |
26800 KB |
Output is correct |
113 |
Correct |
491 ms |
32672 KB |
Output is correct |
114 |
Correct |
468 ms |
25360 KB |
Output is correct |
115 |
Correct |
390 ms |
37332 KB |
Output is correct |
116 |
Correct |
577 ms |
85580 KB |
Output is correct |
117 |
Correct |
383 ms |
27168 KB |
Output is correct |
118 |
Correct |
5 ms |
608 KB |
Output is correct |
119 |
Correct |
5 ms |
612 KB |
Output is correct |
120 |
Correct |
4 ms |
760 KB |
Output is correct |
121 |
Correct |
7 ms |
608 KB |
Output is correct |
122 |
Correct |
4 ms |
612 KB |
Output is correct |
123 |
Correct |
6 ms |
612 KB |
Output is correct |
124 |
Correct |
6 ms |
608 KB |
Output is correct |
125 |
Correct |
5 ms |
612 KB |
Output is correct |
126 |
Correct |
5 ms |
600 KB |
Output is correct |
127 |
Correct |
2 ms |
612 KB |
Output is correct |
128 |
Correct |
3 ms |
756 KB |
Output is correct |
129 |
Correct |
4 ms |
616 KB |
Output is correct |
130 |
Correct |
4 ms |
608 KB |
Output is correct |
131 |
Correct |
0 ms |
360 KB |
Output is correct |
132 |
Correct |
79 ms |
4848 KB |
Output is correct |
133 |
Correct |
81 ms |
4868 KB |
Output is correct |
134 |
Correct |
52 ms |
4656 KB |
Output is correct |
135 |
Correct |
57 ms |
7872 KB |
Output is correct |
136 |
Correct |
40 ms |
7108 KB |
Output is correct |
137 |
Correct |
52 ms |
6724 KB |
Output is correct |
138 |
Correct |
58 ms |
8272 KB |
Output is correct |
139 |
Correct |
74 ms |
13580 KB |
Output is correct |
140 |
Correct |
61 ms |
4748 KB |
Output is correct |
141 |
Correct |
80 ms |
4860 KB |
Output is correct |
142 |
Correct |
71 ms |
4848 KB |
Output is correct |
143 |
Correct |
83 ms |
4844 KB |
Output is correct |
144 |
Correct |
77 ms |
6544 KB |
Output is correct |
145 |
Correct |
74 ms |
4316 KB |
Output is correct |
146 |
Correct |
49 ms |
6180 KB |
Output is correct |
147 |
Correct |
53 ms |
5612 KB |
Output is correct |
148 |
Correct |
51 ms |
5056 KB |
Output is correct |
149 |
Correct |
62 ms |
12944 KB |
Output is correct |
150 |
Correct |
66 ms |
13496 KB |
Output is correct |
151 |
Correct |
49 ms |
11256 KB |
Output is correct |
152 |
Execution timed out |
2077 ms |
104772 KB |
Time limit exceeded |
153 |
Halted |
0 ms |
0 KB |
- |