답안 #284105

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
284105 2020-08-26T20:03:11 Z inbarin XORanges (eJOI19_xoranges) C++14
100 / 100
555 ms 9592 KB
#include <fstream>
#include <iostream>
#include <vector>
#include <set>
#include <list> 
#include <map>
#include <queue>
#include <deque>
#include <string>
#include <stack>
#include <algorithm>
#include <utility>
#include <math.h>
#include <ctime>

using namespace std;
typedef long long int63;
typedef unsigned long long int64;
#define forl(name,start,end,jump) for(int63 name = start; name < end; name+=jump)
#define forlb(name,start,end,jump) for(int63 name = end - 1; name >= start; name+=jump)
#define forn(name,start,end) forl(name,start,end,1)
#define fornb(name,start,end) forlb(name,start,end,-1)
#define fort(start,end) forn(i,start,end)
#define fortb(start,end) fornb(i,start,end)
#define forto(start,end) forn(j,start,end)
#define fortob(start,end) fornb(j,start,end)
#define fortoo(start,end) forn(l,start,end)
#define all(vec) vec.begin(),vec.end()
#define makeitem(itemname,itemtype) itemtype itemname; cin >> itemname
#define point pair<int63,int63>
#define spoint pair<short,short>
#define ipoint pair<int,int>
#define matrix(type) vector<vector<type>>
#define make(name) int63 name; cin >> name
#define tosort(name) name.begin(),name.end()


