#include "shortcut.h"
#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#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, bool, ll, ll*, int> > case_1_inserts, case_1_queries, case_2_inserts, case_2_queries;
for (int i = 0; i < n; i++) {
case_1_inserts.eb(d[i] - x[i], 0, x[i] + d[i], nullptr, i);
case_1_queries.eb(- d[i] - x[i], 1, c + d[i] - x[i], &min_x, i);
case_1_queries.eb(- d[i] - x[i], 1, c + d[i] + x[i], &min_y, i);
case_2_inserts.eb(d[i] - x[i], 0, -(x[i] - d[i]), nullptr, i);
case_2_queries.eb(- d[i] - x[i], 1, - c - d[i] - x[i], &max_x, i);
case_2_queries.eb(- d[i] - x[i], 1, - 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());
auto good = [&](ll k) {
min_x = -(ll)1e18, max_x = (ll)1e18, min_y = -(ll)1e18, max_y = (ll)1e18;
{
vector<tuple<ll, bool, ll, ll*, int> > case_1_queries_copy = case_1_queries, case_1_events;
for (auto &i : case_1_queries_copy) {
get<0>(i) += k;
get<2>(i) -= k;
}
merge(case_1_inserts.begin(), case_1_inserts.end(), case_1_queries_copy.begin(), case_1_queries_copy.end(), back_inserter(case_1_events));
reverse(case_1_events.begin(), case_1_events.end());
pair<ll, int> case_1_first_best = mp(-(ll)1e18, -1), case_1_second_best = mp(-(ll)1e18, -1);
for (auto [_, type, offset, addr, idx] : case_1_events) {
if (type == 0) {
case_1_second_best = max(case_1_second_best, mp(offset, idx));
if (case_1_second_best > case_1_first_best) {
swap(case_1_first_best, case_1_second_best);
}
} else {
*addr = max(*addr, (case_1_first_best.second == idx ? case_1_second_best.first : case_1_first_best.first) + offset);
}
}
}
{
vector<tuple<ll, bool, ll, ll*, int> > case_2_queries_copy = case_2_queries, case_2_events;
for (auto &i : case_2_queries_copy) {
get<0>(i) += k;
get<2>(i) += k;
}
merge(case_2_inserts.begin(), case_2_inserts.end(), case_2_queries_copy.begin(), case_2_queries_copy.end(), back_inserter(case_2_events));
reverse(case_2_events.begin(), case_2_events.end());
pair<ll, int> case_2_first_best = mp(-(ll)1e18, -1), case_2_second_best = mp(-(ll)1e18, -1);
for (auto [_, type, offset, addr, idx] : case_2_events) {
if (type == 0) {
case_2_second_best = max(case_2_second_best, mp(offset, idx));
if (case_2_second_best > case_2_first_best) {
swap(case_2_first_best, case_2_second_best);
}
} else {
*addr = min(*addr, -(case_2_first_best.second == idx ? case_2_second_best.first : case_2_first_best.first) + offset);
}
}
}
if (min_x <= max_x && min_y <= max_y) {
set<ll> pos;
for (int j = 1; j < n; j++) {
pos.insert(x[j - 1]);
ll lb = max(min_x + x[j], min_y - x[j]), rb = min(max_x + x[j], max_y - x[j]);
auto it = pos.lower_bound(lb);
if (it != pos.end() && *it <= rb) {
return true;
}
}
return false;
} else {
return false;
}
};
ll lo = 0, hi = (ll)1e16, ans = -1;
while (lo <= hi) {
ll mid = (lo + hi) / 2;
if (good(mid)) {
ans = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
return ans;
}
