oj.uz

답안 #417358

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
417358 2021-06-03T15:21:16 Z Benq Izvanzemaljci (COI21_izvanzemaljci) C++17
100 / 100
 1342 ms 25616 KB 
#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!

using pi = pair<int,int>;
using pl = pair<ll,ll>;
using pd = pair<db,db>;

using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>; 
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>; 
using vpd = vector<pd>;

#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>; 
tcT> using PR = pair<T,T>;

// pairs
#define mp make_pair
#define f first
#define s second

// 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 ft front()
#define bk back()
#define pb push_back
#define eb emplace_back 
#define pf push_front
#define rtn return

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

// 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 INF = 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; }

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
}

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

int N,K;
vpl points;
pair<ll,V<pair<pl,pl>>> ans;

tcT> void order(T& a, T& b) {
	if (a > b) swap(a,b);
}

const ll BIG = 3e9;

pair<pl,pl> make_square(ll x, ll y, ll len) { // OK
	assert(len > 0);
	assert(abs(x) <= BIG);
	assert(abs(y) <= BIG);
	assert(abs(x+len) <= BIG);
	assert(abs(y+len) <= BIG);
	return {{x,y},{x+len,y+len}};
}

void fail(bool b, bool flag) {
	if (b) {
		exit(flag);
	}
}

pair<ll,V<pair<pl,pl>>> eval(V<pair<pl,pl>> cand) {
	ll len = 0;
	each(t,cand) ckmax(len,abs(t.s.f-t.f.f));
	return {len,cand};
}

void check(V<pair<pl,pl>> cand, bool flag = false) { // OK
	assert(sz(cand) <= K);
	// ll len = 0;
	// each(t,cand) ckmax(len,abs(t.s.f-t.f.f));
	each(t,cand) {
		fail(abs(t.f.f) > BIG,flag);
		fail(abs(t.f.s) > BIG,flag);
		fail(abs(t.s.f) > BIG,flag);
		fail(abs(t.s.s) > BIG,flag);
	}
	int cnt = 0;
	while (sz(cand) < K) {
		if (cnt == 0) {
			cand.pb(make_square(BIG-5,BIG-5,1));
		} else {
			cand.pb(make_square(-BIG+5,-BIG+5,1));
		}
		++cnt;
	}
	each(t,cand) {
		fail(abs(t.f.f) > BIG,flag);
		fail(abs(t.f.s) > BIG,flag);
		fail(abs(t.s.f) > BIG,flag);
		fail(abs(t.s.s) > BIG,flag);
	}
	ckmin(ans,eval(cand));
	// dbg("AH",len,cand,ans.f);
	// if (len < ans.f) ans = {len,cand};
}

using Square = pair<pl,pl>;

vpl rev(vpl v) { // OK
	reverse(all(v));
	return v;
}

vpl neg(vpl v) { // OK
	each(t,v) t.f *= -1;
	return v;
}

V<Square> get_prefs(vpl v) {
	ll xl = v[0].f, xr = v[0].f;
	ll yl = v[0].s, yr = v[0].s;
	V<Square> prefs;
	F0R(i,sz(v)) {
		ckmin(xl,v[i].f), ckmax(xr,v[i].f);
		ckmin(yl,v[i].s), ckmax(yr,v[i].s);
		ll len = max({xr-xl,yr-yl,1LL});
		prefs.pb(make_square(xr-len,yl,len)); // maximize the y-coordinate, minimize the x-coordinate
	}
	return prefs;
}

V<Square> neg(V<Square> v) {// OK, negate x values
	each(t,v) t.f.f *= -1, t.s.f *= -1;
	return v;
}

ll get_len(Square sq) {
	ll dif = sq.s.f-sq.f.f; assert(dif > 0);
	return dif;
}

