Src/Utility/AreaOfUnionOfRectangles.hpp

• View this file on GitHub
• Last update: 2025-06-25 16:48:25+09:00
• Include: #include "Src/Utility/AreaOfUnionOfRectangles.hpp"

Depends on

• Src/Algebra/Monoid/AdditionMonoid.hpp
• Src/Algebra/Monoid/MinCountMonoid.hpp
• Src/Algebra/Monoid/MonoidConcept.hpp
• Src/Algebra/Semigroup/SemigroupConcept.hpp
• Lazy Segment Tree (Src/DataStructure/SegmentTree/LazySegmentTree.hpp)
• Src/DataStructure/SegmentTree/SegmentTreeConcept.hpp
• 標準データ型のエイリアス (Src/Template/TypeAlias.hpp)

Verified with

• Test/AtCoder/abc346_g.test.cpp
• Test/LC/area_of_union_of_rectangles.test.cpp

Code

#pragma once

#include "../Template/TypeAlias.hpp"
#include "../Algebra/Monoid/AdditionMonoid.hpp"
#include "../Algebra/Monoid/MinCountMonoid.hpp"
#include "../DataStructure/SegmentTree/LazySegmentTree.hpp"

#include <algorithm>
#include <cassert>
#include <type_traits>
#include <utility>

namespace zawa {

template <class T>
class Rectangle {
public:

    Rectangle() = default;
     
    Rectangle(T l, T d, T r, T u)
        : l_{l}, d_{d}, r_{r}, u_{u} {
        assert(l <= r);
        assert(d <= u);
    }

    Rectangle(const std::pair<T, T>& ld, const std::pair<T, T>& ru)
        : l_{ld.first}, d_{ld.second}, r_{ru.first}, u_{ru.second} {}

    Rectangle(const std::pair<T, T>& ld, T w, T h)
        : l_{ld.first}, d_{ld.second}, r_{l_ + w}, u_{d_ + h} {}

    inline T left() const noexcept {
        return l_;
    }

    inline T right() const noexcept {
        return r_;
    }

    inline T down() const noexcept {
        return d_;
    }

    inline T up() const noexcept {
        return u_;
    }

private:
    // 左下、右上
    T l_{}, d_{}, r_{}, u_{};
};

namespace internal {

struct AreaOfUnionOfRectanglesStructure {
    using ValueMonoid = MinCountMonoid<i32, u64>;
    using OperatorMonoid = AdditionMonoid<i32>;
    static ValueMonoid::Element mapping(const ValueMonoid::Element& V, const OperatorMonoid::Element& R) {
        return ValueMonoid::Element{ V.first + R, V.second };
    }
    static ValueMonoid::Element generate(u64 v) {
        return ValueMonoid::Element{ 0, v };
    }
};

} // namespace internal

template <class T, class InputIterator>
u64 AreaOfUnionOfRectangles(InputIterator first, InputIterator last) {
    static_assert(std::is_same_v<std::remove_reference_t<decltype(*first)>, Rectangle<T>>, "*iterator 's type must be T");
    usize n{static_cast<usize>(std::distance(first, last))};
    if (n == 0u) return u64{};
    std::vector<T> xs, ys;
    xs.reserve(2u * n);
    ys.reserve(2u * n);
    for (auto it{first} ; it != last ; it++) {
       xs.push_back(it->left()); 
       xs.push_back(it->right());
       ys.push_back(it->down()); 
       ys.push_back(it->up());
    }
    std::sort(ys.begin(), ys.end());
    ys.erase(std::unique(ys.begin(), ys.end()), ys.end());
    std::sort(xs.begin(), xs.end());
    xs.erase(std::unique(xs.begin(), xs.end()), xs.end());
    std::vector<std::vector<std::pair<std::pair<u32, u32>, bool>>> event(xs.size());
    for (auto it{first} ; it != last ; it++) {
        u32 l{static_cast<u32>(std::distance(ys.begin(), std::lower_bound(ys.begin(), ys.end(), it->down())))};
        u32 r{static_cast<u32>(std::distance(ys.begin(), std::lower_bound(ys.begin(), ys.end(), it->up())))};
        event[static_cast<u32>(std::distance(xs.begin(), std::lower_bound(xs.begin(), xs.end(), it->left())))]
            .emplace_back(std::pair<u32, u32>{ l, r }, true);
        event[static_cast<u32>(std::distance(xs.begin(), std::lower_bound(xs.begin(), xs.end(), it->right())))]
            .emplace_back(std::pair<u32, u32>{ l, r }, false);
    } 
    using S = internal::AreaOfUnionOfRectanglesStructure;
    std::vector<S::ValueMonoid::Element> init(ys.size() - 1);
    for (usize i{} ; i + 1 < ys.size() ; i++) {
        init[i] = S::generate(static_cast<u64>(ys[i + 1] - ys[i]));
    } 
    u64 all{static_cast<u64>(ys.back() - ys.front())};
    LazySegmentTree<S> seg{init};
    u64 res{};
    for (u32 x{} ; x < xs.size() ; x++) {
        if (x >= 1u) {
            auto [min, count]{seg.product(0, init.size())};
            res += (all - (min == 0 ? count : u64{})) * (xs[x] - xs[x - 1]);
        }
        for (const auto& [lr, v] : event[x]) {
            seg.operation(lr.first, lr.second, (v ? +1 : -1));
        }
    }
    return res;
}

} // namespace zawa