int63 powmod(int63 base, int63 exponent, int63 mod) {
	int63 result = 1;
	while (exponent > 0) {
		if (exponent % 2 == 0) {
			exponent /= 2;
			base = (base * base) % mod;
		}
		else {
			result = (result * base) % mod;
			exponent /= 2;
			base = (base * base) % mod;
		}
	}
	return result;
}
bool decresing(int63 x, int63 y) {
	return x > y;
}
int63 modInverse(int63 a, int63 b) {//finds inverse of a mod b ...?
	int63 m = b;
	int63 y = 0, x = 1;
	while (a > 1) {
		int63 q = a / m;
		int63 t = m;
		m = a % m, a = t;
		t = y;
		y = x - q * y;
		x = t;
	}
	if (x < 0) {
		x += b;
	}
	return x;
}
int63 trin(int63 start, int63 stop) {
	return (stop - start + 1) * (stop + start) / 2;
}
int63 trin2(int63 start, int63 stop, int63 mod) {
	return ((stop - start + 1) * (stop + start) / 2) % mod;
}
int63 trig(int63 start, int63 stop, int63 jump, int63 mod) {
	return ((trin2(start / jump, (stop - (start % jump)) / jump, mod)*jump + ((stop - (start % jump)) / jump - (start / jump) + 1) * (start % jump)) % mod);
}
int63 cntot(int63 start, int63 stop, int63 jump, int63 mod) {
	return (stop / jump - (start + jump - 1) / jump + 1) % mod;
}
bool sortvectorf(point a, point b) {
	return((a.first > b.first) || (a.first == b.first && a.second > b.second));
}
bool sortvectordiv(point a, point b) {
	return a.first * b.second > b.first * a.second;
}
bool sortvectorfv(point a, point b) {
	return((a.first > b.first) || (a.first == b.first && a.second < b.second));
}
bool sortvectors(point a, point b) {
	return((a.second > b.second) || (a.second == b.second && a.first > b.first));
}
bool negasortvectorf(point a, point b) {
	return((a.first < b.first) || (a.first == b.first && a.second < b.second));
}
bool negasortvectors(point a, point b) {
	return((a.second < b.second) || (a.second == b.second && a.first < b.first));
}
vector<vector<int63>> findPermutationsI(vector<int63> &a) {

	// Sort the given array
	sort(a.begin(), a.end());
	vector<vector<int63> > sol;
	// Find all possible permutations
	do {
		sol.push_back(a);
	} while (next_permutation(a.begin(), a.end()));
	return sol;
}
vector<vector<string>> findPermutationsS(vector<string> &a) {

	// Sort the given array
	sort(a.begin(), a.end());
	vector<vector<string> > sol;
	// Find all possible permutations
	do {
		sol.push_back(a);
	} while (next_permutation(a.begin(), a.end()));
	return sol;
}
int63 gcd(int63 a, int63 b) {
	if (a == 0) {
		return b;
	}
	if (b == 0) {
		return a;
	}
	return gcd(b % a, a);
}
bool isprime(int63 n) {
	fort(2, n) {
		if (i * i > n) {
			break;
		}
		if ((n / i) * i == n) {
			return false;
		}
	}
	return true;
}
int63 fdivisor(int63 n, int63 fro) {
	fort(1, n + 1) {
		if ((n / i) * i == n && i >= fro) {
			return i;
		}
	}
	return -1;
}
vector<int63> divlist(int63 n) {
	vector<int63> curr;
	fort(1, n + 1) {
		if ((int63)i * i > n) {
			break;
		}
		if ((n / i) * i == n) {
			curr.push_back(i);
			curr.push_back(n / i);
		}
		if ((int63)i * i == n) {
			curr.pop_back();
		}
	}

	sort(all(curr));
	return curr;
}
int63 divcnt(int63 n) {
	int63 ans = 1;
	fort(2, n + 1) {
		if (i*i > n) {
			ans *= 2;
			break;
		}
		int63 cur = 1;
		while (n % i == 0) {
			n /= i;
			cur++;
		}
		ans *= cur;
	}
	return ans;
}
vector<int63> pdivlist(int63 n) {
	vector<int63> curr;
	fort(2, n + 1) {
		if ((int63)i * i > n) {
			break;
		}
		if ((n / i) * i == n) {
			if (isprime(i)) { curr.push_back(i); }
			if (isprime(n / i)) { curr.push_back(n / i); }
		}
		if ((int63)i * i == n && isprime(i)) {
			curr.pop_back();
		}
	}

	sort(all(curr));
	return curr;
}
int63 countdivisors(int63 n, int63 divd, int63 rem) {
	vector<int63> divs = divlist(n);
	int63 tot = 0;
	fort(0, (int63)divs.size()) {
		if (divs[(int)i] % divd == rem) {
			tot++;
		}
	}
	if (n % divd == rem) {
		tot++;
	}
	return tot;
}
int63 digsum(int63 num) {
	int63 cr = 0;
	while (num) {
		cr += num % 10;
		num /= 10;
	}
	return cr;
}
int63 azeret(int63 num, int63 mod) {
	int63 sil = 1;
	while (num > 1) {
		sil *= num;
		sil %= mod;
		num--;
	}
	return sil;
}
int63 moddiv(int63 to, int63 by, int63 mod) {
	to %= mod;
	by %= mod;
	to *= modInverse(by, mod);
	return to % mod;
}
class node {
public:
	int data1;
	int data2;
	node* nxt;
	node* bef;
	node(int dat1, int dat2, node*bif) {
		this->nxt = NULL;
		this->bef = bif;
		this->bef->nxt = this;
		this->data1 = dat1;
		this->data2 = dat2;
	}
	node(int dat1, int dat2) {
		this->nxt = NULL;
		this->bef = NULL;
		this->data1 = dat1;
		this->data2 = dat2;
	}
	node() {
		this->nxt = NULL;
		this->bef = NULL;
		this->data1 = 0;
		this->data2 = 0;
	}
	void remove() {
		this->bef->nxt = this->nxt;
		if (this->nxt != NULL) {
			this->nxt->bef = this->bef;
		}
	}
	void push(int dat1, int dat2) {
		node* next = this->nxt;
		node* curr = new node(dat1, dat2, this);
		curr->nxt = next;
		next->bef = curr;
	}
};
bool by_first(pair<point, point> a, pair<point, point> b) {
	return a.first.first < b.first.first;
}
bool ff_fs(pair<pair<int63, bool>, int63> a, pair<pair<int63, bool>, int63> b) {
	return a.first.first < b.first.first || (a.first.first == b.first.first && a.first.second && !b.first.second);
}
bool f_s_b(pair<int63, int63> a, pair<int63, int63> b) {
	return a.first > b.first || (a.first == b.first && a.second > b.second);
}
bool palindrome(string s) {
	fort(0, (int63)s.size() / 2) {
		if (s[(int)i] != s[s.size() - 1 - (int)i]) {
			return 0;
		}
	}
	return 1;
}
struct union_find {
	vector<int>rot;
	vector<int> posrat;
	vector<vector<int>> rat;
	int63 cnt;
	void init(int n) {
		fort(0, n) {
			rot.push_back((int)i);
			rat.push_back({ (int)i });
			posrat.push_back((int)i);
		}
		cnt = n;
	}
	bool isunion(int f, int s) {
		if (rot[f] == rot[s]) {
			return true;
		}
		return false;
	}
	bool unio(int f, int s) {
		if (rot[f] == rot[s]) {
			return false;
		}
		cnt--;
		//rot[f] <-> rot[s]
		if (rat[(int)posrat[rot[f]]].size() > rat[(int)posrat[rot[s]]].size()) {
			//s to f
			int siz = rat[posrat[rot[s]]].size();
			int rs = rot[s];
			fort(0, siz) {
				rat[posrat[rot[f]]].push_back(rat[posrat[rs]][(int)i]);
				rot[rat[posrat[rs]][(int)i]] = rot[f];
			}
			rat[rs].clear();
			return true;
		}
		int siz = rat[posrat[rot[f]]].size();
		int rf = rot[f];
		fort(0, siz) {
			rat[posrat[rot[s]]].push_back(rat[posrat[rf]][(int)i]);
			rot[rat[posrat[rf]][(int)i]] = rot[s];
		}
		rat[rf].clear();
		return true;
	}
};
vector<int63> subsum(vector<int> items, int limit) {
	vector<vector<int> > table(items.size() + 1, vector<int>(limit + 1));
	forto(1, (int63)items.size() + 1) {
		int wt = items[(int)j - 1];
		int val = wt;
		for (int w = 1; w < limit + 1; w++) {
			if (wt > w) {
				table[(int)j][w] = table[(int)j - 1][w];
			}
			else {
				table[(int)j][w] = max(table[(int)j - 1][w], (int)(table[(int)j - 1][w - wt] + val));
			}
		}
	}
	vector<int63> result;
	int w = limit;
	for (int63 j = (int63)items.size(); j > 0; j--) {
		bool was_added = table[(int)j][w] != table[(int)j - 1][w];
		if (was_added) {
			int wt = items[(int)j - 1];
			result.push_back((int)j - 1);
			w -= wt;
		}
	}
	sort(all(result));
	return result;
}
bool func(pair<point, int63>a, pair<point, int63>b) {
	return a.first.second < b.first.second || (a.first.second == b.first.second && a.first.first < b.first.first);
}
int63 palpref(string &s) {
	int63 ha1 = 0, ha2 = 0, hr1 = 0, hr2 = 0;
	int63 m1 = 1, m2 = 1;
	int63 mix = 0;
	forto(0, (int63)s.size()) {
		ha1 = (ha1 + m1 * s[(int)j]) % 1000000007;
		ha2 = (ha2 + m2 * s[(int)j]) % 998244353;

		hr1 = (s[(int)j] + 359 * hr1) % 1000000007;
		hr2 = (s[(int)j] + 401 * hr2) % 998244353;

		m1 *= 359, m1 %= 1000000007;
		m2 *= 401, m2 %= 998244353;

		if (ha1 == hr1 && ha2 == hr2) {
			mix = j + 1;
		}
	}
	return mix;
}
struct fenwick {
	int n;
	vector<int63> data;
	vector<int63> real;
	void init(int n) {
		this->n = n;
		data.resize(n);
		real.resize(n);
	}
	void update(int pos, int63 val) {
		int rpos = pos;
		pos++;
		int63 cur = 0;
		while (pos << cur <= this->n) {
			if (pos % 2 == 1) {
				this->data[(pos << cur) - 1] += val - this->real[rpos];
			}
			cur++;
			pos = (pos + 1) / 2;
		}
		this->real[rpos] = val;
	}
	void add(int pos, int63 val) {
		int rpos = pos;
		pos++;
		int63 cur = 0;
		while (pos << cur <= this->n) {
			if (pos % 2 == 1) {
				this->data[(pos << cur) - 1] += val;
			}
			cur++;
			pos = (pos + 1) / 2;
		}
		this->real[rpos] += val;
	}
	int63 query0(int a) {
		int63 sol = 0;
		int63 cur = 0;
		a++;
		while (a) {
			if (a % 2 == 1) {
				sol += this->data[(a << cur) - 1];
			}
			cur++;
			a = a / 2;
		}
		return sol;
	}
	int63 query(int a, int b) {
		return query0(b) - query0(a - 1);
	}
};
struct fenwick2 {
	int63 n, m;
	vector<vector<int63>> data;
	vector<vector<int63>> real;
	void init(int n, int m) {
		this->n = n;
		this->m = m;
		data = vector<vector<int63>>(n, vector<int63>(m));
		real = vector<vector<int63>>(n, vector<int63>(m));
	}
	void update(int posx, int posy, int63 val) {
		int rposx = posx;
		int rposy = posy;
		posx++;
		posy++;
		int63 cur2 = 0;
		while (posy << cur2 <= this->m) {
			if (posy % 2 == 1) {
				int63 cur1 = 0;
				while (posx << cur1 <= this->n) {
					if (posx % 2 == 1) {
						this->data[(posx << cur1) - 1][(posy << cur2) - 1] += val - this->real[rposx][rposy];
					}
					cur1++;
					posx = (posx + 1) / 2;
				}
				posx = rposx + 1;
			}
			cur2++;
			posy = (posy + 1) / 2;
		}
		this->real[rposx][rposy] = val;
	}
	int63 query0(int x, int y) {
		int63 sol = 0;
		int63 cur2 = 0;
		y++;
		int cx = x + 1;
		while (y) {
			if (y % 2 == 1) {
				int63 cur1 = 0;
				x = cx;
				while (x) {
					if (x % 2 == 1) {
						sol += this->data[(x << cur1) - 1][(y << cur2) - 1];
					}
					cur1++;
					x = x / 2;
				}
			}
			cur2++;
			y = y / 2;
		}
		return sol;
	}
	int63 query(int fx, int fy, int sx, int sy) {
		return this->query0(sx, sy) - this->query0(sx, fy - 1) - this->query0(fx - 1, sy) + this->query0(fx - 1, fy - 1);
	}
};
double diffclock(clock_t clock1, clock_t clock2) {
	double diffticks = clock1 - clock2;
	double diffms = (diffticks) / (CLOCKS_PER_SEC / 1000);
	return diffms;
}
int63 detrig(int63 num) {
	int63 minus = 0;
	while (true) {
		num -= minus;
		if (num < 0) {
			return minus;
		}
		if (num - trin(minus + 1, minus + 1000) >= 0) {
			num -= trin(minus + 1, minus + 1000);
			minus += 1000;
		}
		minus++;
	}
}
int63 detrig2(int63 num, int63 minus) {
	while (true) {
		num -= minus;
		if (num < 0) {
			return minus;
		}
		if (num - trig(minus + 2, minus + 1000, 2, 4999999999999999999) >= 0) {
			num -= trig(minus + 2, minus + 1000, 2, 4999999999999999999);
			minus += 1000;
		}
		minus += 2;
	}
}
# define PI 3.14159265358979323846
struct ifenwick {
	int63 n;
	vector<int> data;
	vector<int> real;
	void init(int n) {
		this->n = n;
		data.resize(n);
		real.resize(n);
	}
	void add(int pos, int val) {
		int rpos = pos;
		pos++;
		int cur = 0;
		while (pos << cur <= this->n) {
			if (pos % 2 == 1) {
				this->data[(pos << cur) - 1] += val;
			}
			cur++;
			pos = (pos + 1) / 2;
		}
		this->real[rpos] += val;
	}
	int query0(int a) {
		int sol = 0;
		int cur = 0;
		a++;
		while (a) {
			if (a % 2 == 1) {
				sol += this->data[(a << cur) - 1];
			}
			cur++;
			a /= 2;
		}
		return sol;
	}
};

