proconlib

This documentation is automatically generated by competitive-verifier/competitive-verifier

View the Project on GitHub anqooqie/proconlib

:heavy_check_mark: tests/persistent_lazy_segtree/binary_search.test.cpp

Depends on

Code

// competitive-verifier: STANDALONE

#include <iostream>
#include <random>
#include <tuple>
#include <utility>
#include <vector>
#include "tools/assert_that.hpp"
#include "tools/inversion_number.hpp"
#include "tools/persistent_lazy_segtree.hpp"

struct SM {
  using T = std::tuple<int, int, int>;
  static T op(const T& x, const T& y) {
    return {std::get<0>(x) + std::get<0>(y), std::get<1>(x) + std::get<1>(y), std::get<2>(x) + std::get<2>(y) + std::get<1>(x) * std::get<0>(y)};
  }
  static T e() {
    return {0, 0, 0};
  }
};
using S = typename SM::T;

struct FM {
  using T = bool;
  static T op(const T f, const T g) {
    return f ^ g;
  }
  static T e() {
    return false;
  }
};
using F = typename FM::T;

S mapping(const F f, const S& e) {
  return f ? std::make_tuple(std::get<1>(e), std::get<0>(e), std::get<0>(e) * std::get<1>(e) - std::get<2>(e)) : e;
}

int main() {
  std::cin.tie(nullptr);
  std::ios_base::sync_with_stdio(false);

  std::random_device seed_gen;
  std::mt19937 engine(seed_gen());

  std::uniform_int_distribution<int> a_dist(0, 1);
  std::uniform_int_distribution<int> t_dist(0, 2);
  for (int N = 0; N < 50; ++N) {
    std::vector<int> a(N);
    for (auto& a_i : a) a_i = a_dist(engine);

    tools::persistent_lazy_segtree<SM, FM, mapping>::buffer buffer;
    std::vector<tools::persistent_lazy_segtree<SM, FM, mapping>> seg;
    seg.emplace_back(buffer, [&]() {
      std::vector<S> v(N);
      for (int i = 0; i < N; ++i) {
        v[i] = a[i] ? std::make_tuple(0, 1, 0) : std::make_tuple(1, 0, 0);
      }
      return v;
    }());
    std::vector<std::tuple<int, int, int, int, int>> queries;

    std::vector<std::pair<int, int>> lr;
    for (int l = 0; l <= N; ++l) {
      for (int r = l; r <= N; ++r) {
        lr.emplace_back(l, r);
      }
    }

    std::uniform_int_distribution<int> p_dist(0, N);
    std::uniform_int_distribution<int> lr_dist(0, (N + 1) * (N + 2) / 2 - 1);
    for (int q = 0; q < (N + 1) * (N + 2) * 3; ++q) {
      const auto t = t_dist(engine);
      if (t == 0) {
        const auto [l, r] = lr[lr_dist(engine)];
        for (int i = l; i < r; ++i) a[i] ^= 1;
        seg.push_back(seg.back().apply(l, r, true));
      } else if (t == 1) {
        const auto l = p_dist(engine);
        const auto x = std::uniform_int_distribution<int>(0, (N - l) * (N - l - 1) / 2)(engine);
        auto ok = l;
        auto ng = N + 1;
        while (ng - ok > 1) {
          const auto mid = (ok + ng) / 2;
          if (tools::inversion_number(std::ranges::subrange(a.begin() + l, a.begin() + mid)) <= x) {
            ok = mid;
          } else {
            ng = mid;
          }
        }
        queries.emplace_back(seg.size() - 1, 1, l, x, ok);
      } else {
        const auto r = p_dist(engine);
        const auto x = std::uniform_int_distribution<int>(0, r * (r - 1) / 2)(engine);
        auto ok = r;
        auto ng = -1;
        while (ok - ng > 1) {
          const auto mid = (ok + ng) / 2;
          if (tools::inversion_number(std::ranges::subrange(a.begin() + mid, a.begin() + r)) <= x) {
            ok = mid;
          } else {
            ng = mid;
          }
        }
        queries.emplace_back(seg.size() - 1, 2, r, x, ok);
      }
    }

    for (const auto& [q, t, b, x, expected] : queries) {
      if (t == 1) {
        assert_that(seg[q].max_right(b, [&](const S& e) { return std::get<2>(e) <= x; }) == expected);
      } else {
        assert_that(seg[q].min_left(b, [&](const S& e) { return std::get<2>(e) <= x; }) == expected);
      }
    }
  }

  return 0;
}