#line 2 "Src/Utility/AreaOfUnionOfRectangles.hpp"

#line 2 "Src/Template/TypeAlias.hpp"

#include <cstdint>
#include <cstddef>

namespace zawa {

using i16 = std::int16_t;
using i32 = std::int32_t;
using i64 = std::int64_t;
using i128 = __int128_t;

using u8 = std::uint8_t;
using u16 = std::uint16_t;
using u32 = std::uint32_t;
using u64 = std::uint64_t;

using usize = std::size_t;

} // namespace zawa
#line 2 "Src/Algebra/Monoid/AdditionMonoid.hpp"

namespace zawa {

template <class T>
struct AdditionMonoid {
    using Element = T;
    static T identity() noexcept {
        return T{};
    }
    static T operation(const T& a, const T& b) noexcept {
        return a + b;
    }
};

} // namespace zawa
#line 2 "Src/Algebra/Monoid/MinCountMonoid.hpp"

#include <limits>
#include <utility>

namespace zawa {

template <class T, class U>
struct MinCountMonoid {
    // min, countの順
    using Element = std::pair<T, U>;

    static Element identity() noexcept {
        return { std::numeric_limits<T>::max(), U{} };
    }

    static Element operation(const Element& L, const Element& R) {
        if (L.first < R.first) return L;
        else if (L.first > R.first) return R;
        else return Element{ L.first, L.second + R.second };
    }

};

} // namespace 
#line 2 "Src/DataStructure/SegmentTree/LazySegmentTree.hpp"

#line 2 "Src/DataStructure/SegmentTree/SegmentTreeConcept.hpp"

#line 2 "Src/Algebra/Monoid/MonoidConcept.hpp"

#line 2 "Src/Algebra/Semigroup/SemigroupConcept.hpp"

#include <concepts>

namespace zawa {

namespace concepts {

template <class T>
concept Semigroup = requires {
    typename T::Element;
    { T::operation(std::declval<typename T::Element>(), std::declval<typename T::Element>()) } -> std::same_as<typename T::Element>;
};

} // namespace concepts

} // namespace zawa
#line 4 "Src/Algebra/Monoid/MonoidConcept.hpp"

#line 6 "Src/Algebra/Monoid/MonoidConcept.hpp"

namespace zawa {

namespace concepts {

template <class T>
concept Identitiable = requires {
    typename T::Element;
    { T::identity() } -> std::same_as<typename T::Element>;
};

template <class T>
concept Monoid = Semigroup<T> and Identitiable<T>;

} // namespace

} // namespace zawa
#line 4 "Src/DataStructure/SegmentTree/SegmentTreeConcept.hpp"

namespace zawa {

namespace concepts {

template <class T>
concept MonoidWithAction = requires {
    requires Monoid<typename T::ValueMonoid>;
    requires Monoid<typename T::OperatorMonoid>;
    { T::mapping(
            std::declval<typename T::ValueMonoid::Element>(),
            std::declval<typename T::OperatorMonoid::Element>()
            ) } -> std::same_as<typename T::ValueMonoid::Element>; 
};

} // namespace concepts

} // namespace zawa
#line 5 "Src/DataStructure/SegmentTree/LazySegmentTree.hpp"

