oj.uz

Submission #405001

# Submission time Handle Problem Language Result Execution time Memory
405001 2021-05-15T13:47:32 Z Benq Circle selection (APIO18_circle_selection) C++17
37 / 100
 3000 ms 243688 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)); }
tcT> int lwb_ok(V<T>& a, const T& b) { 
	int x = lwb(a,b);
	assert(a.at(x) == b); 
	return x;
}

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

using P = pi;
int N;
V<pair<P,int>> circ;

struct Data {
	int xl,xr,yl,yr;
	friend str ts(const Data& d) {
		return ts(vi{d.xl,d.xr,d.yl,d.yr});
	}
};

V<Data> compress;
vi X,Y;

ll sq(ll x) { return x*x; }
ll norm(P p) { return sq(p.f)+sq(p.s); }

P operator-(P a, P b) { return {a.f-b.f,a.s-b.s}; }
bool isect(int x, int y) {
	return norm(circ[x].f-circ[y].f) <= sq(circ[x].s+circ[y].s);
}

int smaller_ind(int x, int y) {
	if (x == -1) return y;
	if (y == -1) return x;
	if (circ[x].s != circ[y].s) {
		if (circ[x].s > circ[y].s) return x;
		return y;
	}
	return min(x,y);
}

const int BIG = 2e7;
int pre[BIG], val[BIG], cnt;

int list_add(int p, int v) {
	int label = ++cnt; assert(label < BIG);
	pre[label] = p;
	val[label] = v;
	return label;
}

struct Seg {
	int N;
	AR<vi,1<<21> ys,ans;
	void init(int _N) {
		N = _N;
		int n = 1; while (n < N) n *= 2;
		n *= 2;
	}
	int lookup(int cind, pi p, int ind, int L, int R) {
		int res = -1;
		int pos = lwb(ys[ind],p.s);
		if (pos < sz(ys[ind])) 
			for (int j = ans[ind][pos]; j; j = pre[j]) {
				int v = val[j];
				if (isect(cind,v))
					res = smaller_ind(res,v);
			}
		if (L != R) {
			int M = (L+R)/2;
			if (p.f <= M) res = smaller_ind(res,lookup(cind,p,2*ind,L,M));
			else res = smaller_ind(res,lookup(cind,p,2*ind+1,M+1,R));
		}
		return res;
	}
	int lookup(int cind, pi p) {
		return lookup(cind,p,1,0,N-1);
	}
	void add_seg_pre(int lo, int hi, int y, int ind, int L, int R) {
		if (hi < L || R < lo) return;
		if (lo <= L && R <= hi) {
			if (sz(ys[ind]) && ys[ind].bk == y) return;
			ys[ind].pb(y);
			return;
		}
		int M = (L+R)/2;
		add_seg_pre(lo,hi,y,2*ind,L,M);
		add_seg_pre(lo,hi,y,2*ind+1,M+1,R);
	}
	void add_seg_pre(pi l, int y) { add_seg_pre(l.f,l.s,y,1,0,N-1); }
	void add_seg(int lo, int hi, pi y, int label, int ind, int L, int R) {
		if (hi < L || R < lo) return;
		if (lo <= L && R <= hi) {
			// dbg("??",ys[ind],y);
			int a = lwb_ok(ys[ind],y.f);
			while (a < sz(ys[ind]) && ys[ind][a] <= y.s) {
				ans[ind][a] = list_add(ans[ind][a],label);
				++a;
			}
			// int b = lwb_ok(ys[ind],y.s);
			// FOR(i,a,b+1) ans[ind][i] = list_add(ans[ind][i],label);
			return;
		}
		int M = (L+R)/2;
		add_seg(lo,hi,y,label,2*ind,L,M);
		add_seg(lo,hi,y,label,2*ind+1,M+1,R);
	}
	void add_seg(pi l, pi r, int label) { add_seg(l.f,l.s,r,label,1,0,N-1); }
	void gen() {
		F0R(i,sz(ys)) {
			// remDup(ys[i]);
			// assert(is_sorted(all(ys[i])));
			ans[i].rsz(sz(ys[i]));
		}
	}
} seg;

