This documentation is automatically generated by competitive-verifier/competitive-verifier
// competitive-verifier: PROBLEM https://judge.yosupo.jp/problem/area_of_union_of_rectangles
#include "../../template/template.hpp"
#include "../../other/area-of-union-of-rectangles.hpp"
#include "../../other/scanner.hpp"
int main() {
Scanner in(stdin);
int n;
in.read(n);
AreaOfUnionOfRectangles<int> sum(n);
for (int i = 0; i < n; i++) {
int l, d, r, u;
in.read(l, d, r, u);
sum.add_rectangle(l, d, r, u);
}
cout << sum.calc<int64>() << endl;
}
#line 1 "test/verify/yosupo-area-of-union-of-rectangles.test.cpp"
// competitive-verifier: PROBLEM https://judge.yosupo.jp/problem/area_of_union_of_rectangles
#line 1 "template/template.hpp"
#include <bits/stdc++.h>
#if __has_include(<atcoder/all>)
#include <atcoder/all>
#endif
using namespace std;
using int64 = long long;
const int64 infll = (1LL << 62) - 1;
const int inf = (1 << 30) - 1;
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
}
} iosetup;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < (int)v.size(); i++) {
os << v[i] << (i + 1 != v.size() ? " " : "");
}
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &in : v) is >> in;
return is;
}
template <typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
template <typename T = int64>
vector<T> make_v(size_t a) {
return vector<T>(a);
}
template <typename T, typename... Ts>
auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t) fill_v(e, v);
}
template <typename F>
struct FixPoint : F {
explicit FixPoint(F &&f) : F(std::forward<F>(f)) {}
template <typename... Args>
decltype(auto) operator()(Args &&...args) const {
return F::operator()(*this, std::forward<Args>(args)...);
}
};
template <typename F>
inline decltype(auto) MFP(F &&f) {
return FixPoint<F>{std::forward<F>(f)};
}
#line 4 "test/verify/yosupo-area-of-union-of-rectangles.test.cpp"
#line 2 "structure/class/acted-monoid.hpp"
template <typename S2, typename Op, typename E, typename F2, typename Mapping,
typename Composition, typename Id>
struct LambdaActedMonoid {
using S = S2;
using F = F2;
S op(const S &a, const S &b) const { return _op(a, b); }
S e() const { return _e(); }
S mapping(const S &x, const F &f) const { return _mapping(x, f); }
F composition(const F &f, const F &g) const { return _composition(f, g); }
F id() const { return _id(); }
LambdaActedMonoid(Op _op, E _e, Mapping _mapping, Composition _composition,
Id _id)
: _op(_op),
_e(_e),
_mapping(_mapping),
_composition(_composition),
_id(_id) {}
private:
Op _op;
E _e;
Mapping _mapping;
Composition _composition;
Id _id;
};
template <typename Op, typename E, typename Mapping, typename Composition,
typename Id>
LambdaActedMonoid(Op _op, E _e, Mapping _mapping, Composition _composition,
Id _id)
-> LambdaActedMonoid<decltype(_e()), Op, E, decltype(_id()), Mapping,
Composition, Id>;
/*
struct ActedMonoid {
using S = ?;
using F = ?;
static constexpr S op(const S& a, const S& b) {}
static constexpr S e() {}
static constexpr S mapping(const S &x, const F &f) {}
static constexpr F composition(const F &f, const F &g) {}
static constexpr F id() {}
};
*/
#line 2 "structure/segment-tree/lazy-segment-tree.hpp"
template <typename ActedMonoid>
struct LazySegmentTree {
using S = typename ActedMonoid::S;
using F = typename ActedMonoid::F;
private:
ActedMonoid m;
int n{}, sz{}, height{};
vector<S> data;
vector<F> lazy;
inline void update(int k) {
data[k] = m.op(data[2 * k + 0], data[2 * k + 1]);
}
inline void all_apply(int k, const F &x) {
data[k] = m.mapping(data[k], x);
if (k < sz) lazy[k] = m.composition(lazy[k], x);
}
inline void propagate(int k) {
if (lazy[k] != m.id()) {
all_apply(2 * k + 0, lazy[k]);
all_apply(2 * k + 1, lazy[k]);
lazy[k] = m.id();
}
}
public:
LazySegmentTree() = default;
explicit LazySegmentTree(ActedMonoid m, int n) : m(m), n(n) {
sz = 1;
height = 0;
while (sz < n) sz <<= 1, height++;
data.assign(2 * sz, m.e());
lazy.assign(2 * sz, m.id());
}
explicit LazySegmentTree(ActedMonoid m, const vector<S> &v)
: LazySegmentTree(m, v.size()) {
build(v);
}
void build(const vector<S> &v) {
assert(n == (int)v.size());
for (int k = 0; k < n; k++) data[k + sz] = v[k];
for (int k = sz - 1; k > 0; k--) update(k);
}
void set(int k, const S &x) {
k += sz;
for (int i = height; i > 0; i--) propagate(k >> i);
data[k] = x;
for (int i = 1; i <= height; i++) update(k >> i);
}
S get(int k) {
k += sz;
for (int i = height; i > 0; i--) propagate(k >> i);
return data[k];
}
S operator[](int k) { return get(k); }
S prod(int l, int r) {
if (l >= r) return m.e();
l += sz;
r += sz;
for (int i = height; i > 0; i--) {
if (((l >> i) << i) != l) propagate(l >> i);
if (((r >> i) << i) != r) propagate((r - 1) >> i);
}
S L = m.e(), R = m.e();
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) L = m.op(L, data[l++]);
if (r & 1) R = m.op(data[--r], R);
}
return m.op(L, R);
}
S all_prod() const { return data[1]; }
void apply(int k, const F &f) {
k += sz;
for (int i = height; i > 0; i--) propagate(k >> i);
data[k] = m.mapping(data[k], f);
for (int i = 1; i <= height; i++) update(k >> i);
}
void apply(int l, int r, const F &f) {
if (l >= r) return;
l += sz;
r += sz;
for (int i = height; i > 0; i--) {
if (((l >> i) << i) != l) propagate(l >> i);
if (((r >> i) << i) != r) propagate((r - 1) >> i);
}
{
int l2 = l, r2 = r;
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) all_apply(l++, f);
if (r & 1) all_apply(--r, f);
}
l = l2, r = r2;
}
for (int i = 1; i <= height; i++) {
if (((l >> i) << i) != l) update(l >> i);
if (((r >> i) << i) != r) update((r - 1) >> i);
}
}
template <typename C>
int find_first(int l, const C &check) {
if (l >= n) return n;
l += sz;
for (int i = height; i > 0; i--) propagate(l >> i);
S sum = m.e();
do {
while ((l & 1) == 0) l >>= 1;
if (check(m.op(sum, data[l]))) {
while (l < sz) {
propagate(l);
l <<= 1;
auto nxt = m.op(sum, data[l]);
if (not check(nxt)) {
sum = nxt;
l++;
}
}
return l + 1 - sz;
}
sum = m.op(sum, data[l++]);
} while ((l & -l) != l);
return n;
}
template <typename C>
int find_last(int r, const C &check) {
if (r <= 0) return -1;
r += sz;
for (int i = height; i > 0; i--) propagate((r - 1) >> i);
S sum = m.e();
do {
r--;
while (r > 1 and (r & 1)) r >>= 1;
if (check(m.op(data[r], sum))) {
while (r < sz) {
propagate(r);
r = (r << 1) + 1;
auto nxt = m.op(data[r], sum);
if (not check(nxt)) {
sum = nxt;
r--;
}
}
return r - sz;
}
sum = m.op(data[r], sum);
} while ((r & -r) != r);
return -1;
}
};
#line 2 "other/area-of-union-of-rectangles.hpp"
template <typename T>
struct AreaOfUnionOfRectangles {
private:
struct Rectangle {
T l, d, r, u;
};
vector<Rectangle> rectangles;
public:
AreaOfUnionOfRectangles() = default;
explicit AreaOfUnionOfRectangles(int n) : rectangles{} {
rectangles.reserve(n);
}
void add_rectangle(T l, T d, T r, T u) {
assert(l < r and d < u);
rectangles.emplace_back(Rectangle{l, d, r, u});
}
template <typename T2>
T2 calc() const {
int n = (int)rectangles.size();
if (n == 0) return 0;
vector<T> ys;
vector<tuple<T, int, int>> xs;
ys.reserve(n + n);
xs.reserve(n + n);
for (int i = 0; i < n; i++) {
auto &rect = rectangles[i];
ys.emplace_back(rect.d);
ys.emplace_back(rect.u);
xs.emplace_back(rect.l, i, +1);
xs.emplace_back(rect.r, i, -1);
}
sort(ys.begin(), ys.end());
ys.erase(unique(ys.begin(), ys.end()), ys.end());
sort(xs.begin(), xs.end());
vector<int> to_d(n), to_u(n);
for (int i = 0; i < n; i++) {
auto &rect = rectangles[i];
to_d[i] = lower_bound(ys.begin(), ys.end(), rect.d) - ys.begin();
to_u[i] = lower_bound(ys.begin(), ys.end(), rect.u) - ys.begin();
}
using pi = pair<int, T>;
auto f = [](const pi &a, const pi &b) -> pi {
if (a.first < b.first) return a;
if (b.first < a.first) return b;
return {a.first, a.second + b.second};
};
auto e = [&]() -> pi { return {n + 1, 0}; };
auto g = [](const pi &a, int b) -> pi { return {a.first + b, a.second}; };
auto h = [](int a, int b) -> int { return a + b; };
auto id = []() { return 0; };
vector<pi> vs(ys.size() - 1);
for (int i = 0; i + 1 < ys.size(); i++) {
vs[i] = {0, ys[i + 1] - ys[i]};
}
LazySegmentTree seg(LambdaActedMonoid(f, e, g, h, id), vs);
T2 ret = 0;
T total = ys.back() - ys.front();
for (int i = 0; i + 1 < n + n; i++) {
auto &[k, j, d] = xs[i];
seg.apply(to_d[j], to_u[j], d);
auto [v, cnt] = seg.all_prod();
T2 dy = total - (v == 0 ? cnt : 0);
T2 dx = get<0>(xs[i + 1]) - k;
ret += dy * dx;
}
return ret;
}
};
#line 6 "test/verify/yosupo-area-of-union-of-rectangles.test.cpp"
#line 1 "other/scanner.hpp"
/**
* @brief Scanner(高速入力)
*/
struct Scanner {
public:
explicit Scanner(FILE *fp) : fp(fp) {}
template <typename T, typename... E>
void read(T &t, E &...e) {
read_single(t);
read(e...);
}
private:
static constexpr size_t line_size = 1 << 16;
static constexpr size_t int_digits = 20;
char line[line_size + 1] = {};
FILE *fp = nullptr;
char *st = line;
char *ed = line;
void read() {}
static inline bool is_space(char c) { return c <= ' '; }
void reread() {
ptrdiff_t len = ed - st;
memmove(line, st, len);
char *tmp = line + len;
ed = tmp + fread(tmp, 1, line_size - len, fp);
*ed = 0;
st = line;
}
void skip_space() {
while (true) {
if (st == ed) reread();
while (*st && is_space(*st)) ++st;
if (st != ed) return;
}
}
template <typename T, enable_if_t<is_integral<T>::value, int> = 0>
void read_single(T &s) {
skip_space();
if (st + int_digits >= ed) reread();
bool neg = false;
if (is_signed<T>::value && *st == '-') {
neg = true;
++st;
}
typename make_unsigned<T>::type y = *st++ - '0';
while (*st >= '0') {
y = 10 * y + *st++ - '0';
}
s = (neg ? -y : y);
}
template <typename T, enable_if_t<is_same<T, string>::value, int> = 0>
void read_single(T &s) {
s = "";
skip_space();
while (true) {
char *base = st;
while (*st && !is_space(*st)) ++st;
s += string(base, st);
if (st != ed) return;
reread();
}
}
template <typename T>
void read_single(vector<T> &s) {
for (auto &d : s) read(d);
}
};
#line 8 "test/verify/yosupo-area-of-union-of-rectangles.test.cpp"
int main() {
Scanner in(stdin);
int n;
in.read(n);
AreaOfUnionOfRectangles<int> sum(n);
for (int i = 0; i < n; i++) {
int l, d, r, u;
in.read(l, d, r, u);
sum.add_rectangle(l, d, r, u);
}
cout << sum.calc<int64>() << endl;
}
Env | Name | Status | Elapsed | Memory |
---|---|---|---|---|
g++ | edge_bound_00 | AC | 665 ms | 63 MB |
g++ | edge_bound_01 | AC | 675 ms | 63 MB |
g++ | edge_bound_02 | AC | 676 ms | 63 MB |
g++ | edge_bound_03 | AC | 687 ms | 63 MB |
g++ | edge_bound_04 | AC | 650 ms | 63 MB |
g++ | example_00 | AC | 5 ms | 4 MB |
g++ | max_random_00 | AC | 733 ms | 63 MB |
g++ | max_random_01 | AC | 767 ms | 63 MB |
g++ | max_random_02 | AC | 781 ms | 63 MB |
g++ | max_random_03 | AC | 793 ms | 63 MB |
g++ | max_random_04 | AC | 819 ms | 63 MB |
g++ | random_00 | AC | 590 ms | 55 MB |
g++ | random_01 | AC | 722 ms | 60 MB |
g++ | random_02 | AC | 67 ms | 10 MB |
g++ | random_03 | AC | 639 ms | 58 MB |
g++ | random_04 | AC | 390 ms | 47 MB |
g++ | small_00 | AC | 6 ms | 4 MB |
g++ | small_01 | AC | 5 ms | 4 MB |
g++ | small_02 | AC | 5 ms | 4 MB |
g++ | small_03 | AC | 6 ms | 4 MB |
g++ | small_04 | AC | 5 ms | 4 MB |
clang++ | edge_bound_00 | AC | 622 ms | 63 MB |
clang++ | edge_bound_01 | AC | 611 ms | 63 MB |
clang++ | edge_bound_02 | AC | 605 ms | 63 MB |
clang++ | edge_bound_03 | AC | 605 ms | 63 MB |
clang++ | edge_bound_04 | AC | 598 ms | 63 MB |
clang++ | example_00 | AC | 5 ms | 4 MB |
clang++ | max_random_00 | AC | 694 ms | 63 MB |
clang++ | max_random_01 | AC | 686 ms | 63 MB |
clang++ | max_random_02 | AC | 687 ms | 63 MB |
clang++ | max_random_03 | AC | 713 ms | 63 MB |
clang++ | max_random_04 | AC | 695 ms | 63 MB |
clang++ | random_00 | AC | 524 ms | 55 MB |
clang++ | random_01 | AC | 639 ms | 60 MB |
clang++ | random_02 | AC | 62 ms | 10 MB |
clang++ | random_03 | AC | 569 ms | 58 MB |
clang++ | random_04 | AC | 346 ms | 47 MB |
clang++ | small_00 | AC | 6 ms | 4 MB |
clang++ | small_01 | AC | 5 ms | 4 MB |
clang++ | small_02 | AC | 5 ms | 4 MB |
clang++ | small_03 | AC | 6 ms | 4 MB |
clang++ | small_04 | AC | 5 ms | 4 MB |