#include "seats.h"
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct segment_tree {
int n;
vector<T> s;
T e;
segment_tree() {
}
segment_tree(int _n) {
n = 2 << __lg(_n);
s.resize(2 * n - 1, T());
}
segment_tree(vector<T> &a) : segment_tree(a.size()) {
for (int i = 0; i < a.size(); i++) {
s[i + n - 1] = a[i];
}
for (int i = n - 2; i >= 0; i--) {
s[i] = s[i * 2 + 1] + s[i * 2 + 2];
}
}
void modify(int p, int l, int r, int x, const T &v) {
if (l + 1 == r) {
s[p] = v;
return;
}
int m = (l + r + 1) / 2;
if (x < m) {
modify(p * 2 + 1, l, m, x, v);
} else {
modify(p * 2 + 2, m, r, x, v);
}
s[p] = s[p * 2 + 1] + s[p * 2 + 2];
}
void modify(int x, const T &v) {
modify(0, 0, n, x, v);
}
T range_query(int p, int l, int r, int L, int R) {
if (R <= l || r <= L) {
return T();
}
if (L <= l && r <= R) {
return s[p];
}
int m = (l + r + 1) / 2;
return range_query(p * 2 + 1, l, m, L, R) + range_query(p * 2 + 2, m, r, L, R);
}
T range_query(int l, int r) {
return range_query(0, 0, n, l, r);
}
};
constexpr int inf = 1E9;
struct node {
int l, r, u, d;
node() : l(inf), r(-inf), u(inf), d(-inf) {
}
node(int L, int R, int U, int D) : l(L), r(R), u(U), d(D) {
}
int area() const {
return (r - l + 1) * (d - u + 1);
}
};
node operator+(const node &a, const node &b) {
return node(min(a.l, b.l), max(a.r, b.r), min(a.u, b.u), max(a.d, b.d));
}
int N, M, t = 0;
vector<int> A, B, PL, PR, PU, PD;
bool F(int p) {
return (PR[p] - PL[p] + 1) * (PD[p] - PU[p] + 1) == p;
}
segment_tree<node> S;
void give_initial_chart(int H, int W, vector<int> R, vector<int> C) {
N = H, M = W;
A = R, B = C;
PL = PU = {inf};
PR = PD = {-inf};
for (int i = 0; i < N * M; i++) {
PL.push_back(min(PL.back(), B[i]));
PR.push_back(max(PR.back(), B[i]));
PU.push_back(min(PU.back(), A[i]));
PD.push_back(max(PD.back(), A[i]));
if (F(i + 1)) {
t++;
}
}
vector<node> v(N * M);
for (int i = 0; i < N * M; i++) {
v[i] = node(B[i], B[i], A[i], A[i]);
}
S = segment_tree<node>(v);
}
int swap_seats(int u, int v) {
swap(A[u], A[v]);
swap(B[u], B[v]);
if (N * M <= 10000) {
int ans = 0;
int L = M, R = -1;
int U = N, D = -1;
for (int i = 0; i < N * M; i++) {
L = min(L, B[i]);
R = max(R, B[i]);
U = min(U, A[i]);
D = max(D, A[i]);
if ((R - L + 1) * (D - U + 1) == i + 1) {
ans++;
}
}
return ans;
} else if (N <= 1000 && M <= 1000) {
S.modify(u, node(B[u], B[u], A[u], A[u]));
S.modify(v, node(B[v], B[v], A[v], A[v]));
int ans = 0;
for (int i = 1; i <= N * M;) {
int s = S.range_query(0, i).area();
if (s == i) {
ans++;
i++;
} else {
i = s;
}
}
return ans;
} else {
if (u > v) {
swap(u, v);
}
for (int i = u; i <= v; i++) {
if (F(i + 1)) {
t--;
}
PL[i + 1] = min(PL[i], B[i]);
PR[i + 1] = max(PR[i], B[i]);
PU[i + 1] = min(PU[i], A[i]);
PD[i + 1] = max(PD[i], A[i]);
if (F(i + 1)) {
t++;
}
}
return t;
}
}
