oj.uz

Submission #650895

# Submission time Handle Problem Language Result Execution time Memory
650895 2022-10-16T03:36:35 Z Benq Uplifting Excursion (BOI22_vault) C++17
55 / 100
 5000 ms 319304 KB 
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <vector>
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 = (int)1e9 + 7; // 998244353;
const int MX = (int)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;
} // namespace Helpers

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__);
} // namespace Input

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;
}
} // namespace ToString

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)
} // namespace Output

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
}
} // namespace FileIO

// conditions:
// <M unused out of negatives or <M unused out of positives
// you can split at some positive index such that <M unused on both sides

int M;

void add_min(vi &dp, int sum, int num) {
	assert(num > 0);
	if (sum > 0) {
		R0F(i, sz(dp) - sum) {
			if (dp[i] != M) ckmin(dp[i + sum], dp[i] + num);
		}

	} else {
		FOR(i, -sum, sz(dp)) {
			if (dp[i] != M) ckmin(dp[i + sum], dp[i] + num);
		}
	}
}

void add_max(vi &dp, int sum, int num) {
	if (sum > 0) {
		// dbg("ADD MAX", sum, num);
		R0F(i, sz(dp) - sum) {
			if (dp[i] != -1) ckmax(dp[i + sum], dp[i] + num);
		}
		// dbg("DONE MAX", sum, num);
	} else {
		FOR(i, -sum, sz(dp)) {
			if (dp[i] != -1) ckmax(dp[i + sum], dp[i] + num);
		}
	}
}

ll ans = -1;

void add_min_all(vi &v, int x, ll num) {
	ckmin(num, (ll)M - 1);
	// dbg("add min all", x, num);
	for (int j = 1;; j *= 2) {
		ckmin(j, (int)num);
		if (j == 0) break;
		num -= j;
		add_min(v, j * x, j);
	}
}

void add_max_all(vi &v, int x, ll num) {
	ckmin(num, (ll)M - 1);
	for (int j = 1;; j *= 2) {
		ckmin(j, (int)num);
		if (j == 0) break;
		num -= j;
		add_max(v, j * x, j);
	}
}

void solve(vl A, ll L) {
	V<vi> psums(M + 1, vi(2 * M * M + 1, M));
	psums.ft.at(M * M) = 0;
	FOR(x, -M, 0) { add_min_all(psums.at(0), x, A.at(x + M)); }
	FOR(x, 1, M + 1) {
		psums.at(x) = psums.at(x - 1);
		add_min_all(psums.at(x), x, A.at(x + M));
	}
	V<vi> suf_sums(M + 2, vi(M * M, -1));
	suf_sums.bk.at(0) = 0;
	ROF(x, 1, M + 1) {
		suf_sums.at(x) = suf_sums.at(x + 1);
		add_max_all(suf_sums.at(x), x, A.at(x + M));
	}
	ll sum_so_far = 0, num_so_far = 0;
	FOR(i, -M, 1) {
		sum_so_far += A.at(i + M) * i;
		num_so_far += A.at(i + M);
	}
	dbg(sum_so_far, num_so_far);
	FOR(x, 1, M + 1) {
		// sum_so_far - i + ? * x + j = L
		FOR(i, -M * M, M * x) if (psums.at(x - 1).at(i + M * M) < M) {
			ll rem = L - sum_so_far + i; // 5 - ()
			if (rem < 0) continue;
			for (int j = rem % x; j < M * M && rem - j >= 0; j += x)
				if (suf_sums.at(x + 1).at(j) != -1) {
					ll need_x = (rem - j) / x;
					if (need_x <= A.at(x + M)) {
						if (ckmax(ans, num_so_far -
										   psums.at(x - 1).at(i + M * M) +
										   suf_sums.at(x + 1).at(j) + need_x)) {
							// dbg("AH", ans, A, need_x, rem, L, sum_so_far);
							// dbg(num_so_far, psums.at(x - 1).at(i + M * M),
							// 	suf_sums.at(x + 1).at(j), need_x);
							// i,
							// 		psums.at(x - 1).at(i + M * M),
							// 		suf_sums.at(x + 1).at(j));
						}
					}
				}
		}
		sum_so_far += A.at(x + M) * x;
		num_so_far += A.at(x + M);
	}
}

