This documentation is automatically generated by online-judge-tools/verification-helper
View the Project on GitHub suisen-cp/cp-library-cpp
#define PROBLEM "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_2_I" #include <iostream> #include "library/datastructure/segment_tree/lazy_segment_tree.hpp" using suisen::LazySegmentTree; using S = std::pair<long long, int>; using F = long long; S op(S p1, S p2) { auto [s1, l1] = p1; auto [s2, l2] = p2; return { s1 + s2, l1 + l2 }; } S e() { return { 0LL, 0 }; } S mapping(F f, S p) { int l = p.second; return f == std::numeric_limits<long long>::min() ? p : std::make_pair(f * l, l); } F composition(F f, F g) { return f == std::numeric_limits<long long>::min() ? g : f; } F id() { return std::numeric_limits<long long>::min(); } int main() { std::ios::sync_with_stdio(false); std::cin.tie(nullptr); int n, q; std::cin >> n >> q; LazySegmentTree<S, op, e, F, mapping, composition, id> seg(std::vector<S>(n, { 0LL, 1 })); for (int i = 0; i < q; ++i) { int t, l, r; std::cin >> t >> l >> r; ++r; if (t == 0) { long long x; std::cin >> x; seg.apply(l, r, x); } else { std::cout << seg(l, r).first << '\n'; } } return 0; }
#line 1 "test/src/datastructure/segment_tree/lazy_segment_tree/DSL_2_I.test.cpp" #define PROBLEM "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_2_I" #include <iostream> #line 1 "library/datastructure/segment_tree/lazy_segment_tree.hpp" #include <cassert> #include <vector> #line 1 "library/util/update_proxy_object.hpp" #line 1 "library/type_traits/type_traits.hpp" #include <limits> #line 6 "library/type_traits/type_traits.hpp" #include <type_traits> namespace suisen { template <typename ...Constraints> using constraints_t = std::enable_if_t<std::conjunction_v<Constraints...>, std::nullptr_t>; template <typename T, typename = std::nullptr_t> struct bitnum { static constexpr int value = 0; }; template <typename T> struct bitnum<T, constraints_t<std::is_integral<T>>> { static constexpr int value = std::numeric_limits<std::make_unsigned_t<T>>::digits; }; template <typename T> static constexpr int bitnum_v = bitnum<T>::value; template <typename T, size_t n> struct is_nbit { static constexpr bool value = bitnum_v<T> == n; }; template <typename T, size_t n> static constexpr bool is_nbit_v = is_nbit<T, n>::value; template <typename T, typename = std::nullptr_t> struct safely_multipliable { using type = T; }; template <typename T> struct safely_multipliable<T, constraints_t<std::is_signed<T>, is_nbit<T, 32>>> { using type = long long; }; template <typename T> struct safely_multipliable<T, constraints_t<std::is_signed<T>, is_nbit<T, 64>>> { using type = __int128_t; }; template <typename T> struct safely_multipliable<T, constraints_t<std::is_unsigned<T>, is_nbit<T, 32>>> { using type = unsigned long long; }; template <typename T> struct safely_multipliable<T, constraints_t<std::is_unsigned<T>, is_nbit<T, 64>>> { using type = __uint128_t; }; template <typename T> using safely_multipliable_t = typename safely_multipliable<T>::type; template <typename T, typename = void> struct rec_value_type { using type = T; }; template <typename T> struct rec_value_type<T, std::void_t<typename T::value_type>> { using type = typename rec_value_type<typename T::value_type>::type; }; template <typename T> using rec_value_type_t = typename rec_value_type<T>::type; template <typename T> class is_iterable { template <typename T_> static auto test(T_ e) -> decltype(e.begin(), e.end(), std::true_type{}); static std::false_type test(...); public: static constexpr bool value = decltype(test(std::declval<T>()))::value; }; template <typename T> static constexpr bool is_iterable_v = is_iterable<T>::value; template <typename T> class is_writable { template <typename T_> static auto test(T_ e) -> decltype(std::declval<std::ostream&>() << e, std::true_type{}); static std::false_type test(...); public: static constexpr bool value = decltype(test(std::declval<T>()))::value; }; template <typename T> static constexpr bool is_writable_v = is_writable<T>::value; template <typename T> class is_readable { template <typename T_> static auto test(T_ e) -> decltype(std::declval<std::istream&>() >> e, std::true_type{}); static std::false_type test(...); public: static constexpr bool value = decltype(test(std::declval<T>()))::value; }; template <typename T> static constexpr bool is_readable_v = is_readable<T>::value; } // namespace suisen #line 5 "library/util/update_proxy_object.hpp" namespace suisen { template <typename T, typename UpdateFunc, constraints_t<std::is_invocable<UpdateFunc>> = nullptr> struct UpdateProxyObject { public: UpdateProxyObject(T &v, UpdateFunc update) : v(v), update(update) {} operator T() const { return v; } auto& operator++() && { ++v, update(); return *this; } auto& operator--() && { --v, update(); return *this; } auto& operator+=(const T &val) && { v += val, update(); return *this; } auto& operator-=(const T &val) && { v -= val, update(); return *this; } auto& operator*=(const T &val) && { v *= val, update(); return *this; } auto& operator/=(const T &val) && { v /= val, update(); return *this; } auto& operator%=(const T &val) && { v %= val, update(); return *this; } auto& operator =(const T &val) && { v = val, update(); return *this; } auto& operator<<=(const T &val) && { v <<= val, update(); return *this; } auto& operator>>=(const T &val) && { v >>= val, update(); return *this; } template <typename F, constraints_t<std::is_invocable_r<T, F, T>> = nullptr> auto& apply(F f) && { v = f(v), update(); return *this; } private: T &v; UpdateFunc update; }; } // namespace suisen #line 7 "library/datastructure/segment_tree/lazy_segment_tree.hpp" namespace suisen { template <typename T, T(*op)(T, T), T(*e)(), typename F, T(*mapping)(F, T), F(*composition)(F, F), F(*id)(), bool enable_beats = false> struct LazySegmentTree { using value_type = T; using operator_type = F; LazySegmentTree() : LazySegmentTree(0) {} LazySegmentTree(int n) : LazySegmentTree(std::vector<value_type>(n, e())) {} LazySegmentTree(const std::vector<value_type>& init) : n(init.size()), m(ceil_pow2(n)), lg(__builtin_ctz(m)), data(2 * m, e()), lazy(m, id()) { std::copy(init.begin(), init.end(), data.begin() + m); for (int k = m - 1; k > 0; --k) update(k); } void apply(int l, int r, const operator_type& f) { assert(0 <= l and l <= r and r <= n); push_to(l, r); for (int l2 = l + m, r2 = r + m; l2 < r2; l2 >>= 1, r2 >>= 1) { if (l2 & 1) all_apply(l2++, f); if (r2 & 1) all_apply(--r2, f); } update_from(l, r); } void apply(int p, const operator_type& f) { (*this)[p] = mapping(f, get(p)); } value_type operator()(int l, int r) { assert(0 <= l and l <= r and r <= n); push_to(l, r); value_type res_l = e(), res_r = e(); for (l += m, r += m; l < r; l >>= 1, r >>= 1) { if (l & 1) res_l = op(res_l, data[l++]); if (r & 1) res_r = op(data[--r], res_r); } return op(res_l, res_r); } value_type prod(int l, int r) { return (*this)(l, r); } value_type prefix_prod(int r) { return (*this)(0, r); } value_type suffix_prod(int l) { return (*this)(l, m); } value_type all_prod() const { return data[1]; } auto operator[](int p) { assert(0 <= p and p < n); push_to(p); return UpdateProxyObject{ data[p + m], [this, p] { update_from(p); } }; } value_type get(int p) { return (*this)[p]; } void set(int p, value_type v) { (*this)[p] = v; } template <typename Pred, constraints_t<std::is_invocable_r<bool, Pred, value_type>> = nullptr> int max_right(int l, Pred g) { assert(0 <= l && l <= n); assert(g(e())); if (l == n) return n; l += m; for (int i = lg; i >= 1; --i) push(l >> i); value_type sum = e(); do { while ((l & 1) == 0) l >>= 1; if (not g(op(sum, data[l]))) { while (l < m) { push(l); l = 2 * l; if (g(op(sum, data[l]))) sum = op(sum, data[l++]); } return l - m; } sum = op(sum, data[l++]); } while ((l & -l) != l); return n; } template <bool(*f)(value_type)> int max_right(int l) { return max_right(l, f); } template <typename Pred, constraints_t<std::is_invocable_r<bool, Pred, value_type>> = nullptr> int min_left(int r, Pred g) { assert(0 <= r && r <= n); assert(g(e())); if (r == 0) return 0; r += m; for (int i = lg; i >= 1; --i) push(r >> i); value_type sum = e(); do { r--; while (r > 1 and (r & 1)) r >>= 1; if (not g(op(data[r], sum))) { while (r < m) { push(r); r = 2 * r + 1; if (g(op(data[r], sum))) sum = op(data[r--], sum); } return r + 1 - m; } sum = op(data[r], sum); } while ((r & -r) != r); return 0; } template <bool(*f)(value_type)> int min_left(int l) { return min_left(l, f); } private: int n, m, lg; std::vector<value_type> data; std::vector<operator_type> lazy; static constexpr int ceil_pow2(int n) { int m = 1; while (m < n) m <<= 1; return m; } void all_apply(int k, const operator_type& f) { data[k] = mapping(f, data[k]); if (k < m) { lazy[k] = composition(f, lazy[k]); if constexpr (enable_beats) if (data[k].fail) push(k), update(k); } } void push(int k) { all_apply(2 * k, lazy[k]), all_apply(2 * k + 1, lazy[k]); lazy[k] = id(); } void push_to(int p) { p += m; for (int i = lg; i >= 1; --i) push(p >> i); } void push_to(int l, int r) { l += m, r += m; int li = __builtin_ctz(l), ri = __builtin_ctz(r); for (int i = lg; i >= li + 1; --i) push(l >> i); for (int i = lg; i >= ri + 1; --i) push(r >> i); } void update(int k) { data[k] = op(data[2 * k], data[2 * k + 1]); } void update_from(int p) { p += m; for (int i = 1; i <= lg; ++i) update(p >> i); } void update_from(int l, int r) { l += m, r += m; int li = __builtin_ctz(l), ri = __builtin_ctz(r); for (int i = li + 1; i <= lg; ++i) update(l >> i); for (int i = ri + 1; i <= lg; ++i) update(r >> i); } }; } #line 6 "test/src/datastructure/segment_tree/lazy_segment_tree/DSL_2_I.test.cpp" using suisen::LazySegmentTree; using S = std::pair<long long, int>; using F = long long; S op(S p1, S p2) { auto [s1, l1] = p1; auto [s2, l2] = p2; return { s1 + s2, l1 + l2 }; } S e() { return { 0LL, 0 }; } S mapping(F f, S p) { int l = p.second; return f == std::numeric_limits<long long>::min() ? p : std::make_pair(f * l, l); } F composition(F f, F g) { return f == std::numeric_limits<long long>::min() ? g : f; } F id() { return std::numeric_limits<long long>::min(); } int main() { std::ios::sync_with_stdio(false); std::cin.tie(nullptr); int n, q; std::cin >> n >> q; LazySegmentTree<S, op, e, F, mapping, composition, id> seg(std::vector<S>(n, { 0LL, 1 })); for (int i = 0; i < q; ++i) { int t, l, r; std::cin >> t >> l >> r; ++r; if (t == 0) { long long x; std::cin >> x; seg.apply(l, r, x); } else { std::cout << seg(l, r).first << '\n'; } } return 0; }