#line 1 "tests/persistent_lazy_segtree/binary_search.test.cpp"
// competitive-verifier: STANDALONE

#include <iostream>
#include <random>
#include <tuple>
#include <utility>
#include <vector>
#line 1 "tools/assert_that.hpp"



#line 5 "tools/assert_that.hpp"
#include <cstdlib>

#define assert_that_impl(cond, file, line, func) do {\
  if (!cond) {\
    ::std::cerr << file << ':' << line << ": " << func << ": Assertion `" << #cond << "' failed." << '\n';\
    ::std::exit(EXIT_FAILURE);\
  }\
} while (false)
#define assert_that(...) assert_that_impl((__VA_ARGS__), __FILE__, __LINE__, __func__)


#line 1 "tools/inversion_number.hpp"



#include <algorithm>
#include <iterator>
#include <ranges>
#line 1 "lib/ac-library/atcoder/fenwicktree.hpp"



#include <cassert>
#line 6 "lib/ac-library/atcoder/fenwicktree.hpp"

#line 1 "lib/ac-library/atcoder/internal_type_traits.hpp"



#line 5 "lib/ac-library/atcoder/internal_type_traits.hpp"
#include <numeric>
#include <type_traits>

namespace atcoder {

namespace internal {

#ifndef _MSC_VER
template <class T>
using is_signed_int128 =
    typename std::conditional<std::is_same<T, __int128_t>::value ||
                                  std::is_same<T, __int128>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using is_unsigned_int128 =
    typename std::conditional<std::is_same<T, __uint128_t>::value ||
                                  std::is_same<T, unsigned __int128>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using make_unsigned_int128 =
    typename std::conditional<std::is_same<T, __int128_t>::value,
                              __uint128_t,
                              unsigned __int128>;

template <class T>
using is_integral = typename std::conditional<std::is_integral<T>::value ||
                                                  is_signed_int128<T>::value ||
                                                  is_unsigned_int128<T>::value,
                                              std::true_type,
                                              std::false_type>::type;

template <class T>
using is_signed_int = typename std::conditional<(is_integral<T>::value &&
                                                 std::is_signed<T>::value) ||
                                                    is_signed_int128<T>::value,
                                                std::true_type,
                                                std::false_type>::type;

template <class T>
using is_unsigned_int =
    typename std::conditional<(is_integral<T>::value &&
                               std::is_unsigned<T>::value) ||
                                  is_unsigned_int128<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using to_unsigned = typename std::conditional<
    is_signed_int128<T>::value,
    make_unsigned_int128<T>,
    typename std::conditional<std::is_signed<T>::value,
                              std::make_unsigned<T>,
                              std::common_type<T>>::type>::type;

#else

template <class T> using is_integral = typename std::is_integral<T>;

template <class T>
using is_signed_int =
    typename std::conditional<is_integral<T>::value && std::is_signed<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using is_unsigned_int =
    typename std::conditional<is_integral<T>::value &&
                                  std::is_unsigned<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using to_unsigned = typename std::conditional<is_signed_int<T>::value,
                                              std::make_unsigned<T>,
                                              std::common_type<T>>::type;

#endif

template <class T>
using is_signed_int_t = std::enable_if_t<is_signed_int<T>::value>;

template <class T>
using is_unsigned_int_t = std::enable_if_t<is_unsigned_int<T>::value>;

template <class T> using to_unsigned_t = typename to_unsigned<T>::type;

}  // namespace internal

}  // namespace atcoder


#line 8 "lib/ac-library/atcoder/fenwicktree.hpp"

