#include "shortcut.h"
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
const lint INF = 2e15;
int N, C;
lint X[1000000]; // location of main stations
lint D[1000000]; // distance of secondary stations
int SUM[1000000]; // index of increasing X[i] + D[i]
int DIF[1000000]; // index of increasing X[i] - D[i]
lint SUM_VAL[1000000]; // stores X[i] + D[i]
lint DIF_VAL[1000000]; // stores X[i] - D[i]
lint max_sum = +INF; // maximum of S1 + S2 that is valid
lint min_sum = -INF; // minimum of S1 + S2 that is valid
lint max_dif = +INF; // maximum of S1 - S2 that is valid
lint min_dif = -INF; // minimum of S1 - S2 that is valid
lint sum_big = -INF; // maximum X[i] + D[i], for all valid i
lint sum_sml = -INF; // second maximum X[i] + D[i], for all valid i
int sum_idx = -1; // index of sum_big
lint dif_sml = +INF; // minimum X[i] - D[i], for all valid i
lint dif_big = +INF; // second minimum X[i] - D[i], for all valid i
int dif_idx = -1; // index of dif_sml
lint sum_val;
lint dif_val;
lint valid_sum;
lint valid_dif;
inline bool is_valid(lint &T) {
max_sum = +INF; // maximum of S1 + S2 that is valid
min_sum = -INF; // minimum of S1 + S2 that is valid
max_dif = +INF; // maximum of S1 - S2 that is valid
min_dif = -INF; // minimum of S1 - S2 that is valid
sum_big = -INF; // maximum X[i] + D[i], for all valid i
sum_sml = -INF; // second maximum X[i] + D[i], for all valid i
sum_idx = -1; // index of sum_big
dif_sml = +INF; // minimum X[i] - D[i], for all valid i
dif_big = +INF; // second minimum X[i] - D[i], for all valid i
dif_idx = -1; // index of dif_sml
for (int j = 0, pos = 0; j < N; j++) {
while (pos < N && SUM_VAL[SUM[j]] - DIF_VAL[DIF[pos]] > T) {
sum_val = SUM_VAL[DIF[pos]];
dif_val = DIF_VAL[DIF[pos]];
if (sum_big < sum_val) {
sum_sml = sum_big;
sum_big = sum_val;
sum_idx = DIF[pos];
} else if (sum_sml < sum_val) {
sum_sml = sum_val;
}
if (dif_sml > dif_val) {
dif_big = dif_sml;
dif_sml = dif_val;
dif_idx = DIF[pos];
} else if (dif_big > dif_val) {
dif_big = dif_val;
}
pos++;
}
valid_sum = ((SUM[j] != sum_idx)? sum_big : sum_sml);
valid_dif = ((SUM[j] != dif_idx)? dif_sml : dif_big);
sum_val = SUM_VAL[SUM[j]];
dif_val = DIF_VAL[SUM[j]];
max_sum = min(max_sum, + T + valid_dif + dif_val - C);
min_sum = max(min_sum, - T + valid_sum + sum_val + C);
max_dif = min(max_dif, + T + valid_dif - sum_val - C);
min_dif = max(min_dif, - T + valid_sum - dif_val + C);
}
if (min_sum > max_sum || min_dif > max_dif)
return false;
for (int i = 0, ptl = 0, ptr = N - 1, pos; i < N; i++) {
while (ptl < N && X[ptl] - X[i] < min_dif) ptl++;
while (ptr >= 0 && X[ptr] + X[i] >= min_sum) ptr--;
pos = max(ptl, ptr + 1);
if (pos < N && min_sum <= X[pos] + X[i] && X[pos] + X[i] <= max_sum
&& min_dif <= X[pos] - X[i] && X[pos] - X[i] <= max_dif)
return true;
}
return false;
}
lint find_shortcut(int n_, vector<int> l_, vector<int> d_, int c_) {
N = n_, C = c_;
for (int i = 0; i < l_.size(); i++)
X[i + 1] = X[i] + l_[i];
for (int i = 0; i < d_.size(); i++)
D[i] = d_[i];
for (int i = 0; i < N; i++) {
SUM_VAL[i] = X[i] + D[i];
DIF_VAL[i] = X[i] - D[i];
}
iota(SUM, SUM + N, 0), iota(DIF, DIF + N, 0);
sort(SUM, SUM + N, [&] (int l, int r) { return SUM_VAL[l] < SUM_VAL[r]; });
sort(DIF, DIF + N, [&] (int l, int r) { return DIF_VAL[l] < DIF_VAL[r]; });
lint res = 0;
for (lint L = 0, R = INF, M = (L + R) / 2; L <= R; M = (L + R) / 2)
if (is_valid(M))
R = M - 1, res = M;
else
L = M + 1;
return res;
}