int lookup_isect(int ind) {
	int res = -1;
	int a = seg.lookup(ind,{compress[ind].xl,compress[ind].yl});
	int b = seg.lookup(ind,{compress[ind].xr,compress[ind].yl});
	int c = seg.lookup(ind,{compress[ind].xl,compress[ind].yr});
	int d = seg.lookup(ind,{compress[ind].xr,compress[ind].yr});
	res = smaller_ind(res,a);
	res = smaller_ind(res,b);
	res = smaller_ind(res,c);
	res = smaller_ind(res,d);
	return res;
}	

// void add_seg_pre(int ind) {
// 	seg.add_seg_pre({compress[ind].xl,compress[ind].xr},{compress[ind].yl,compress[ind].yr});
// }

void add_seg(int ind) {
	seg.add_seg({compress[ind].xl,compress[ind].xr},{compress[ind].yl,compress[ind].yr},ind);
}

clock_t beg = clock();

int main() {
	setIO(); re(N);
	circ.rsz(N); 
	each(t,circ) {
		t.f = {rng()%1000000000,0};
		t.s = rng()%1000000+1;
	}
	re(circ);
	each(t,circ) {
		X.pb(t.f.f-t.s);
		X.pb(t.f.f+t.s);
		Y.pb(t.f.s-t.s);
		Y.pb(t.f.s+t.s);
	}
	remDup(X);
	remDup(Y);
	dbg((db)(clock()-beg)/CLOCKS_PER_SEC);
	each(t,circ) {
		compress.pb(Data{lwb_ok(X,t.f.f-t.s),
			lwb_ok(X,t.f.f+t.s),
			lwb_ok(Y,t.f.s-t.s),
			lwb_ok(Y,t.f.s+t.s)});
	}
	vi inds(N); iota(all(inds),0);
	sort(all(inds),[&](int x, int y) {
		return smaller_ind(x,y) == x;
	});
	dbg("DONE INIT");
	seg.init(sz(X));
	{
		vpi res;
		F0R(i,N) {
			res.pb({compress[i].yl,i});
			res.pb({compress[i].yr,i});
		}
		sort(all(res));
		each(t,res) {
			seg.add_seg_pre(mp(compress[t.s].xl,compress[t.s].xr),t.f);
		}
	}
	// F0R(i,N) add_seg_pre(i);
	seg.gen();
	dbg((db)(clock()-beg)/CLOCKS_PER_SEC);
	dbg("DONE GEN SEG");
	// dbg(inds);
	// each(t,inds) dbg(t,compress[t]);
	vi ans(N,-1);
	each(t,inds) {
		// dbg("LOOKING UP");
		int res = lookup_isect(t);
		if (res == -1) {
			res = t;
		// dbg("ADDING");
			add_seg(t);
		}
		ans[t] = res;
	}
	dbg((db)(clock()-beg)/CLOCKS_PER_SEC);
	// #ifndef LOCAL
		each(t,ans) cout << t+1 << ' ';
	// #endif
	// 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

circle_selection.cpp: In function 'int main()':
circle_selection.cpp:244:20: warning: statement has no effect [-Wunused-value]
  244 |   #define dbg(...) 0
      |                    ^
circle_selection.cpp:408:2: note: in expansion of macro 'dbg'
  408 |  dbg((db)(clock()-beg)/CLOCKS_PER_SEC);
      |  ^~~
circle_selection.cpp:244:20: warning: statement has no effect [-Wunused-value]
  244 |   #define dbg(...) 0
      |                    ^
circle_selection.cpp:419:2: note: in expansion of macro 'dbg'
  419 |  dbg("DONE INIT");
      |  ^~~
circle_selection.cpp:244:20: warning: statement has no effect [-Wunused-value]
  244 |   #define dbg(...) 0
      |                    ^
circle_selection.cpp:434:2: note: in expansion of macro 'dbg'
  434 |  dbg((db)(clock()-beg)/CLOCKS_PER_SEC);
      |  ^~~
circle_selection.cpp:244:20: warning: statement has no effect [-Wunused-value]
  244 |   #define dbg(...) 0
      |                    ^
circle_selection.cpp:435:2: note: in expansion of macro 'dbg'
  435 |  dbg("DONE GEN SEG");
      |  ^~~
circle_selection.cpp:244:20: warning: statement has no effect [-Wunused-value]
  244 |   #define dbg(...) 0
      |                    ^
circle_selection.cpp:449:2: note: in expansion of macro 'dbg'
  449 |  dbg((db)(clock()-beg)/CLOCKS_PER_SEC);
      |  ^~~
circle_selection.cpp: In function 'void FileIO::setIn(str)':
circle_selection.cpp:250:30: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  250 |  void setIn(str s)  { freopen(s.c_str(),"r",stdin); }
      |                       ~~~~~~~^~~~~~~~~~~~~~~~~~~~~
circle_selection.cpp: In function 'void FileIO::setOut(str)':
circle_selection.cpp:251:30: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  251 |  void setOut(str s) { freopen(s.c_str(),"w",stdout); }
      |                       ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~

Subtask #1
7.0 / 7.0

# Verdict Execution time Memory Grader output
1 Correct 65 ms 98756 KB Output is correct
2 Correct 64 ms 98756 KB Output is correct
3 Correct 65 ms 98748 KB Output is correct
4 Correct 65 ms 98712 KB Output is correct
5 Correct 64 ms 98756 KB Output is correct
6 Correct 66 ms 98776 KB Output is correct
7 Correct 65 ms 98732 KB Output is correct
8 Correct 69 ms 98812 KB Output is correct
9 Correct 66 ms 98828 KB Output is correct
10 Correct 64 ms 98768 KB Output is correct
11 Correct 65 ms 98824 KB Output is correct
12 Correct 67 ms 98772 KB Output is correct
13 Correct 65 ms 98756 KB Output is correct
14 Correct 69 ms 98752 KB Output is correct
15 Correct 66 ms 98744 KB Output is correct
16 Correct 68 ms 99012 KB Output is correct
17 Correct 69 ms 99144 KB Output is correct
18 Correct 69 ms 99140 KB Output is correct
19 Correct 95 ms 100724 KB Output is correct
20 Correct 87 ms 100804 KB Output is correct
21 Correct 94 ms 100732 KB Output is correct
22 Correct 85 ms 99832 KB Output is correct
23 Correct 103 ms 100432 KB Output is correct
24 Correct 85 ms 99832 KB Output is correct
25 Correct 84 ms 99692 KB Output is correct
26 Correct 83 ms 99892 KB Output is correct

Subtask #2
0 / 12.0

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

Subtask #3
0 / 15.0

# Verdict Execution time Memory Grader output
1 Correct 69 ms 98816 KB Output is correct
2 Correct 901 ms 130836 KB Output is correct
3 Correct 2954 ms 193856 KB Output is correct
4 Correct 2922 ms 193924 KB Output is correct
5 Execution timed out 3057 ms 197408 KB Time limit exceeded
6 Halted 0 ms 0 KB -

Subtask #4
0 / 23.0

# Verdict Execution time Memory Grader output
1 Correct 2398 ms 186376 KB Output is correct
2 Correct 1551 ms 152676 KB Output is correct
3 Execution timed out 3073 ms 217088 KB Time limit exceeded
4 Halted 0 ms 0 KB -

Subtask #5
30.0 / 30.0

# Verdict Execution time Memory Grader output
1 Correct 65 ms 98756 KB Output is correct
2 Correct 64 ms 98756 KB Output is correct
3 Correct 65 ms 98748 KB Output is correct
4 Correct 65 ms 98712 KB Output is correct
5 Correct 64 ms 98756 KB Output is correct
6 Correct 66 ms 98776 KB Output is correct
7 Correct 65 ms 98732 KB Output is correct
8 Correct 69 ms 98812 KB Output is correct
9 Correct 66 ms 98828 KB Output is correct
10 Correct 64 ms 98768 KB Output is correct
11 Correct 65 ms 98824 KB Output is correct
12 Correct 67 ms 98772 KB Output is correct
13 Correct 65 ms 98756 KB Output is correct
14 Correct 69 ms 98752 KB Output is correct
15 Correct 66 ms 98744 KB Output is correct
16 Correct 68 ms 99012 KB Output is correct
17 Correct 69 ms 99144 KB Output is correct
18 Correct 69 ms 99140 KB Output is correct
19 Correct 95 ms 100724 KB Output is correct
20 Correct 87 ms 100804 KB Output is correct
21 Correct 94 ms 100732 KB Output is correct
22 Correct 85 ms 99832 KB Output is correct
23 Correct 103 ms 100432 KB Output is correct
24 Correct 85 ms 99832 KB Output is correct
25 Correct 84 ms 99692 KB Output is correct
26 Correct 83 ms 99892 KB Output is correct
27 Correct 139 ms 102920 KB Output is correct
28 Correct 158 ms 102928 KB Output is correct
29 Correct 138 ms 102944 KB Output is correct
30 Correct 115 ms 101704 KB Output is correct
31 Correct 107 ms 101120 KB Output is correct
32 Correct 109 ms 101024 KB Output is correct
33 Correct 1334 ms 143452 KB Output is correct
34 Correct 1561 ms 144140 KB Output is correct
35 Correct 1793 ms 143224 KB Output is correct
36 Correct 667 ms 123020 KB Output is correct
37 Correct 674 ms 123632 KB Output is correct
38 Correct 739 ms 125452 KB Output is correct
39 Correct 380 ms 108448 KB Output is correct
40 Correct 398 ms 108416 KB Output is correct
41 Correct 383 ms 108408 KB Output is correct
42 Correct 483 ms 112448 KB Output is correct
43 Correct 480 ms 117644 KB Output is correct
44 Correct 497 ms 117644 KB Output is correct
45 Correct 487 ms 117660 KB Output is correct
46 Correct 507 ms 117616 KB Output is correct
47 Correct 488 ms 117640 KB Output is correct
48 Correct 515 ms 117644 KB Output is correct
49 Correct 484 ms 117608 KB Output is correct
50 Correct 496 ms 117592 KB Output is correct

Subtask #6
0 / 13.0

# Verdict Execution time Memory Grader output
1 Correct 65 ms 98756 KB Output is correct
2 Correct 64 ms 98756 KB Output is correct
3 Correct 65 ms 98748 KB Output is correct
4 Correct 65 ms 98712 KB Output is correct
5 Correct 64 ms 98756 KB Output is correct
6 Correct 66 ms 98776 KB Output is correct
7 Correct 65 ms 98732 KB Output is correct
8 Correct 69 ms 98812 KB Output is correct
9 Correct 66 ms 98828 KB Output is correct
10 Correct 64 ms 98768 KB Output is correct
11 Correct 65 ms 98824 KB Output is correct
12 Correct 67 ms 98772 KB Output is correct
13 Correct 65 ms 98756 KB Output is correct
14 Correct 69 ms 98752 KB Output is correct
15 Correct 66 ms 98744 KB Output is correct
16 Correct 68 ms 99012 KB Output is correct
17 Correct 69 ms 99144 KB Output is correct
18 Correct 69 ms 99140 KB Output is correct
19 Correct 95 ms 100724 KB Output is correct
20 Correct 87 ms 100804 KB Output is correct
21 Correct 94 ms 100732 KB Output is correct
22 Correct 85 ms 99832 KB Output is correct
23 Correct 103 ms 100432 KB Output is correct
24 Correct 85 ms 99832 KB Output is correct
25 Correct 84 ms 99692 KB Output is correct
26 Correct 83 ms 99892 KB Output is correct
27 Execution timed out 3080 ms 243688 KB Time limit exceeded
28 Halted 0 ms 0 KB -