#include <algorithm>
#include <bit>
#include <cassert>
#include <ranges>
#include <tuple>
#include <vector>

namespace zawa {

template <concepts::MonoidWithAction S>
class LazySegmentTree {
public:

    using VM = S::ValueMonoid;

    using V = typename VM::Element;

    using OM = S::OperatorMonoid;

    using O = typename OM::Element;

    LazySegmentTree() = default;

    explicit LazySegmentTree(usize n) 
        : m_n{n}, m_sz{1u << (std::bit_width(n))}, m_dat(m_sz << 1, VM::identity()), m_lazy(m_sz << 1, OM::identity()) {}

    explicit LazySegmentTree(const std::vector<V>& a)
        : m_n{a.size()}, m_sz{1u << (std::bit_width(a.size()))}, m_dat(m_sz << 1, VM::identity()), m_lazy(m_sz << 1, OM::identity()) {
        std::ranges::copy(a, m_dat.begin() + inner_size());
        for (usize i = inner_size() ; --i ; ) recalc(i);
    }

    [[nodiscard]] inline usize size() const noexcept {
        return m_n;
    }

    [[nodiscard]] V operator[](usize i) {
        assert(i < size());
        return get(i, 1, 0, inner_size());
    }

    [[nodiscard]] V get(usize i) {
        return (*this)[i];
    }

    [[nodiscard]] V product(usize l, usize r) {
        assert(l <= r and r <= size());
        return product(l, r, 1, 0, inner_size());
    }

    void operation(usize l, usize r, const O& o) {
        assert(l <= r and r <= size());
        return operation(l, r, o, 1, 0, inner_size());
    }

    void assign(usize i, const V& v) {
        assert(i < size());
        assign(i, v, 1, 0, inner_size());
    }

    void operation(usize i, const O& o) {
        assert(i < size());
        operation(i, o, 1, 0, inner_size());
    }

private:

    using NodeInfo = std::tuple<usize, usize, usize>;

public:

    template <class F>
    requires std::predicate<F, V>
    usize maxRight(usize l, F f) {
        assert(l <= size());
        if (!f(VM::identity())) return l;
        if (l == size()) return size();
        std::vector<NodeInfo> ranges;
        partition_range(l, size(), ranges, 1, 0, inner_size());
        V prod = VM::identity();
        for (auto [nd, nl, nr] : ranges) {
            if (!f(VM::operation(prod, m_dat[nd]))) {
                return maxRight(f, prod, nd, nl, nr);
            }
            else {
                prod = VM::operation(prod, m_dat[nd]);
            }
        }
        return size();
    }

    template <class F>
    requires std::predicate<F, V>
    usize minLeft(usize r, F f) {
        assert(r <= size());
        if (!f(VM::identity())) return r;
        if (!r) return 0;
        std::vector<NodeInfo> ranges;
        partition_range(0, r, ranges, 1, 0, inner_size());
        V prod = VM::identity();
        for (auto [nd, nl, nr] : ranges | std::views::reverse) {
            if (!f(VM::operation(m_dat[nd], prod))) {
                return minLeft(f, prod, nd, nl, nr);
            }
            else {
                prod = VM::operation(prod, m_dat[nd]);
            }
        }
        return 0;
    }

private:

    usize m_n{}, m_sz{};

    std::vector<V> m_dat;

    std::vector<O> m_lazy;

    inline usize inner_size() const noexcept {
        return m_sz;
    }
    
    void recalc(usize nd) {
        // assert(nd < inner_size());
        m_dat[nd] = VM::operation(m_dat[nd << 1 | 0], m_dat[nd << 1 | 1]);
    }

    void propagate(usize nd) {
        // assert(nd < inner_size());
        for (usize ch : {nd << 1 | 0, nd << 1 | 1}) {
            m_dat[ch] = S::mapping(m_dat[ch], m_lazy[nd]);
            m_lazy[ch] = OM::operation(m_lazy[ch], m_lazy[nd]);
        }
        m_lazy[nd] = OM::identity();
    }