#define MOD % 1000000007
#define mod 1000000007






struct treestruct {
	int63 n;
	int63 root;
	vector<int63>layer;
	vector<vector<int63>>jumps;
	void initialize(int63 N) {
		n = N;
		jumps = vector<vector<int63>>(n, vector<int63>(18));
		layer = vector<int63>(n, -1);
	}
	void setroot(int63 a) {
		root = a;
		layer[root] = 0;
		jumps[root][0] = root;
	}
	bool addedge(int63 a, int63 b) {
		if (layer[a] == -1) {
			return false;
		}
		layer[b] = layer[a] + 1;
		jumps[b][0] = a;
		return true;
	}
	void lift() {
		forto(1, 18) {
			fort(0, n) {
				jumps[i][j] = jumps[jumps[i][j - 1]][j - 1];
			}
		}
	}
	int63 dist(int63 a, int63 b) {
		if (a == b) {
			return 0;
		}
		if (layer[a] <= layer[b]) {
			return -1;
		}
		int63 dif = layer[a] - layer[b];
		int63 ans = dif;
		fortb(0, 18) {
			if (dif >= (1 << i)) {
				dif -= (1 << i);
				a = jumps[a][i];
			}
		}
		if (a == b) {
			return ans;
		}
		return -1;
	}															   
};																   
																   
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	make(n);
	make(q);
	vector<vector<int63>>v1(17),v2(17);
	v1[0].resize(n/2 + 2);
	v2[0].resize(n/2 + 2);
	fort(0, (n/2)) {
		cin >> v1[0][i];
		cin >> v2[0][i];
	}
	if (n % 2) {
		cin >> v1[0][n / 2];
	}
	forto(1, 17) {
		v1[j].resize((v1[j - 1].size() + 1) / 2);
		fort(0, v1[j].size()) {
			if (v1[j - 1].size() > i * 2 + 1) {
				v1[j][i] = v1[j - 1][i * 2] ^ v1[j - 1][i * 2 + 1];
			} else {
				v1[j][i] = v1[j - 1][i * 2];
			}
		}
		v2[j].resize((v2[j - 1].size() + 1) / 2);
		fort(0, v2[j].size()) {
			if (v2[j - 1].size() > i * 2 + 1) {
				v2[j][i] = v2[j - 1][i * 2] ^ v2[j - 1][i * 2 + 1];
			} else {
				v2[j][i] = v2[j - 1][i * 2];
			}
		}
	}
	fortoo(0, q) {
		make(t);
		make(a);
		make(b);
		if (t == 1) {
			a--;
			if (a % 2) {
				a /= 2;
				v2[0][a] = b;
				forto(1, 17) {
					a /= 2;
					if (v2[j - 1].size() > a * 2 + 1) {
						v2[j][a] = v2[j - 1][a * 2] ^ v2[j - 1][a * 2 + 1];
					} else {
						v2[j][a] = v2[j - 1][a * 2];
					}
				}
			} else {
				a /= 2;
				v1[0][a] = b;
				forto(1, 17) {
					a /= 2;
					if (v1[j - 1].size() > a * 2 + 1) {
						v1[j][a] = v1[j - 1][a * 2] ^ v1[j - 1][a * 2 + 1];
					} else {
						v1[j][a] = v1[j - 1][a * 2];
					}
				}
			}
		} else {
			int63 j = 0;
			int63 ans = 0;
			a--;
			b--;
			if (((b - a) % 2) == 1) {
				cout << 0 << endl;
				continue;
			}
			if (a % 2) {
				a /= 2;
				b /= 2;
				while (b > a) {
					if ((b % 2) == 0) {
						ans ^= v2[j][b];
					}
					b--;
					b /= 2;
					if ((a % 2) == 1) {
						ans ^= v2[j][a];
					}
					a++;
					a /= 2;
					j++;
				}
				if (a == b) {
					ans ^= v2[j][a];
				}
				cout << ans << endl;
			} else {
				a /= 2;
				b /= 2;
				while (b > a) {
					if ((b % 2) == 0) {
						ans ^= v1[j][b];
					}
					b--;
					b /= 2;
					if ((a % 2) == 1) {
						ans ^= v1[j][a];
					}
					a++;
					a /= 2;
					j++;
				}
				if (a == b) {
					ans ^= v1[j][a];
				}
				cout << ans << endl;
			}
		}
	}
	return 0;
}

