Submission #757389

#	Time	Username	Problem	Language	Result	Execution time	Memory
757389		SanguineChameleon	Pyramid Base (IOI08_pyramid_base)	C++17	73 / 100	5047 ms	56040 KiB

pyramid_base

#include <bits/stdc++.h>
using namespace std;
 
void just_do_it();
 
int main() {
	#ifdef KAMIRULEZ
		freopen("kamirulez.inp", "r", stdin);
		freopen("kamirulez.out", "w", stdout);
	#endif
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	just_do_it();
	return 0;
}
 
const int maxN = 1e6 + 20;
const int maxK = 4e5 + 20;
int tree[maxN << 2];
int lazy[maxN << 2];
int Lx[maxK];
int Ly[maxK];
int Rx[maxK];
int Ry[maxK];
int ly[maxK];
int ry[maxK];
int cnt_x[maxN];
int cnt_y[maxN];
int cost[maxK];
int queries[maxK << 2];
pair<int, int> events_x[maxK << 1];
pair<int, int> events_y[maxK << 1];
int N, M, B, K;
 
void reset(int id, int lt, int rt) {
	tree[id] = 0;
	lazy[id] = 0;
	if (lt == rt) {
		return;
	}
	int mt = (lt + rt) >> 1;
	reset(id << 1, lt, mt);
	reset(id << 1 | 1, mt + 1, rt);
}
 
void update(int id, int lt, int rt, int ql, int qr, int add) {
	if (lt == ql && rt == qr) {
		tree[id] += add;
		lazy[id] += add;
		return;
	}
	tree[id << 1] += lazy[id];
	lazy[id << 1] += lazy[id];
	tree[id << 1 | 1] += lazy[id];
	lazy[id << 1 | 1] += lazy[id];
	lazy[id] = 0;
	int mt = (lt + rt) >> 1;
	if (qr <= mt) {
		update(id << 1, lt, mt, ql, qr, add);
	}
	else if (ql >= mt + 1) {
		update(id << 1 | 1, mt + 1, rt, ql, qr, add);
	}
	else {
		update(id << 1, lt, mt, ql, mt, add);
		update(id << 1 | 1, mt + 1, rt, mt + 1, qr, add);
	}
	tree[id] = min(tree[id << 1], tree[id << 1 | 1]);
}
 