    V product(usize ql, usize qr, usize nd, usize nl, usize nr) {
        if (qr <= nl or nr <= ql) return VM::identity();
        if (ql <= nl and nr <= qr) return m_dat[nd];
        propagate(nd);
        const usize m = (nl + nr) >> 1;
        return VM::operation(
                product(ql, qr, nd << 1 | 0, nl, m),
                product(ql, qr, nd << 1 | 1, m, nr)
                );
    }

    V get(usize i, usize nd, usize nl, usize nr) {
        if (nd >= inner_size()) return m_dat[nd];
        propagate(nd);
        const usize m = (nl + nr) >> 1;
        return i < m ? get(i, nd << 1 | 0, nl, m) : get(i, nd << 1 | 1, m, nr);
    }

    void operation(usize ql, usize qr, const O& o, usize nd, usize nl, usize nr) {
        if (qr <= nl or nr <= ql) return;
        if (ql <= nl and nr <= qr) {
            m_dat[nd] = S::mapping(m_dat[nd], o);
            m_lazy[nd] = OM::operation(m_lazy[nd], o);
            return;
        }
        propagate(nd);
        const usize m = (nl + nr) >> 1;
        operation(ql, qr, o, nd << 1 | 0, nl, m);
        operation(ql, qr, o, nd << 1 | 1, m, nr);
        recalc(nd);
    }

    void operation(usize i, const O& o, usize nd, usize nl, usize nr) {
        if (nl == i and i + 1 == nr) {
            m_dat[nd] = S::mapping(m_dat[nd], o);
            // 葉頂点なので、lazyへのopは不要
            return;
        }
        propagate(nd); 
        const usize m = (nl + nr) >> 1;
        i < m ? operation(i, o, nd << 1 | 0, nl, m) : operation(i, o, nd << 1 | 1, m, nr);
        recalc(nd);
    }

    void assign(usize i, const V& v, usize nd, usize nl, usize nr) {
        if (nl == i and i + 1 == nr) {
            m_dat[nd] = v;
            return;
        }
        propagate(nd); 
        const usize m = (nl + nr) >> 1;
        i < m ? assign(i, v, nd << 1 | 0, nl, m) : assign(i, v, nd << 1 | 1, m, nr);
        recalc(nd);
    }

    void partition_range(usize ql, usize qr, std::vector<NodeInfo>& res, usize nd, usize nl, usize nr) {
        if (qr <= nl or nr <= ql) return;
        if (ql <= nl and nr <= qr) {
            res.emplace_back(nd, nl, nr);
            return;
        }
        propagate(nd);
        const usize m = (nl + nr) >> 1;
        partition_range(ql, qr, res, nd << 1 | 0, nl, m);
        partition_range(ql, qr, res, nd << 1 | 1, m, nr);
    }

    template <class F>
    requires std::predicate<F, V>
    usize maxRight(F f, const V& prod, usize nd, usize nl, usize nr) {
        if (nd >= inner_size()) return nl;
        propagate(nd);
        const usize m = (nl + nr) >> 1, lch = nd << 1 | 0, rch = nd << 1 | 1;
        return f(VM::operation(prod, m_dat[lch])) ? 
            maxRight(f, VM::operation(prod, m_dat[lch]), rch, m, nr) : maxRight(f, prod, lch, nl, m);
    }

    template <class F>
    requires std::predicate<F, V>
    usize minLeft(F f, const V& prod, usize nd, usize nl, usize nr) {
        if (nd >= inner_size()) return nr;
        propagate(nd);
        const usize m = (nl + nr) >> 1, lch = nd << 1 | 0, rch = nd << 1 | 1;
        return f(VM::operation(m_dat[rch], prod)) ? 
            minLeft(f, VM::operation(m_dat[rch], prod), lch, nl, m) : minLeft(f, prod, rch, m, nr);
    }
};

} // namespace zawa
#line 7 "Src/Utility/AreaOfUnionOfRectangles.hpp"

#line 10 "Src/Utility/AreaOfUnionOfRectangles.hpp"
#include <type_traits>
#line 12 "Src/Utility/AreaOfUnionOfRectangles.hpp"