namespace atcoder {

// Reference: https://en.wikipedia.org/wiki/Fenwick_tree
template <class T> struct fenwick_tree {
    using U = internal::to_unsigned_t<T>;

  public:
    fenwick_tree() : _n(0) {}
    explicit fenwick_tree(int n) : _n(n), data(n) {}

    void add(int p, T x) {
        assert(0 <= p && p < _n);
        p++;
        while (p <= _n) {
            data[p - 1] += U(x);
            p += p & -p;
        }
    }

    T sum(int l, int r) {
        assert(0 <= l && l <= r && r <= _n);
        return sum(r) - sum(l);
    }

  private:
    int _n;
    std::vector<U> data;

    U sum(int r) {
        U s = 0;
        while (r > 0) {
            s += data[r - 1];
            r -= r & -r;
        }
        return s;
    }
};

}  // namespace atcoder


#line 1 "tools/compress.hpp"



#line 1 "tools/lower_bound.hpp"



#line 6 "tools/lower_bound.hpp"

namespace tools {

  template <class ForwardIterator, class T>
  auto lower_bound(ForwardIterator first, ForwardIterator last, const T& value) {
    return ::std::distance(first, ::std::lower_bound(first, last, value));
  }

  template <class ForwardIterator, class T, class Compare>
  auto lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp) {
    return ::std::distance(first, ::std::lower_bound(first, last, value, comp));
  }
}


#line 8 "tools/compress.hpp"

namespace tools {
  template <::std::ranges::range R, typename OutputIterator>
  void compress(R&& a, OutputIterator result) {
    using T = typename ::std::ranges::range_value_t<R>;
    if constexpr (::std::ranges::forward_range<R>) {
      ::std::vector<T> sorted(::std::ranges::begin(a), ::std::ranges::end(a));
      ::std::ranges::sort(sorted);
      sorted.erase(::std::unique(sorted.begin(), sorted.end()), sorted.end());
      for (auto it = ::std::ranges::begin(a); it != ::std::ranges::end(a); ++it, ++result) {
        *result = ::tools::lower_bound(sorted.begin(), sorted.end(), *it);
      }
    } else {
      ::tools::compress(::std::vector<T>(::std::ranges::begin(a), ::std::ranges::end(a)), result);
    }
  }
}


#line 10 "tools/inversion_number.hpp"

namespace tools {

  template <::std::ranges::range R>
  long long inversion_number(R&& a) {
    ::std::vector<int> compressed;
    ::tools::compress(a, ::std::back_inserter(compressed));

    if (compressed.empty()) return 0;

    const auto max = *::std::ranges::max_element(compressed);
    ::atcoder::fenwick_tree<int> fw(max + 1);
    long long res = 0;
    for (const auto x : compressed) {
      res += fw.sum(x + 1, max + 1);
      fw.add(x, 1);
    }

    return res;
  }
}


#line 1 "tools/persistent_lazy_segtree.hpp"



#line 5 "tools/persistent_lazy_segtree.hpp"
#include <array>
#line 7 "tools/persistent_lazy_segtree.hpp"
#include <functional>
#line 1 "tools/ceil_log2.hpp"



#line 1 "tools/bit_width.hpp"



#include <bit>
#line 1 "tools/is_integral.hpp"



#line 5 "tools/is_integral.hpp"

namespace tools {
  template <typename T>
  struct is_integral : ::std::is_integral<T> {};

  template <typename T>
  inline constexpr bool is_integral_v = ::tools::is_integral<T>::value;
}


#line 1 "tools/is_signed.hpp"



#line 5 "tools/is_signed.hpp"

namespace tools {
  template <typename T>
  struct is_signed : ::std::is_signed<T> {};

  template <typename T>
  inline constexpr bool is_signed_v = ::tools::is_signed<T>::value;
}


#line 1 "tools/make_unsigned.hpp"



#line 5 "tools/make_unsigned.hpp"

namespace tools {
  template <typename T>
  struct make_unsigned : ::std::make_unsigned<T> {};

  template <typename T>
  using make_unsigned_t = typename ::tools::make_unsigned<T>::type;
}