int main() {
	// read read read
	setIO();
	re(M);
	ll L;
	re(L);
	vl A(2 * M + 1);
	re(A);
	solve(A, L);
	reverse(all(A));
	solve(A, -L);
	if (ans == -1) ps("impossible");
	else ps(ans);

	// everything < M*M:

	// you should actually read the stuff at the bottom
}

/* 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
 */

Compilation message

vault.cpp: In function 'void solve(vl, ll)':
vault.cpp:303:18: warning: statement has no effect [-Wunused-value]
  303 | #define dbg(...) 0
      |                  ^
vault.cpp:399:2: note: in expansion of macro 'dbg'
  399 |  dbg(sum_so_far, num_so_far);
      |  ^~~
vault.cpp: In function 'void FileIO::setIn(str)':
vault.cpp:312:28: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  312 | void setIn(str s) { freopen(s.c_str(), "r", stdin); }
      |                     ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~
vault.cpp: In function 'void FileIO::setOut(str)':
vault.cpp:313:29: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  313 | void setOut(str s) { freopen(s.c_str(), "w", stdout); }
      |                      ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~

Subtask #1
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 1 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 1 ms 212 KB Output is correct
5 Correct 455 ms 1828 KB Output is correct
6 Correct 438 ms 1848 KB Output is correct
7 Correct 211 ms 1756 KB Output is correct
8 Correct 399 ms 1844 KB Output is correct
9 Correct 389 ms 1880 KB Output is correct
10 Correct 9 ms 1756 KB Output is correct
11 Correct 7 ms 1756 KB Output is correct

Subtask #2
0 / 15.0

# Verdict Execution time Memory Grader output
1 Correct 1 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 1 ms 212 KB Output is correct
5 Correct 455 ms 1828 KB Output is correct
6 Correct 438 ms 1848 KB Output is correct
7 Correct 211 ms 1756 KB Output is correct
8 Correct 399 ms 1844 KB Output is correct
9 Correct 389 ms 1880 KB Output is correct
10 Correct 9 ms 1756 KB Output is correct
11 Correct 7 ms 1756 KB Output is correct
12 Correct 0 ms 212 KB Output is correct
13 Correct 1 ms 212 KB Output is correct
14 Correct 1 ms 212 KB Output is correct
15 Correct 1 ms 212 KB Output is correct
16 Correct 468 ms 1840 KB Output is correct
17 Correct 426 ms 1844 KB Output is correct
18 Correct 215 ms 1840 KB Output is correct
19 Correct 385 ms 1872 KB Output is correct
20 Correct 381 ms 1888 KB Output is correct
21 Correct 8 ms 1756 KB Output is correct
22 Correct 7 ms 1756 KB Output is correct
23 Execution timed out 5051 ms 12272 KB Time limit exceeded
24 Halted 0 ms 0 KB -

Subtask #3-1
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 13 ms 648 KB Output is correct
3 Correct 4 ms 648 KB Output is correct
4 Correct 9 ms 596 KB Output is correct
5 Correct 13 ms 672 KB Output is correct
6 Correct 6 ms 628 KB Output is correct
7 Correct 3 ms 648 KB Output is correct
8 Correct 5 ms 648 KB Output is correct
9 Correct 7 ms 648 KB Output is correct
10 Correct 10 ms 648 KB Output is correct

Subtask #3-2
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 13 ms 648 KB Output is correct
3 Correct 4 ms 648 KB Output is correct
4 Correct 9 ms 596 KB Output is correct
5 Correct 13 ms 672 KB Output is correct
6 Correct 6 ms 628 KB Output is correct
7 Correct 3 ms 648 KB Output is correct
8 Correct 5 ms 648 KB Output is correct
9 Correct 7 ms 648 KB Output is correct
10 Correct 10 ms 648 KB Output is correct
11 Correct 1 ms 212 KB Output is correct
12 Correct 1 ms 212 KB Output is correct
13 Correct 1 ms 212 KB Output is correct
14 Correct 1 ms 324 KB Output is correct
15 Correct 15 ms 672 KB Output is correct
16 Correct 5 ms 648 KB Output is correct
17 Correct 8 ms 648 KB Output is correct
18 Correct 14 ms 596 KB Output is correct
19 Correct 8 ms 632 KB Output is correct
20 Correct 3 ms 648 KB Output is correct
21 Correct 5 ms 648 KB Output is correct
22 Correct 7 ms 648 KB Output is correct
23 Correct 9 ms 648 KB Output is correct
24 Correct 96 ms 700 KB Output is correct
25 Correct 37 ms 644 KB Output is correct
26 Correct 68 ms 708 KB Output is correct
27 Correct 88 ms 596 KB Output is correct
28 Correct 58 ms 648 KB Output is correct