bool check(int sz) {
	int n = N - sz + 1;
	int m = M - sz + 1;
	cnt_x[1] = 1;
	cnt_x[n + 1] = 1;
	for (int i = 2; i <= n; i++) {
		cnt_x[i] = 0;
	}
	cnt_y[1] = 1;
	cnt_y[m + 1] = 1;
	for (int i = 2; i <= m; i++) {
		cnt_y[i] = 0;
	}
	for (int i = 1; i <= K; i++) {
		int lx = max(1, Lx[i] - sz + 1);
		int rx = min(n, Rx[i]);
		int ly = max(1, Ly[i] - sz + 1);
		int ry = min(m, Ry[i]);
		if (lx <= rx && ly <= ry) {
			cnt_x[lx]++;
			cnt_x[rx + 1]++;
			cnt_y[ly]++;
			cnt_y[ry + 1]++;
		}
	}
	int sz_x = 0;
	for (int i = 1; i <= n + 1; i++) {
		swap(sz_x, cnt_x[i]);
		sz_x += cnt_x[i];
	}
	int sz_y = 0;
	for (int i = 1; i <= m + 1; i++) {
		swap(sz_y, cnt_y[i]);
		sz_y += cnt_y[i];
	}
	events_x[cnt_x[1]].first = 1;
	events_x[cnt_x[1]].second = 0;
	cnt_x[1]++;
	events_x[cnt_x[n + 1]].first = n + 1;
	events_x[cnt_x[n + 1]].second = 0;
	cnt_x[n + 1]++;
	events_y[cnt_y[1]].first = 1;
	events_y[cnt_y[1]].second = 0;
	cnt_y[1]++;
	events_y[cnt_y[m + 1]].first = m + 1;
	events_y[cnt_y[m + 1]].second = 0;
	cnt_y[m + 1]++;
	for (int i = 1; i <= K; i++) {
		int lx = max(1, Lx[i] - sz + 1);
		int rx = min(n, Rx[i]);
		int ly = max(1, Ly[i] - sz + 1);
		int ry = min(m, Ry[i]);
		if (lx <= rx && ly <= ry) {
			events_x[cnt_x[lx]].first = lx;
			events_x[cnt_x[lx]].second = i;
			cnt_x[lx]++;
			events_x[cnt_x[rx + 1]].first = rx + 1;
			events_x[cnt_x[rx + 1]].second = -i;
			cnt_x[rx + 1]++;
			events_y[cnt_y[ly]].first = ly;
			events_y[cnt_y[ly]].second = i;
			cnt_y[ly]++;
			events_y[cnt_y[ry + 1]].first = ry + 1;
			events_y[cnt_y[ry + 1]].second = -i;
			cnt_y[ry + 1]++;
		}
	}
	n = 0;
	int sz_q = 0;
	for (int i = 0; i < sz_x; i++) {
		if (i == 0 || events_x[i].first != events_x[i - 1].first) {
			if (n) {
				queries[sz_q++] = 0;
			}
			n++;
		}
		int id = events_x[i].second;
		if (id) {
			queries[sz_q++] = id;
		}
	}
	n--;
	m = 0;
	for (int i = 0; i < sz_y; i++) {
		if (i == 0 || events_y[i].first != events_y[i - 1].first) {
			m++;
		}
		int id = events_y[i].second;
		if (id > 0) {
			ly[id] = m;
		}
		else {
			ry[-id] = m - 1;
		}
	}
	m--;
	reset(1, 1, m);
	for (int i = 0; i < sz_q; i++) {
		int id = queries[i];
		if (id > 0) {
			update(1, 1, m, ly[id], ry[id], cost[id]);
		}
		else if (id < 0) {
			update(1, 1, m, ly[-id], ry[-id], -cost[-id]);
		}
		else if (tree[1] <= B) {
			return true;
		}
	}
	return false;
}

const int block = 10000;

void just_do_it() {
	cin >> N >> M >> B >> K;
	int mx = min(N, M);
	for (int i = 1; i <= K; i++) {
		cin >> Lx[i] >> Ly[i] >> Rx[i] >> Ry[i] >> cost[i];
		if (cost[i] > B) {
			int s1 = min(Lx[i] - 1, M);
			int s2 = min(N - Rx[i], M);
			int s3 = min(N, Ly[i] - 1);
			int s4 = min(N, M - Ry[i]);
			mx = min(mx, max(max(max(s1, s2), s3), s4));
		}
	}
	int res = 0;
	while (true) {
		int lt = res + 1;
		int rt = min(mx, lt + block);
		int tmp = rt;
		bool found = false;
		while (lt <= rt) {
			int mt = (lt + rt) >> 1;
			if (check(mt)) {
				res = mt;
				lt = mt + 1;
				found = true;
			}
			else {
				rt = mt - 1;
			}
		}
		if (!found || res < tmp) {
			break;
		}
	}
	cout << res;
}

• Subtask 1: 5 / 5
• Subtask 2: 5 / 5
• Subtask 3: 5 / 5
• Subtask 4: 5 / 5
• Subtask 5: 5 / 5
• Subtask 6: 5 / 5
• Subtask 7: 5 / 5
• Subtask 8: 7 / 7
• Subtask 9: 7 / 7
• Subtask 10: 7 / 7
• Subtask 11: 7 / 7
• Subtask 12: 0 / 7
• Subtask 13: 10 / 10
• Subtask 14: 0 / 10
• Subtask 15: 0 / 10