#line 10 "tools/bit_width.hpp"

namespace tools {
  template <typename T>
  constexpr int bit_width(T) noexcept;

  template <typename T>
  constexpr int bit_width(const T x) noexcept {
    static_assert(::tools::is_integral_v<T> && !::std::is_same_v<::std::remove_cv_t<T>, bool>);
    if constexpr (::tools::is_signed_v<T>) {
      assert(x >= 0);
      return ::tools::bit_width<::tools::make_unsigned_t<T>>(x);
    } else {
      return ::std::bit_width(x);
    }
  }
}


#line 6 "tools/ceil_log2.hpp"

namespace tools {
  template <typename T>
  constexpr T ceil_log2(T x) noexcept {
    assert(x > 0);
    return ::tools::bit_width(x - 1);
  }
}


#line 1 "tools/fix.hpp"



#line 6 "tools/fix.hpp"

namespace tools {
  template <typename F>
  struct fix : F {
    template <typename G>
    fix(G&& g) : F({::std::forward<G>(g)}) {
    }

    template <typename... Args>
    decltype(auto) operator()(Args&&... args) const {
      return F::operator()(*this, ::std::forward<Args>(args)...);
    }
  };

  template <typename F>
  fix(F&&) -> fix<::std::decay_t<F>>;
}


#line 15 "tools/persistent_lazy_segtree.hpp"

namespace tools {
  template <typename SM, typename FM, auto mapping>
  class persistent_lazy_segtree {
    using S = typename SM::T;
    using F = typename FM::T;
    static_assert(
      ::std::is_convertible_v<decltype(mapping), ::std::function<S(F, S)>>,
      "mapping must work as S(F, S)");

    struct node {
      S data;
      F lazy;
      ::std::array<int, 2> children;
    };

  public:
    class buffer {
      ::std::vector<::tools::persistent_lazy_segtree<SM, FM, mapping>::node> m_nodes;
      long long m_offset;
      long long m_size;
      int m_height;

    public:
      friend ::tools::persistent_lazy_segtree<SM, FM, mapping>;
    };

  private:
    ::tools::persistent_lazy_segtree<SM, FM, mapping>::buffer *m_buffer;
    int m_root;

    long long capacity() const {
      return 1LL << this->m_buffer->m_height;
    }

  public:
    persistent_lazy_segtree() = default;
    persistent_lazy_segtree(::tools::persistent_lazy_segtree<SM, FM, mapping>::buffer& buffer, const long long l_star, const long long r_star) :
      persistent_lazy_segtree(buffer, l_star, r_star, SM::e()) {
    }
    persistent_lazy_segtree(::tools::persistent_lazy_segtree<SM, FM, mapping>::buffer& buffer, const long long l_star, const long long r_star, const S& x) : m_buffer(&buffer) {
      assert(buffer.m_nodes.empty());
      assert(l_star <= r_star);
      buffer.m_offset = l_star;
      buffer.m_size = r_star - l_star;
      buffer.m_height = ::tools::ceil_log2(::std::max(1LL, r_star - l_star));
      buffer.m_nodes.push_back({x, FM::e(), {-1, -1}});
      for (int k = 1; k <= buffer.m_height; ++k) {
        buffer.m_nodes.push_back({SM::op(buffer.m_nodes.back().data, buffer.m_nodes.back().data), FM::e(), {k - 1, k - 1}});
      }
      this->m_root = buffer.m_height;
    }
    template <::std::ranges::range R>
    persistent_lazy_segtree(::tools::persistent_lazy_segtree<SM, FM, mapping>::buffer& buffer, R&& v) : m_buffer(&buffer) {
      assert(buffer.m_nodes.empty());
      for (auto&& x : v) {
        buffer.m_nodes.push_back({x, FM::e(), {-1, -1}});
      }
      buffer.m_offset = 0;
      buffer.m_size = buffer.m_nodes.size();
      buffer.m_height = ::tools::ceil_log2(::std::max(1LL, buffer.m_size));
      buffer.m_nodes.push_back({SM::e(), FM::e(), {-1, -1}});
      for (int h = 1; h <= buffer.m_height; ++h) {
        buffer.m_nodes.push_back({SM::e(), FM::e(), {static_cast<int>(buffer.m_nodes.size()) - 1, static_cast<int>(buffer.m_nodes.size()) - 1}});
      }
      this->m_root = ::tools::fix([&](auto&& dfs, const int h, const long long kl, const long long kr) -> int {
        assert(kl < kr);
        if (buffer.m_size <= kl) return buffer.m_size + h;
        if (h == 0) return kl;
        const auto km = ::std::midpoint(kl, kr);
        const auto left_child = dfs(h - 1, kl, km);
        const auto right_child = dfs(h - 1, km, kr);
        buffer.m_nodes.push_back({SM::op(buffer.m_nodes[left_child].data, buffer.m_nodes[right_child].data), FM::e(), {left_child, right_child}});
        return buffer.m_nodes.size() - 1;
      })(buffer.m_height, 0, this->capacity());
    }