Subtask #4-1
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 13 ms 648 KB Output is correct
3 Correct 4 ms 648 KB Output is correct
4 Correct 9 ms 596 KB Output is correct
5 Correct 13 ms 672 KB Output is correct
6 Correct 6 ms 628 KB Output is correct
7 Correct 3 ms 648 KB Output is correct
8 Correct 5 ms 648 KB Output is correct
9 Correct 7 ms 648 KB Output is correct
10 Correct 10 ms 648 KB Output is correct
11 Correct 1 ms 340 KB Output is correct
12 Correct 11 ms 672 KB Output is correct
13 Correct 5 ms 596 KB Output is correct
14 Correct 8 ms 648 KB Output is correct
15 Correct 12 ms 648 KB Output is correct
16 Correct 6 ms 628 KB Output is correct
17 Correct 4 ms 648 KB Output is correct
18 Correct 6 ms 628 KB Output is correct
19 Correct 7 ms 648 KB Output is correct
20 Correct 10 ms 648 KB Output is correct
21 Correct 8 ms 1756 KB Output is correct
22 Correct 8 ms 1756 KB Output is correct
23 Correct 94 ms 1832 KB Output is correct
24 Correct 50 ms 1748 KB Output is correct
25 Correct 92 ms 1876 KB Output is correct
26 Correct 67 ms 1728 KB Output is correct
27 Correct 37 ms 1756 KB Output is correct
28 Correct 88 ms 1736 KB Output is correct