namespace zawa {

template <class T>
class Rectangle {
public:

    Rectangle() = default;
     
    Rectangle(T l, T d, T r, T u)
        : l_{l}, d_{d}, r_{r}, u_{u} {
        assert(l <= r);
        assert(d <= u);
    }

    Rectangle(const std::pair<T, T>& ld, const std::pair<T, T>& ru)
        : l_{ld.first}, d_{ld.second}, r_{ru.first}, u_{ru.second} {}

    Rectangle(const std::pair<T, T>& ld, T w, T h)
        : l_{ld.first}, d_{ld.second}, r_{l_ + w}, u_{d_ + h} {}

    inline T left() const noexcept {
        return l_;
    }

    inline T right() const noexcept {
        return r_;
    }

    inline T down() const noexcept {
        return d_;
    }

    inline T up() const noexcept {
        return u_;
    }

private:
    // 左下、右上
    T l_{}, d_{}, r_{}, u_{};
};

namespace internal {

struct AreaOfUnionOfRectanglesStructure {
    using ValueMonoid = MinCountMonoid<i32, u64>;
    using OperatorMonoid = AdditionMonoid<i32>;
    static ValueMonoid::Element mapping(const ValueMonoid::Element& V, const OperatorMonoid::Element& R) {
        return ValueMonoid::Element{ V.first + R, V.second };
    }
    static ValueMonoid::Element generate(u64 v) {
        return ValueMonoid::Element{ 0, v };
    }
};

} // namespace internal

template <class T, class InputIterator>
u64 AreaOfUnionOfRectangles(InputIterator first, InputIterator last) {
    static_assert(std::is_same_v<std::remove_reference_t<decltype(*first)>, Rectangle<T>>, "*iterator 's type must be T");
    usize n{static_cast<usize>(std::distance(first, last))};
    if (n == 0u) return u64{};
    std::vector<T> xs, ys;
    xs.reserve(2u * n);
    ys.reserve(2u * n);
    for (auto it{first} ; it != last ; it++) {
       xs.push_back(it->left()); 
       xs.push_back(it->right());
       ys.push_back(it->down()); 
       ys.push_back(it->up());
    }
    std::sort(ys.begin(), ys.end());
    ys.erase(std::unique(ys.begin(), ys.end()), ys.end());
    std::sort(xs.begin(), xs.end());
    xs.erase(std::unique(xs.begin(), xs.end()), xs.end());
    std::vector<std::vector<std::pair<std::pair<u32, u32>, bool>>> event(xs.size());
    for (auto it{first} ; it != last ; it++) {
        u32 l{static_cast<u32>(std::distance(ys.begin(), std::lower_bound(ys.begin(), ys.end(), it->down())))};
        u32 r{static_cast<u32>(std::distance(ys.begin(), std::lower_bound(ys.begin(), ys.end(), it->up())))};
        event[static_cast<u32>(std::distance(xs.begin(), std::lower_bound(xs.begin(), xs.end(), it->left())))]
            .emplace_back(std::pair<u32, u32>{ l, r }, true);
        event[static_cast<u32>(std::distance(xs.begin(), std::lower_bound(xs.begin(), xs.end(), it->right())))]
            .emplace_back(std::pair<u32, u32>{ l, r }, false);
    } 
    using S = internal::AreaOfUnionOfRectanglesStructure;
    std::vector<S::ValueMonoid::Element> init(ys.size() - 1);
    for (usize i{} ; i + 1 < ys.size() ; i++) {
        init[i] = S::generate(static_cast<u64>(ys[i + 1] - ys[i]));
    } 
    u64 all{static_cast<u64>(ys.back() - ys.front())};
    LazySegmentTree<S> seg{init};
    u64 res{};
    for (u32 x{} ; x < xs.size() ; x++) {
        if (x >= 1u) {
            auto [min, count]{seg.product(0, init.size())};
            res += (all - (min == 0 ? count : u64{})) * (xs[x] - xs[x - 1]);
        }
        for (const auto& [lr, v] : event[x]) {
            seg.operation(lr.first, lr.second, (v ? +1 : -1));
        }
    }
    return res;
}

} // namespace zawa

Back to top page