pair<ll,V<Square>> solve_opt_2(vpl rem) {
	assert(sz(rem));
	V<Square> pref_square = get_prefs(rem);
	V<Square> suf_square = neg(get_prefs(rev(neg(rem))));
	reverse(all(suf_square));
	pair<ll,V<Square>> res = eval({pref_square.bk});
	F0R(i,sz(rem)-1) if (rem.at(i).f < rem.at(i+1).f) 
		ckmin(res,eval({pref_square.at(i),suf_square.at(i+1)}));
	return res;
}

V<Square> swap_xy_sq(V<Square> v) {
	each(t,v) {
		swap(t.f.f,t.f.s);
		swap(t.s.f,t.s.s);
	}
	return v;
}

void solve() {
	sor(points);
	V<Square> pref_square = get_prefs(points);
	V<Square> suf_square = neg(get_prefs(rev(neg(points))));
	reverse(all(suf_square));
	{ // K == 1
		check({pref_square.bk});
	}
	if (K >= 2) { // K == 2
		F0R(i,sz(pref_square)-1) if (points[i].f < points[i+1].f) {
			check({pref_square[i],suf_square[i+1]}, true);
		}
		// dbg("HUH",v);
		// dbg(pref_square);
		// dbg(suf_square);
		// dbg(ans);
	}
	if (K >= 3) {
		vi tri_inds;
		F0R(i,sz(points)-1) if (points.at(i).f < points.at(i+1).f) {
			tri_inds.pb(i);
		}
		vl huh;
		auto check_sol = [&](int ind) -> ll {
			// everything <= ind accounted for
			auto swap_xy = [&](pl p) {
				swap(p.f,p.s);
				return p;
			};
			// check distinct y
			vpl rem; 
			// for (int i: sort_by_y) if (i >= ind+1) {

			// }
			FOR(i,ind+1,sz(points)) rem.pb(swap_xy(points.at(i)));
			sort(all(rem));
			auto ans_y = solve_opt_2(rem);
			ans_y.s = swap_xy_sq(ans_y.s);
			each(t,ans_y.s) assert(t.f.f > points.at(ind).f && t.s.f > points.at(ind).f);
			// check distinct x
			ll xl = MOD, xr = -MOD;
			ll yl = MOD, yr = -MOD;
			FOR(i,ind+1,sz(points)-1) {
				ckmin(xl,points.at(i).f); ckmax(xr,points.at(i).f);
				ckmin(yl,points.at(i).s); ckmax(yr,points.at(i).s);
				if (points.at(i).f < points.at(i+1).f) {
					ll len = max({xr-xl,yr-yl,1LL});
					ll nxl = max(points.at(ind).f+1,xr-len);
					ll nxr = nxl+len;
					if (nxr < points.at(i+1).f) {
						ckmin(ans_y,eval({make_square(nxl,yl,len),suf_square.at(i+1)}));
					}
				}
			}
			huh.pb(ans_y.f);
			// dbg(ans_y.f);
			ans_y.s.pb(pref_square.at(ind));
			ans_y = eval(ans_y.s); ckmin(ans,ans_y);
			// if (ans_y.f <= 6) {
			// 	dbg("AH",points,ans_y);
			// }
			return ans_y.f;
		};
		int lo = 0, hi = sz(tri_inds)-1;
		// dbg("BOUNDS",points,lo,hi);
		while (lo <= hi) {
			int mid = (lo+hi)/2;
			// dbg("TRIED",mid);
			// dbg("TRYING",mid);
			int x = tri_inds.at(mid);
			ll len = check_sol(x);
			// dbg(x,len,get_len(pref_square[x]));
			if (len > get_len(pref_square.at(x))) lo = mid+1;
			else hi = mid-1;
		}
		// for (int i: tri_inds) {
		// 	ll prev_ans = ans.f;
		// 	check_sol(i);
		// 	ll new_ans = ans.f;
		// 	if (prev_ans != new_ans) {
		// 		dbg("AH",prev_ans,new_ans,i);
		// 		exit(0);
		// 	}
		// 	// pr(check_sol(i) > get_len(pref_square[i]));
		// }
		// reverse(all(huh));
		// dbg(is_sorted(all(huh)));
		// ps();
	}
}

