Submission #838106

#	Time	Username	Problem	Language	Result	Execution time	Memory
838106		pavement	Shortcut (IOI16_shortcut)	C++17	97 / 100	2021 ms	243348 KiB

shortcut

#include "shortcut.h"
#include <bits/stdc++.h>
using namespace std;

#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back

using ll = long long;

ll find_shortcut(int n, vector<int> l, vector<int> d, int c) {
	vector<ll> x(n, 0);
	for (int i = 0; i + 1 < n; i++) {
		x[i + 1] = x[i] + (ll)l[i];
	}
	
	ll min_x = -(ll)1e18, max_x = (ll)1e18, min_y = -(ll)1e18, max_y = (ll)1e18;
	
	vector<tuple<ll, ll, int> > case_1_inserts(n), case_2_inserts(n);
	vector<tuple<ll, ll, ll*, int> > case_1_queries(2 * n), case_2_queries(2 * n);
	
	for (int i = 0; i < n; i++) {
		case_1_inserts[i] = mt(d[i] - x[i], x[i] + d[i], i);
		case_1_queries[2 * i] = mt(- d[i] - x[i], c + d[i] - x[i], &min_x, i);
		case_1_queries[2 * i + 1] = mt(- d[i] - x[i], c + d[i] + x[i], &min_y, i);
		case_2_inserts[i] = mt(d[i] - x[i], -(x[i] - d[i]), i);
		case_2_queries[2 * i] = mt(- d[i] - x[i], - c - d[i] - x[i], &max_x, i);
		case_2_queries[2 * i + 1] = mt(- d[i] - x[i], - c - d[i] + x[i], &max_y, i);
	}
	
	sort(case_1_inserts.begin(), case_1_inserts.end());
	sort(case_1_queries.begin(), case_1_queries.end());
	sort(case_2_inserts.begin(), case_2_inserts.end());
	sort(case_2_queries.begin(), case_2_queries.end());
	reverse(case_1_inserts.begin(), case_1_inserts.end());
	reverse(case_1_queries.begin(), case_1_queries.end());
	reverse(case_2_inserts.begin(), case_2_inserts.end());
	reverse(case_2_queries.begin(), case_2_queries.end());
	
	auto good = [&](ll k) {
		min_x = -(ll)1e18, max_x = (ll)1e18, min_y = -(ll)1e18, max_y = (ll)1e18;
		{
			pair<ll, int> case_1_first_best = mp(-(ll)1e18, -1), case_1_second_best = mp(-(ll)1e18, -1);
			int ptr = 0;
			
			for (auto &[val, offset, addr, idx] : case_1_queries) {
				while (ptr < n && get<0>(case_1_inserts[ptr]) > val + k) {
					auto &[__, val_insert, idx_insert] = case_1_inserts[ptr];
					case_1_second_best = max(case_1_second_best, mp(val_insert, idx_insert));
					if (case_1_second_best > case_1_first_best) {
						swap(case_1_first_best, case_1_second_best);
					}
					ptr++;
				}
				*addr = max(*addr, case_1_first_best.first + (idx == case_1_first_best.second) * (case_1_second_best.first - case_1_first_best.first) + offset - k);
			}
		}
		
		{
			pair<ll, int> case_2_first_best = mp(-(ll)1e18, -1), case_2_second_best = mp(-(ll)1e18, -1);
			int ptr = 0;
			
			for (auto &[val, offset, addr, idx] : case_2_queries) {
				while (ptr < n && get<0>(case_2_inserts[ptr]) > val + k) {
					auto &[__, val_insert, idx_insert] = case_2_inserts[ptr];
					case_2_second_best = max(case_2_second_best, mp(val_insert, idx_insert));
					if (case_2_second_best > case_2_first_best) {
						swap(case_2_first_best, case_2_second_best);
					}
					ptr++;
				}
				*addr = min(*addr, -(case_2_first_best.first + (idx == case_2_first_best.second) * (case_2_second_best.first - case_2_first_best.first)) + offset + k);
			}
		}
		
		if (min_x <= max_x && min_y <= max_y) {
			vector<pair<ll, ll> > vec_1, vec_2;
			for (int j = 0; j < n; j++) {
				ll rb = min(max_x + x[j], max_y - x[j]);
				if (min_x + x[j] <= min_y - x[j]) {
					vec_1.eb(min_y - x[j], rb);
				} else {
					vec_2.eb(min_x + x[j], rb);
				}
			}
			
			int ptr_1 = (int)vec_1.size() - 1, ptr_2 = 0;
			for (int i = 0; i < n; i++) {
				while (ptr_1 >= 0 && vec_1[ptr_1].first <= x[i]) {
					if (x[i] <= vec_1[ptr_1].second) {
						return true;
					}
					ptr_1--;
				}
				while (ptr_2 < (int)vec_2.size() && vec_2[ptr_2].first <= x[i]) {
					if (x[i] <= vec_2[ptr_2].second) {
						return true;
					}
					ptr_2++;
				}
			}
			return false;
		} else {
			return false;
		}
	};
	
	ll lo = 0, hi = (ll)1e15, ans = -1;
	while (lo <= hi) {
		ll mid = (lo + hi) / 2;
		if (good(mid)) {
			ans = mid;
			hi = mid - 1;
		} else {
			lo = mid + 1;
		}
	}
	
	return ans;
}

• Subtask 1: 9 / 9
• Subtask 2: 14 / 14
• Subtask 3: 8 / 8
• Subtask 4: 7 / 7
• Subtask 5: 33 / 33
• Subtask 6: 22 / 22
• Subtask 7: 4 / 4
• Subtask 8: 0 / 3