Subtask #4-2
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 1 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 1 ms 212 KB Output is correct
5 Correct 455 ms 1828 KB Output is correct
6 Correct 438 ms 1848 KB Output is correct
7 Correct 211 ms 1756 KB Output is correct
8 Correct 399 ms 1844 KB Output is correct
9 Correct 389 ms 1880 KB Output is correct
10 Correct 9 ms 1756 KB Output is correct
11 Correct 7 ms 1756 KB Output is correct
12 Correct 1 ms 212 KB Output is correct
13 Correct 13 ms 648 KB Output is correct
14 Correct 4 ms 648 KB Output is correct
15 Correct 9 ms 596 KB Output is correct
16 Correct 13 ms 672 KB Output is correct
17 Correct 6 ms 628 KB Output is correct
18 Correct 3 ms 648 KB Output is correct
19 Correct 5 ms 648 KB Output is correct
20 Correct 7 ms 648 KB Output is correct
21 Correct 10 ms 648 KB Output is correct
22 Correct 1 ms 212 KB Output is correct
23 Correct 1 ms 212 KB Output is correct
24 Correct 1 ms 212 KB Output is correct
25 Correct 1 ms 324 KB Output is correct
26 Correct 15 ms 672 KB Output is correct
27 Correct 5 ms 648 KB Output is correct
28 Correct 8 ms 648 KB Output is correct
29 Correct 14 ms 596 KB Output is correct
30 Correct 8 ms 632 KB Output is correct
31 Correct 3 ms 648 KB Output is correct
32 Correct 5 ms 648 KB Output is correct
33 Correct 7 ms 648 KB Output is correct
34 Correct 9 ms 648 KB Output is correct
35 Correct 96 ms 700 KB Output is correct
36 Correct 37 ms 644 KB Output is correct
37 Correct 68 ms 708 KB Output is correct
38 Correct 88 ms 596 KB Output is correct
39 Correct 58 ms 648 KB Output is correct
40 Correct 1 ms 340 KB Output is correct
41 Correct 11 ms 672 KB Output is correct
42 Correct 5 ms 596 KB Output is correct
43 Correct 8 ms 648 KB Output is correct
44 Correct 12 ms 648 KB Output is correct
45 Correct 6 ms 628 KB Output is correct
46 Correct 4 ms 648 KB Output is correct
47 Correct 6 ms 628 KB Output is correct
48 Correct 7 ms 648 KB Output is correct
49 Correct 10 ms 648 KB Output is correct
50 Correct 8 ms 1756 KB Output is correct
51 Correct 8 ms 1756 KB Output is correct
52 Correct 94 ms 1832 KB Output is correct
53 Correct 50 ms 1748 KB Output is correct
54 Correct 92 ms 1876 KB Output is correct
55 Correct 67 ms 1728 KB Output is correct
56 Correct 37 ms 1756 KB Output is correct
57 Correct 88 ms 1736 KB Output is correct
58 Correct 1 ms 212 KB Output is correct
59 Correct 1 ms 324 KB Output is correct
60 Correct 1 ms 212 KB Output is correct
61 Correct 1 ms 212 KB Output is correct
62 Correct 456 ms 1832 KB Output is correct
63 Correct 459 ms 1840 KB Output is correct
64 Correct 206 ms 1836 KB Output is correct
65 Correct 412 ms 1836 KB Output is correct
66 Correct 390 ms 1832 KB Output is correct
67 Correct 9 ms 1756 KB Output is correct
68 Correct 7 ms 1740 KB Output is correct
69 Correct 12 ms 596 KB Output is correct
70 Correct 4 ms 648 KB Output is correct
71 Correct 8 ms 648 KB Output is correct
72 Correct 12 ms 672 KB Output is correct
73 Correct 5 ms 648 KB Output is correct
74 Correct 4 ms 648 KB Output is correct
75 Correct 5 ms 648 KB Output is correct
76 Correct 7 ms 724 KB Output is correct
77 Correct 10 ms 648 KB Output is correct
78 Correct 91 ms 708 KB Output is correct
79 Correct 39 ms 584 KB Output is correct
80 Correct 68 ms 648 KB Output is correct
81 Correct 89 ms 596 KB Output is correct
82 Correct 60 ms 644 KB Output is correct
83 Correct 93 ms 1748 KB Output is correct
84 Correct 52 ms 1732 KB Output is correct
85 Correct 101 ms 1732 KB Output is correct
86 Correct 68 ms 1748 KB Output is correct
87 Correct 39 ms 1832 KB Output is correct
88 Correct 89 ms 1832 KB Output is correct
89 Correct 794 ms 1908 KB Output is correct
90 Correct 792 ms 1872 KB Output is correct
91 Correct 712 ms 1900 KB Output is correct
92 Correct 525 ms 1892 KB Output is correct