tcT> void rot(T& p) {
	p = mp(-p.s,p.f);
	// fassert(abs(p.f) <= BIG && abs(p.s) <= BIG)
}

int main() {
	setIO(); re(N,K);
	points.rsz(N); re(points);
	ans.f = 2*MOD;
	rep(4) {
		solve();
		each(t,points) rot(t);
		each(t,ans.s) rot(t.f), rot(t.s);
	}
	ll len = 0;
	each(t,ans.s) {
		pl a = t.f;
		pl b = t.s;
		order(a.f,b.f);
		order(a.s,b.s);
		assert(b.f-a.f == b.s-a.s);
		ckmax(len,b.f-a.f);
		assert(abs(a.f) <= BIG);
		assert(abs(a.s) <= BIG);
		ps(a.f,a.s,b.f-a.f);
	}
	dbg(len);
	// 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

izvanzemaljci.cpp: In function 'int main()':
izvanzemaljci.cpp:239:20: warning: statement has no effect [-Wunused-value]
  239 |   #define dbg(...) 0
      |                    ^
izvanzemaljci.cpp:488:2: note: in expansion of macro 'dbg'
  488 |  dbg(len);
      |  ^~~
izvanzemaljci.cpp: In function 'void FileIO::setIn(str)':
izvanzemaljci.cpp:245:30: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  245 |  void setIn(str s)  { freopen(s.c_str(),"r",stdin); }
      |                       ~~~~~~~^~~~~~~~~~~~~~~~~~~~~
izvanzemaljci.cpp: In function 'void FileIO::setOut(str)':
izvanzemaljci.cpp:246:30: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  246 |  void setOut(str s) { freopen(s.c_str(),"w",stdout); }
      |                       ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~

Subtask #1
5.0 / 5.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 204 KB Output is correct
2 Correct 1 ms 204 KB Output is correct
3 Correct 0 ms 204 KB Output is correct
4 Correct 1 ms 204 KB Output is correct
5 Correct 1 ms 204 KB Output is correct
6 Correct 0 ms 204 KB Output is correct
7 Correct 99 ms 13812 KB Output is correct
8 Correct 101 ms 13812 KB Output is correct
9 Correct 98 ms 13824 KB Output is correct
10 Correct 98 ms 13808 KB Output is correct
11 Correct 98 ms 13844 KB Output is correct

Subtask #2
21.0 / 21.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 204 KB Output is correct
2 Correct 1 ms 204 KB Output is correct
3 Correct 1 ms 204 KB Output is correct
4 Correct 0 ms 204 KB Output is correct
5 Correct 0 ms 204 KB Output is correct
6 Correct 1 ms 204 KB Output is correct
7 Correct 1 ms 204 KB Output is correct
8 Correct 1 ms 204 KB Output is correct
9 Correct 0 ms 204 KB Output is correct
10 Correct 139 ms 13816 KB Output is correct
11 Correct 141 ms 13832 KB Output is correct
12 Correct 144 ms 13920 KB Output is correct
13 Correct 137 ms 13828 KB Output is correct
14 Correct 140 ms 13824 KB Output is correct
15 Correct 139 ms 13824 KB Output is correct
16 Correct 139 ms 13824 KB Output is correct
17 Correct 125 ms 13008 KB Output is correct
18 Correct 124 ms 12700 KB Output is correct
19 Correct 115 ms 12012 KB Output is correct
20 Correct 118 ms 12520 KB Output is correct
21 Correct 139 ms 13816 KB Output is correct
22 Correct 139 ms 13844 KB Output is correct
23 Correct 140 ms 13832 KB Output is correct

Subtask #3
12.0 / 12.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 204 KB Output is correct
2 Correct 0 ms 204 KB Output is correct
3 Correct 1 ms 204 KB Output is correct
4 Correct 0 ms 204 KB Output is correct
5 Correct 0 ms 204 KB Output is correct
6 Correct 0 ms 204 KB Output is correct
7 Correct 0 ms 204 KB Output is correct
8 Correct 0 ms 204 KB Output is correct
9 Correct 1 ms 204 KB Output is correct
10 Correct 0 ms 204 KB Output is correct
11 Correct 1 ms 204 KB Output is correct
12 Correct 0 ms 204 KB Output is correct
13 Correct 1 ms 204 KB Output is correct
14 Correct 1 ms 204 KB Output is correct
15 Correct 0 ms 204 KB Output is correct
16 Correct 1 ms 204 KB Output is correct
17 Correct 1 ms 204 KB Output is correct
18 Correct 1 ms 204 KB Output is correct
19 Correct 1 ms 204 KB Output is correct
20 Correct 0 ms 204 KB Output is correct
21 Correct 1 ms 204 KB Output is correct
22 Correct 1 ms 204 KB Output is correct
23 Correct 1 ms 204 KB Output is correct
24 Correct 0 ms 204 KB Output is correct
25 Correct 1 ms 204 KB Output is correct
26 Correct 1 ms 204 KB Output is correct

Subtask #4
30.0 / 30.0

# 결과 실행 시간 메모리 Grader output
1 Correct 8 ms 512 KB Output is correct
2 Correct 9 ms 512 KB Output is correct
3 Correct 8 ms 544 KB Output is correct
4 Correct 9 ms 512 KB Output is correct
5 Correct 8 ms 508 KB Output is correct
6 Correct 8 ms 552 KB Output is correct
7 Correct 8 ms 512 KB Output is correct
8 Correct 10 ms 552 KB Output is correct
9 Correct 8 ms 532 KB Output is correct
10 Correct 8 ms 512 KB Output is correct
11 Correct 8 ms 512 KB Output is correct
12 Correct 8 ms 508 KB Output is correct
13 Correct 6 ms 532 KB Output is correct
14 Correct 7 ms 524 KB Output is correct
15 Correct 7 ms 548 KB Output is correct
16 Correct 6 ms 524 KB Output is correct
17 Correct 7 ms 492 KB Output is correct
18 Correct 6 ms 476 KB Output is correct
19 Correct 6 ms 508 KB Output is correct
20 Correct 6 ms 544 KB Output is correct
21 Correct 6 ms 528 KB Output is correct
22 Correct 6 ms 536 KB Output is correct
23 Correct 5 ms 476 KB Output is correct
24 Correct 7 ms 528 KB Output is correct

Subtask #5
32.0 / 32.0

# 결과 실행 시간 메모리 Grader output
1 Correct 8 ms 536 KB Output is correct
2 Correct 9 ms 548 KB Output is correct
3 Correct 8 ms 532 KB Output is correct
4 Correct 8 ms 544 KB Output is correct
5 Correct 8 ms 548 KB Output is correct
6 Correct 8 ms 512 KB Output is correct
7 Correct 8 ms 512 KB Output is correct
8 Correct 8 ms 556 KB Output is correct
9 Correct 9 ms 512 KB Output is correct
10 Correct 8 ms 512 KB Output is correct
11 Correct 8 ms 508 KB Output is correct
12 Correct 8 ms 544 KB Output is correct
13 Correct 8 ms 512 KB Output is correct
14 Correct 999 ms 20984 KB Output is correct
15 Correct 1117 ms 23480 KB Output is correct
16 Correct 983 ms 23600 KB Output is correct
17 Correct 1342 ms 25012 KB Output is correct
18 Correct 1020 ms 23244 KB Output is correct
19 Correct 1119 ms 24092 KB Output is correct
20 Correct 1057 ms 25616 KB Output is correct
21 Correct 804 ms 20520 KB Output is correct
22 Correct 1010 ms 23460 KB Output is correct
23 Correct 1002 ms 24132 KB Output is correct
24 Correct 1336 ms 24348 KB Output is correct
25 Correct 1253 ms 23648 KB Output is correct
26 Correct 1102 ms 22808 KB Output is correct