    long long lower_bound() const {
      return this->m_buffer->m_offset;
    }
    long long upper_bound() const {
      return this->m_buffer->m_offset + this->m_buffer->m_size;
    }
    ::tools::persistent_lazy_segtree<SM, FM, mapping> set(long long p, const S& x) const {
      assert(this->lower_bound() <= p && p < this->upper_bound());
      auto& buffer = *this->m_buffer;
      p -= buffer.m_offset;

      auto res = *this;
      res.m_root = ::tools::fix([&](auto&& dfs, const int k, const long long kl, const long long kr, const F& lz) -> int {
        assert(kl < kr);
        if (p <= kl && kr <= p + 1) {
          buffer.m_nodes.push_back({x, FM::e(), buffer.m_nodes[k].children});
          return buffer.m_nodes.size() - 1;
        }
        if (kr <= p || p + 1 <= kl) {
          if (lz == FM::e()) return k;
          buffer.m_nodes.push_back({mapping(lz, buffer.m_nodes[k].data), FM::op(lz, buffer.m_nodes[k].lazy), buffer.m_nodes[k].children});
          return buffer.m_nodes.size() - 1;
        }
        const auto km = ::std::midpoint(kl, kr);
        const F next_lz = FM::op(lz, buffer.m_nodes[k].lazy);
        const auto left_child = dfs(buffer.m_nodes[k].children[0], kl, km, next_lz);
        const auto right_child = dfs(buffer.m_nodes[k].children[1], km, kr, next_lz);
        buffer.m_nodes.push_back({SM::op(buffer.m_nodes[left_child].data, buffer.m_nodes[right_child].data), FM::e(), {left_child, right_child}});
        return buffer.m_nodes.size() - 1;
      })(res.m_root, 0, res.capacity(), FM::e());
      return res;
    }
    S get(const long long p) const {
      return this->prod(p, p + 1);
    }
    S prod(long long l, long long r) const {
      assert(this->lower_bound() <= l && l <= r && r <= this->upper_bound());
      if (l == r) return SM::e();
      auto& buffer = *this->m_buffer;
      l -= buffer.m_offset;
      r -= buffer.m_offset;

      return ::tools::fix([&](auto&& dfs, const int k, const long long kl, const long long kr, const F& lz) -> S {
        assert(kl < kr);
        if (l <= kl && kr <= r) return mapping(lz, buffer.m_nodes[k].data);
        const auto km = ::std::midpoint(kl, kr);
        const F next_lz = FM::op(lz, buffer.m_nodes[k].lazy);
        S res = SM::e();
        if (l < km) res = SM::op(res, dfs(buffer.m_nodes[k].children[0], kl, km, next_lz));
        if (km < r) res = SM::op(res, dfs(buffer.m_nodes[k].children[1], km, kr, next_lz));
        return res;
      })(this->m_root, 0, this->capacity(), FM::e());
    }
    S all_prod() const {
      return this->m_buffer->m_nodes[this->m_root].data;
    }
    ::tools::persistent_lazy_segtree<SM, FM, mapping> apply(const long long p, const F& f) const {
      return this->apply(p, p + 1, f);
    }
    ::tools::persistent_lazy_segtree<SM, FM, mapping> apply(long long l, long long r, const F& f) const {
      assert(this->lower_bound() <= l && l <= r && r <= this->upper_bound());
      if (l == r) return *this;
      auto& buffer = *this->m_buffer;
      l -= buffer.m_offset;
      r -= buffer.m_offset;

      auto res = *this;
      res.m_root = ::tools::fix([&](auto&& dfs, const int k, const long long kl, const long long kr, const F& lz) -> int {
        assert(kl < kr);
        if (l <= kl && kr <= r) {
          const F modified_lz = FM::op(f, lz);
          buffer.m_nodes.push_back({mapping(modified_lz, buffer.m_nodes[k].data), FM::op(modified_lz, buffer.m_nodes[k].lazy), buffer.m_nodes[k].children});
          return buffer.m_nodes.size() - 1;
        }
        if (kr <= l || r <= kl) {
          if (lz == FM::e()) return k;
          buffer.m_nodes.push_back({mapping(lz, buffer.m_nodes[k].data), FM::op(lz, buffer.m_nodes[k].lazy), buffer.m_nodes[k].children});
          return buffer.m_nodes.size() - 1;
        }
        const auto km = ::std::midpoint(kl, kr);
        const F next_lz = FM::op(lz, buffer.m_nodes[k].lazy);
        const auto left_child = dfs(buffer.m_nodes[k].children[0], kl, km, next_lz);
        const auto right_child = dfs(buffer.m_nodes[k].children[1], km, kr, next_lz);
        buffer.m_nodes.push_back({SM::op(buffer.m_nodes[left_child].data, buffer.m_nodes[right_child].data), FM::e(), {left_child, right_child}});
        return buffer.m_nodes.size() - 1;
      })(res.m_root, 0, res.capacity(), FM::e());
      return res;
    }
    ::tools::persistent_lazy_segtree<SM, FM, mapping> rollback(const ::tools::persistent_lazy_segtree<SM, FM, mapping>& s, long long l, long long r) const {
      assert(this->m_buffer == s.m_buffer);
      assert(this->lower_bound() <= l && l <= r && r <= this->upper_bound());
      if (l == r) return *this;
      if (l == this->lower_bound() && r == this->upper_bound()) return s;
      auto& buffer = *this->m_buffer;
      l -= buffer.m_offset;
      r -= buffer.m_offset;

      auto res = *this;
      res.m_root = ::tools::fix([&](auto&& dfs, const int k1, const int k2, const long long kl, const long long kr, const F& lz1, const F& lz2) -> int {
        assert(kl < kr);
        if (l <= kl && kr <= r) {
          if (lz2 == FM::e()) return k2;
          buffer.m_nodes.push_back({mapping(lz2, buffer.m_nodes[k2].data), FM::op(lz2, buffer.m_nodes[k2].lazy), buffer.m_nodes[k2].children});
          return buffer.m_nodes.size() - 1;
        }
        if (kr <= l || r <= kl) {
          if (lz1 == FM::e()) return k1;
          buffer.m_nodes.push_back({mapping(lz1, buffer.m_nodes[k1].data), FM::op(lz1, buffer.m_nodes[k1].lazy), buffer.m_nodes[k1].children});
          return buffer.m_nodes.size() - 1;
        }
        const auto km = ::std::midpoint(kl, kr);
        const F next_lz1 = FM::op(lz1, buffer.m_nodes[k1].lazy);
        const F next_lz2 = FM::op(lz2, buffer.m_nodes[k2].lazy);
        const auto left_child = dfs(buffer.m_nodes[k1].children[0], buffer.m_nodes[k2].children[0], kl, km, next_lz1, next_lz2);
        const auto right_child = dfs(buffer.m_nodes[k1].children[1], buffer.m_nodes[k2].children[1], km, kr, next_lz1, next_lz2);
        buffer.m_nodes.push_back({SM::op(buffer.m_nodes[left_child].data, buffer.m_nodes[right_child].data), FM::e(), {left_child, right_child}});
        return buffer.m_nodes.size() - 1;
      })(res.m_root, s.m_root, 0, res.capacity(), FM::e(), FM::e());
      return res;
    }
    template <typename G>
    long long max_right(long long l, const G& g) const {
      assert(this->lower_bound() <= l && l <= this->upper_bound());
      assert(g(SM::e()));
      if (l == this->upper_bound()) return l;
      auto& buffer = *this->m_buffer;
      l -= buffer.m_offset;

      return buffer.m_offset + ::std::min(::tools::fix([&](auto&& dfs, const S& c, const int k, const long long kl, const long long kr, const F& lz) -> ::std::pair<S, long long> {
        assert(kl < kr);
        if (kl < l) {
          assert(kl < l && l < kr);
          const auto km = ::std::midpoint(kl, kr);
          const F next_lz = FM::op(lz, buffer.m_nodes[k].lazy);
          if (l < km) {
            const auto [hc, hr] = dfs(c, buffer.m_nodes[k].children[0], kl, km, next_lz);
            assert(l <= hr && hr <= km);
            if (hr < km) return {hc, hr};
            return dfs(hc, buffer.m_nodes[k].children[1], km, kr, next_lz);
          } else {
            return dfs(c, buffer.m_nodes[k].children[1], km, kr, next_lz);
          }
        } else {
          if (const auto wc = SM::op(c, mapping(lz, buffer.m_nodes[k].data)); g(wc)) return {wc, kr};
          if (kr - kl == 1) return {c, kl};
          const auto km = ::std::midpoint(kl, kr);
          const F next_lz = FM::op(lz, buffer.m_nodes[k].lazy);
          const auto [hc, hr] = dfs(c, buffer.m_nodes[k].children[0], kl, km, next_lz);
          assert(l <= hr && hr <= km);
          if (hr < km) return {hc, hr};
          return dfs(hc, buffer.m_nodes[k].children[1], km, kr, next_lz);
        }
      })(SM::e(), this->m_root, 0, this->capacity(), FM::e()).second, buffer.m_size);
    }
    template <typename G>
    long long min_left(long long r, const G& g) const {
      assert(this->lower_bound() <= r && r <= this->upper_bound());
      assert(g(SM::e()));
      if (r == this->lower_bound()) return r;
      auto& buffer = *this->m_buffer;
      r -= buffer.m_offset;

      return buffer.m_offset + ::tools::fix([&](auto&& dfs, const S& c, const int k, const long long kl, const long long kr, const F& lz) -> ::std::pair<S, long long> {
        assert(kl < kr);
        if (r < kr) {
          assert(kl < r && r < kr);
          const auto km = ::std::midpoint(kl, kr);
          const F next_lz = FM::op(lz, buffer.m_nodes[k].lazy);
          if (km < r) {
            const auto [hc, hl] = dfs(c, buffer.m_nodes[k].children[1], km, kr, next_lz);
            assert(km <= hl && hl <= r);
            if (km < hl) return {hc, hl};
            return dfs(hc, buffer.m_nodes[k].children[0], kl, km, next_lz);
          } else {
            return dfs(c, buffer.m_nodes[k].children[0], kl, km, next_lz);
          }
        } else {
          if (const auto wc = SM::op(mapping(lz, buffer.m_nodes[k].data), c); g(wc)) return {wc, kl};
          if (kr - kl == 1) return {c, kr};
          const auto km = ::std::midpoint(kl, kr);
          const F next_lz = FM::op(lz, buffer.m_nodes[k].lazy);
          const auto [hc, hl] = dfs(c, buffer.m_nodes[k].children[1], km, kr, next_lz);
          assert(km <= hl && hl <= r);
          if (km < hl) return {hc, hl};
          return dfs(hc, buffer.m_nodes[k].children[0], kl, km, next_lz);
        }
      })(SM::e(), this->m_root, 0, this->capacity(), FM::e()).second;
    }
  };
}