Subtask #5-1
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 13 ms 648 KB Output is correct
3 Correct 4 ms 648 KB Output is correct
4 Correct 9 ms 596 KB Output is correct
5 Correct 13 ms 672 KB Output is correct
6 Correct 6 ms 628 KB Output is correct
7 Correct 3 ms 648 KB Output is correct
8 Correct 5 ms 648 KB Output is correct
9 Correct 7 ms 648 KB Output is correct
10 Correct 10 ms 648 KB Output is correct
11 Correct 1 ms 340 KB Output is correct
12 Correct 11 ms 672 KB Output is correct
13 Correct 5 ms 596 KB Output is correct
14 Correct 8 ms 648 KB Output is correct
15 Correct 12 ms 648 KB Output is correct
16 Correct 6 ms 628 KB Output is correct
17 Correct 4 ms 648 KB Output is correct
18 Correct 6 ms 628 KB Output is correct
19 Correct 7 ms 648 KB Output is correct
20 Correct 10 ms 648 KB Output is correct
21 Correct 8 ms 1756 KB Output is correct
22 Correct 8 ms 1756 KB Output is correct
23 Correct 94 ms 1832 KB Output is correct
24 Correct 50 ms 1748 KB Output is correct
25 Correct 92 ms 1876 KB Output is correct
26 Correct 67 ms 1728 KB Output is correct
27 Correct 37 ms 1756 KB Output is correct
28 Correct 88 ms 1736 KB Output is correct
29 Correct 1 ms 340 KB Output is correct
30 Correct 13 ms 628 KB Output is correct
31 Correct 4 ms 648 KB Output is correct
32 Correct 8 ms 648 KB Output is correct
33 Correct 12 ms 628 KB Output is correct
34 Correct 6 ms 648 KB Output is correct
35 Correct 4 ms 648 KB Output is correct
36 Correct 6 ms 648 KB Output is correct
37 Correct 7 ms 648 KB Output is correct
38 Correct 10 ms 648 KB Output is correct
39 Correct 8 ms 1756 KB Output is correct
40 Correct 8 ms 1756 KB Output is correct
41 Correct 93 ms 1832 KB Output is correct
42 Correct 53 ms 1832 KB Output is correct
43 Correct 93 ms 1832 KB Output is correct
44 Correct 67 ms 1856 KB Output is correct
45 Correct 38 ms 1756 KB Output is correct
46 Correct 84 ms 1836 KB Output is correct
47 Correct 115 ms 12252 KB Output is correct
48 Correct 107 ms 12280 KB Output is correct
49 Correct 1549 ms 12384 KB Output is correct
50 Correct 759 ms 12296 KB Output is correct
51 Correct 1350 ms 12288 KB Output is correct
52 Correct 1240 ms 12380 KB Output is correct
53 Correct 619 ms 12412 KB Output is correct
54 Correct 1475 ms 12332 KB Output is correct

Subtask #5-2
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 1 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 1 ms 212 KB Output is correct
5 Correct 455 ms 1828 KB Output is correct
6 Correct 438 ms 1848 KB Output is correct
7 Correct 211 ms 1756 KB Output is correct
8 Correct 399 ms 1844 KB Output is correct
9 Correct 389 ms 1880 KB Output is correct
10 Correct 9 ms 1756 KB Output is correct
11 Correct 7 ms 1756 KB Output is correct
12 Correct 0 ms 212 KB Output is correct
13 Correct 1 ms 212 KB Output is correct
14 Correct 1 ms 212 KB Output is correct
15 Correct 1 ms 212 KB Output is correct
16 Correct 468 ms 1840 KB Output is correct
17 Correct 426 ms 1844 KB Output is correct
18 Correct 215 ms 1840 KB Output is correct
19 Correct 385 ms 1872 KB Output is correct
20 Correct 381 ms 1888 KB Output is correct
21 Correct 8 ms 1756 KB Output is correct
22 Correct 7 ms 1756 KB Output is correct
23 Execution timed out 5051 ms 12272 KB Time limit exceeded
24 Halted 0 ms 0 KB -