Compilation message

xoranges.cpp: In function 'int main()':
xoranges.cpp:19:64: warning: comparison of integer expressions of different signedness: 'int63' {aka 'long long int'} and 'std::vector<long long int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   19 | #define forl(name,start,end,jump) for(int63 name = start; name < end; name+=jump)
      |                                                                ^
xoranges.cpp:21:30: note: in expansion of macro 'forl'
   21 | #define forn(name,start,end) forl(name,start,end,1)
      |                              ^~~~
xoranges.cpp:23:25: note: in expansion of macro 'forn'
   23 | #define fort(start,end) forn(i,start,end)
      |                         ^~~~
xoranges.cpp:650:3: note: in expansion of macro 'fort'
  650 |   fort(0, v1[j].size()) {
      |   ^~~~
xoranges.cpp:651:25: warning: comparison of integer expressions of different signedness: 'std::vector<long long int>::size_type' {aka 'long unsigned int'} and 'int63' {aka 'long long int'} [-Wsign-compare]
  651 |    if (v1[j - 1].size() > i * 2 + 1) {
      |        ~~~~~~~~~~~~~~~~~^~~~~~~~~~~
xoranges.cpp:19:64: warning: comparison of integer expressions of different signedness: 'int63' {aka 'long long int'} and 'std::vector<long long int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   19 | #define forl(name,start,end,jump) for(int63 name = start; name < end; name+=jump)
      |                                                                ^
xoranges.cpp:21:30: note: in expansion of macro 'forl'
   21 | #define forn(name,start,end) forl(name,start,end,1)
      |                              ^~~~
xoranges.cpp:23:25: note: in expansion of macro 'forn'
   23 | #define fort(start,end) forn(i,start,end)
      |                         ^~~~
xoranges.cpp:658:3: note: in expansion of macro 'fort'
  658 |   fort(0, v2[j].size()) {
      |   ^~~~
xoranges.cpp:659:25: warning: comparison of integer expressions of different signedness: 'std::vector<long long int>::size_type' {aka 'long unsigned int'} and 'int63' {aka 'long long int'} [-Wsign-compare]
  659 |    if (v2[j - 1].size() > i * 2 + 1) {
      |        ~~~~~~~~~~~~~~~~~^~~~~~~~~~~
xoranges.cpp:677:27: warning: comparison of integer expressions of different signedness: 'std::vector<long long int>::size_type' {aka 'long unsigned int'} and 'int63' {aka 'long long int'} [-Wsign-compare]
  677 |      if (v2[j - 1].size() > a * 2 + 1) {
      |          ~~~~~~~~~~~~~~~~~^~~~~~~~~~~
xoranges.cpp:688:27: warning: comparison of integer expressions of different signedness: 'std::vector<long long int>::size_type' {aka 'long unsigned int'} and 'int63' {aka 'long long int'} [-Wsign-compare]
  688 |      if (v1[j - 1].size() > a * 2 + 1) {
      |          ~~~~~~~~~~~~~~~~~^~~~~~~~~~~
# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 384 KB Output is correct
2 Correct 1 ms 384 KB Output is correct
3 Correct 1 ms 384 KB Output is correct
4 Correct 1 ms 384 KB Output is correct
5 Correct 1 ms 384 KB Output is correct
# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 384 KB Output is correct
2 Correct 2 ms 384 KB Output is correct
3 Correct 2 ms 384 KB Output is correct
4 Correct 2 ms 384 KB Output is correct
5 Correct 2 ms 384 KB Output is correct
# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 384 KB Output is correct
2 Correct 1 ms 384 KB Output is correct
3 Correct 1 ms 384 KB Output is correct
4 Correct 1 ms 384 KB Output is correct
5 Correct 1 ms 384 KB Output is correct
6 Correct 2 ms 384 KB Output is correct
7 Correct 2 ms 384 KB Output is correct
8 Correct 2 ms 384 KB Output is correct
9 Correct 2 ms 384 KB Output is correct
10 Correct 2 ms 384 KB Output is correct
11 Correct 8 ms 512 KB Output is correct
12 Correct 8 ms 512 KB Output is correct
13 Correct 16 ms 512 KB Output is correct
14 Correct 13 ms 512 KB Output is correct
# 결과 실행 시간 메모리 Grader output
1 Correct 555 ms 7160 KB Output is correct
2 Correct 546 ms 9592 KB Output is correct
3 Correct 542 ms 9468 KB Output is correct
4 Correct 537 ms 9336 KB Output is correct
5 Correct 551 ms 9208 KB Output is correct
# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 384 KB Output is correct
2 Correct 1 ms 384 KB Output is correct
3 Correct 1 ms 384 KB Output is correct
4 Correct 1 ms 384 KB Output is correct
5 Correct 1 ms 384 KB Output is correct
6 Correct 2 ms 384 KB Output is correct
7 Correct 2 ms 384 KB Output is correct
8 Correct 2 ms 384 KB Output is correct
9 Correct 2 ms 384 KB Output is correct
10 Correct 2 ms 384 KB Output is correct
11 Correct 8 ms 512 KB Output is correct
12 Correct 8 ms 512 KB Output is correct
13 Correct 16 ms 512 KB Output is correct
14 Correct 13 ms 512 KB Output is correct
15 Correct 555 ms 7160 KB Output is correct
16 Correct 546 ms 9592 KB Output is correct
17 Correct 542 ms 9468 KB Output is correct
18 Correct 537 ms 9336 KB Output is correct
19 Correct 551 ms 9208 KB Output is correct
20 Correct 348 ms 9336 KB Output is correct
21 Correct 338 ms 9208 KB Output is correct
22 Correct 337 ms 9256 KB Output is correct
23 Correct 528 ms 9208 KB Output is correct
24 Correct 508 ms 9208 KB Output is correct