#include <bits/stdc++.h>
#include "obstacles.h"
using namespace std;
#define ll long long
#define pb push_back
#define ff first
#define ss second
#define _ << " " <<
#define yes cout<<"YES\n"
#define no cout<<"NO\n"
#define ull unsigned long long
#define lll __int128
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define BlueCrowner ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORD(i, a, b) for (ll i = (a); i >= (b); i--)
const ll mod = 1e9 + 7;
const ll mod1 = 998244353;
const ll naim = 1e9;
const ll max_bit = 60;
const ull tom = ULLONG_MAX;
const ll MAXN = 2e6 + 5;
const ll LOG = 20;
const ll NAIM = 1e18;
const ll N = 2e6 + 5;
// ---------- GCD ----------
ll gcd(ll a, ll b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
// ---------- LCM ----------
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}
// ---------- Modular Exponentiation ----------
ll modpow(ll a, ll b, ll m = mod) {
ll c = 1;
a %= m;
while (b > 0) {
if (b & 1) c = c * a % m;
a = a * a % m;
b >>= 1;
}
return c;
}
// ---------- Modular Inverse (Fermat’s Little Theorem) ----------
ll modinv(ll a, ll m = mod) {
return modpow(a, m - 2, m);
}
// ---------- Factorials and Inverse Factorials ----------
ll fact[N], invfact[N];
void pre_fact(ll n = N-1, ll m = mod) {
fact[0] = 1;
for (ll i = 1; i <= n; i++) fact[i] = fact[i-1] * i % m;
invfact[n] = modinv(fact[n], m);
for (ll i = n; i > 0; i--) invfact[i-1] = invfact[i] * i % m;
}
// ---------- nCr ----------
ll nCr(ll n, ll r, ll m = mod) {
if (r < 0 || r > n) return 0;
return fact[n] * invfact[r] % m * invfact[n-r] % m;
}
// ---------- Sieve of Eratosthenes ----------
vector<ll> primes;
bool is_prime[N];
void sieve(ll n = N-1) {
fill(is_prime, is_prime + n + 1, true);
is_prime[0] = is_prime[1] = false;
for (ll i = 2; i * i <= n; i++) {
if (is_prime[i]) {
for (ll j = i * i; j <= n; j += i)
is_prime[j] = false;
}
}
for (ll i = 2; i <= n; i++)
if (is_prime[i]) primes.pb(i);
}
vector<int> t, h;
struct UnionFind {
vector<int> par, sz;
UnionFind(int n) {
par.resize(n);
sz.resize(n, 1);
iota(all(par), 0);
}
int find(int a) {
if(par[a] == a) return a;
return par[a] = find(par[a]);
}
int unite(int a, int b) {
a = find(a);
b = find(b);
if(a == b) return 0;
if(sz[a] < sz[b]) swap(a, b);
par[b] = a;
sz[a] += sz[b];
return 1;
}
};
UnionFind dsu(MAXN);
void initialize(vector<int> T, vector<int> H) {
t = T;
h = H;
ll n = t.size(), m = h.size();
priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<>> inactive_columns;
vector<int> mn(m, 0);
vector<int> id(m, -1);
FOR(i, 0, m) {
mn[i] = h[i];
if(h[i] >= t[0]) inactive_columns.push({h[i], i});
if(i) {
if(t[0] > h[i] && t[0] > h[i - 1]) {
ll a = dsu.find(i), b = dsu.find(i - 1);
dsu.unite(i, i - 1);
ll c = dsu.find(i);
ll d = (c == a ? b : a);
mn[c] = min(mn[c], mn[d]);
}
}
}
FOR(i, 0, m) {
if(t[0] > h[i]) id[i] = dsu.find(i);
}
FOR(i, 1, n) {
while(inactive_columns.size()) {
auto [k, x] = inactive_columns.top();
if(id[x] != -1) {
inactive_columns.pop();
continue;
}
if(t[i] > k) {
inactive_columns.pop();
if(x < m - 1 && id[x + 1] != -1) {
ll a = dsu.find(id[x + 1]), b = dsu.find(x);
dsu.unite(a, b);
ll c = dsu.find(a);
ll d = (c == a ? b : a);
mn[c] = min(mn[c], mn[d]);
id[x] = c;
ll cur = x;
while(cur > 0 && id[cur - 1] == -1 && h[cur - 1] < t[i]) {
ll a = cur - 1, b = dsu.find(cur);
dsu.unite(a, b);
ll c = dsu.find(a);
ll d = (c == a ? b : a);
mn[c] = min(mn[c], mn[d]);
id[cur] = c;
cur--;
}
}
if(x > 0 && id[x - 1] != -1) {
ll a = dsu.find(id[x - 1]), b = dsu.find(x);
dsu.unite(a, b);
ll c = dsu.find(a);
ll d = (c == a ? b : a);
mn[c] = min(mn[c], mn[d]);
id[x] = c;
ll cur = x;
while(cur < m - 1 && id[cur + 1] == -1 && h[cur + 1] < t[i]) {
ll a = cur + 1, b = dsu.find(cur);
dsu.unite(a, b);
ll c = dsu.find(a);
ll d = (c == a ? b : a);
mn[c] = min(mn[c], mn[d]);
id[cur] = c;
cur++;
}
}
}
else break;
}
}
}
bool can_reach(int l, int r, int s, int d) {
if(dsu.find(s) == dsu.find(d)) return 1;
return 0;
}