Subtask #6-1
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 13 ms 648 KB Output is correct
3 Correct 4 ms 648 KB Output is correct
4 Correct 9 ms 596 KB Output is correct
5 Correct 13 ms 672 KB Output is correct
6 Correct 6 ms 628 KB Output is correct
7 Correct 3 ms 648 KB Output is correct
8 Correct 5 ms 648 KB Output is correct
9 Correct 7 ms 648 KB Output is correct
10 Correct 10 ms 648 KB Output is correct
11 Correct 1 ms 340 KB Output is correct
12 Correct 11 ms 672 KB Output is correct
13 Correct 5 ms 596 KB Output is correct
14 Correct 8 ms 648 KB Output is correct
15 Correct 12 ms 648 KB Output is correct
16 Correct 6 ms 628 KB Output is correct
17 Correct 4 ms 648 KB Output is correct
18 Correct 6 ms 628 KB Output is correct
19 Correct 7 ms 648 KB Output is correct
20 Correct 10 ms 648 KB Output is correct
21 Correct 8 ms 1756 KB Output is correct
22 Correct 8 ms 1756 KB Output is correct
23 Correct 94 ms 1832 KB Output is correct
24 Correct 50 ms 1748 KB Output is correct
25 Correct 92 ms 1876 KB Output is correct
26 Correct 67 ms 1728 KB Output is correct
27 Correct 37 ms 1756 KB Output is correct
28 Correct 88 ms 1736 KB Output is correct
29 Correct 1 ms 340 KB Output is correct
30 Correct 13 ms 628 KB Output is correct
31 Correct 4 ms 648 KB Output is correct
32 Correct 8 ms 648 KB Output is correct
33 Correct 12 ms 628 KB Output is correct
34 Correct 6 ms 648 KB Output is correct
35 Correct 4 ms 648 KB Output is correct
36 Correct 6 ms 648 KB Output is correct
37 Correct 7 ms 648 KB Output is correct
38 Correct 10 ms 648 KB Output is correct
39 Correct 8 ms 1756 KB Output is correct
40 Correct 8 ms 1756 KB Output is correct
41 Correct 93 ms 1832 KB Output is correct
42 Correct 53 ms 1832 KB Output is correct
43 Correct 93 ms 1832 KB Output is correct
44 Correct 67 ms 1856 KB Output is correct
45 Correct 38 ms 1756 KB Output is correct
46 Correct 84 ms 1836 KB Output is correct
47 Correct 115 ms 12252 KB Output is correct
48 Correct 107 ms 12280 KB Output is correct
49 Correct 1549 ms 12384 KB Output is correct
50 Correct 759 ms 12296 KB Output is correct
51 Correct 1350 ms 12288 KB Output is correct
52 Correct 1240 ms 12380 KB Output is correct
53 Correct 619 ms 12412 KB Output is correct
54 Correct 1475 ms 12332 KB Output is correct
55 Correct 1 ms 340 KB Output is correct
56 Correct 13 ms 668 KB Output is correct
57 Correct 4 ms 648 KB Output is correct
58 Correct 9 ms 628 KB Output is correct
59 Correct 12 ms 636 KB Output is correct
60 Correct 5 ms 648 KB Output is correct
61 Correct 4 ms 648 KB Output is correct
62 Correct 5 ms 656 KB Output is correct
63 Correct 7 ms 632 KB Output is correct
64 Correct 10 ms 648 KB Output is correct
65 Correct 8 ms 1756 KB Output is correct
66 Correct 8 ms 1756 KB Output is correct
67 Correct 95 ms 1748 KB Output is correct
68 Correct 50 ms 1748 KB Output is correct
69 Correct 94 ms 1748 KB Output is correct
70 Correct 70 ms 1748 KB Output is correct
71 Correct 36 ms 1756 KB Output is correct
72 Correct 80 ms 1748 KB Output is correct
73 Correct 117 ms 12304 KB Output is correct
74 Correct 108 ms 12244 KB Output is correct
75 Correct 1565 ms 12288 KB Output is correct
76 Correct 768 ms 12284 KB Output is correct
77 Correct 1372 ms 12284 KB Output is correct
78 Correct 1242 ms 12300 KB Output is correct
79 Correct 616 ms 12348 KB Output is correct
80 Correct 1480 ms 12288 KB Output is correct
81 Execution timed out 5070 ms 319304 KB Time limit exceeded
82 Halted 0 ms 0 KB -

Subtask #6-2
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 1 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 1 ms 212 KB Output is correct
5 Correct 455 ms 1828 KB Output is correct
6 Correct 438 ms 1848 KB Output is correct
7 Correct 211 ms 1756 KB Output is correct
8 Correct 399 ms 1844 KB Output is correct
9 Correct 389 ms 1880 KB Output is correct
10 Correct 9 ms 1756 KB Output is correct
11 Correct 7 ms 1756 KB Output is correct
12 Correct 0 ms 212 KB Output is correct
13 Correct 1 ms 212 KB Output is correct
14 Correct 1 ms 212 KB Output is correct
15 Correct 1 ms 212 KB Output is correct
16 Correct 468 ms 1840 KB Output is correct
17 Correct 426 ms 1844 KB Output is correct
18 Correct 215 ms 1840 KB Output is correct
19 Correct 385 ms 1872 KB Output is correct
20 Correct 381 ms 1888 KB Output is correct
21 Correct 8 ms 1756 KB Output is correct
22 Correct 7 ms 1756 KB Output is correct
23 Execution timed out 5051 ms 12272 KB Time limit exceeded
24 Halted 0 ms 0 KB -