#line 11 "tests/persistent_lazy_segtree/binary_search.test.cpp"

struct SM {
  using T = std::tuple<int, int, int>;
  static T op(const T& x, const T& y) {
    return {std::get<0>(x) + std::get<0>(y), std::get<1>(x) + std::get<1>(y), std::get<2>(x) + std::get<2>(y) + std::get<1>(x) * std::get<0>(y)};
  }
  static T e() {
    return {0, 0, 0};
  }
};
using S = typename SM::T;

struct FM {
  using T = bool;
  static T op(const T f, const T g) {
    return f ^ g;
  }
  static T e() {
    return false;
  }
};
using F = typename FM::T;

S mapping(const F f, const S& e) {
  return f ? std::make_tuple(std::get<1>(e), std::get<0>(e), std::get<0>(e) * std::get<1>(e) - std::get<2>(e)) : e;
}

int main() {
  std::cin.tie(nullptr);
  std::ios_base::sync_with_stdio(false);

  std::random_device seed_gen;
  std::mt19937 engine(seed_gen());

  std::uniform_int_distribution<int> a_dist(0, 1);
  std::uniform_int_distribution<int> t_dist(0, 2);
  for (int N = 0; N < 50; ++N) {
    std::vector<int> a(N);
    for (auto& a_i : a) a_i = a_dist(engine);

    tools::persistent_lazy_segtree<SM, FM, mapping>::buffer buffer;
    std::vector<tools::persistent_lazy_segtree<SM, FM, mapping>> seg;
    seg.emplace_back(buffer, [&]() {
      std::vector<S> v(N);
      for (int i = 0; i < N; ++i) {
        v[i] = a[i] ? std::make_tuple(0, 1, 0) : std::make_tuple(1, 0, 0);
      }
      return v;
    }());
    std::vector<std::tuple<int, int, int, int, int>> queries;

    std::vector<std::pair<int, int>> lr;
    for (int l = 0; l <= N; ++l) {
      for (int r = l; r <= N; ++r) {
        lr.emplace_back(l, r);
      }
    }

    std::uniform_int_distribution<int> p_dist(0, N);
    std::uniform_int_distribution<int> lr_dist(0, (N + 1) * (N + 2) / 2 - 1);
    for (int q = 0; q < (N + 1) * (N + 2) * 3; ++q) {
      const auto t = t_dist(engine);
      if (t == 0) {
        const auto [l, r] = lr[lr_dist(engine)];
        for (int i = l; i < r; ++i) a[i] ^= 1;
        seg.push_back(seg.back().apply(l, r, true));
      } else if (t == 1) {
        const auto l = p_dist(engine);
        const auto x = std::uniform_int_distribution<int>(0, (N - l) * (N - l - 1) / 2)(engine);
        auto ok = l;
        auto ng = N + 1;
        while (ng - ok > 1) {
          const auto mid = (ok + ng) / 2;
          if (tools::inversion_number(std::ranges::subrange(a.begin() + l, a.begin() + mid)) <= x) {
            ok = mid;
          } else {
            ng = mid;
          }
        }
        queries.emplace_back(seg.size() - 1, 1, l, x, ok);
      } else {
        const auto r = p_dist(engine);
        const auto x = std::uniform_int_distribution<int>(0, r * (r - 1) / 2)(engine);
        auto ok = r;
        auto ng = -1;
        while (ok - ng > 1) {
          const auto mid = (ok + ng) / 2;
          if (tools::inversion_number(std::ranges::subrange(a.begin() + mid, a.begin() + r)) <= x) {
            ok = mid;
          } else {
            ng = mid;
          }
        }
        queries.emplace_back(seg.size() - 1, 2, r, x, ok);
      }
    }

    for (const auto& [q, t, b, x, expected] : queries) {
      if (t == 1) {
        assert_that(seg[q].max_right(b, [&](const S& e) { return std::get<2>(e) <= x; }) == expected);
      } else {
        assert_that(seg[q].min_left(b, [&](const S& e) { return std::get<2>(e) <= x; }) == expected);
      }
    }
  }

  return 0;
}
Back to top page