Skip to content

Commit 811ab42

Browse files
hitonanodehitonanode
committed
fix segtrees
1 parent 5528317 commit 811ab42

File tree

5 files changed

+107
-46
lines changed

5 files changed

+107
-46
lines changed

‎segmenttree/acl_beats.hpp‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,14 @@
11
#pragma once
22
#include "acl_lazysegtree.hpp"
33

4-
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S), F (*composition)(F, F),
5-
F (*id)()>
4+
#include <algorithm>
5+
#include <iostream>
6+
7+
template <class S, auto op, auto e, class F, auto mapping, auto composition, auto id>
68
class segtree_beats : public atcoder::lazy_segtree<S, op, e, F, mapping, composition, id> {
79
using Base = atcoder::lazy_segtree<S, op, e, F, mapping, composition, id>;
810
using Base::lazy_segtree;
9-
void all_apply(int k, F f) const override {
11+
void all_apply(int k, F f) override {
1012
Base::d[k] = mapping(f, Base::d[k]);
1113
if (k < Base::size) {
1214
Base::lz[k] = composition(f, Base::lz[k]);
@@ -16,8 +18,6 @@ class segtree_beats : public atcoder::lazy_segtree<S, op, e, F, mapping, composi
1618
};
1719

1820
namespace RangeChMinMaxAddSum {
19-
#include <algorithm>
20-
2121
template <typename Num> inline Num second_lowest(Num a, Num a2, Num c, Num c2) noexcept {
2222
assert(a <= a2); // a < a2 or a == a2 == INF
2323
assert(c <= c2); // c < c2 or c == c2 == -INF

‎segmenttree/acl_lazysegtree.hpp‎

Lines changed: 53 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -5,21 +5,32 @@
55
#include <intrin.h>
66
#endif
77

8+
#if __cplusplus >= 202002L
9+
#include <bit>
10+
#endif
11+
812
namespace atcoder {
913

1014
namespace internal {
1115

12-
// @param n `0 <= n`
13-
// @return minimum non-negative `x` s.t. `n <= 2**x`
14-
int ceil_pow2(int n) {
15-
int x = 0;
16-
while ((1U << x) < (unsigned int)(n)) x++;
16+
#if __cplusplus >= 202002L
17+
18+
using std::bit_ceil;
19+
20+
#else
21+
22+
// @return same with std::bit::bit_ceil
23+
unsigned int bit_ceil(unsigned int n) {
24+
unsigned int x = 1;
25+
while (x < (unsigned int)(n)) x *= 2;
1726
return x;
1827
}
1928

29+
#endif
30+
2031
// @param n `1 <= n`
21-
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
22-
int bsf(unsigned int n) {
32+
// @return same with std::bit::countr_zero
33+
int countr_zero(unsigned int n) {
2334
#ifdef _MSC_VER
2435
unsigned long index;
2536
_BitScanForward(&index, n);
@@ -29,6 +40,14 @@ int bsf(unsigned int n) {
2940
#endif
3041
}
3142

43+
// @param n `1 <= n`
44+
// @return same with std::bit::countr_zero
45+
constexpr int countr_zero_constexpr(unsigned int n) {
46+
int x = 0;
47+
while (!(n & (1 << x))) x++;
48+
return x;
49+
}
50+
3251
} // namespace internal
3352

3453
} // namespace atcoder
@@ -37,24 +56,31 @@ int bsf(unsigned int n) {
3756
#ifndef ATCODER_LAZYSEGTREE_HPP
3857
#define ATCODER_LAZYSEGTREE_HPP 1
3958

40-
#include <algorithm>
4159
#include <cassert>
42-
#include <iostream>
60+
#include <functional>
4361
#include <vector>
4462

45-
// #include "atcoder/internal_bit"
63+
#include "atcoder/internal_bit"
4664

4765
namespace atcoder {
4866

49-
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S), F (*composition)(F, F),
50-
F (*id)()>
67+
template <class S, auto op, auto e, class F, auto mapping, auto composition, auto id>
5168
struct lazy_segtree {
69+
static_assert(std::is_convertible_v<decltype(op), std::function<S(S, S)>>,
70+
"op must work as S(S, S)");
71+
static_assert(std::is_convertible_v<decltype(e), std::function<S()>>, "e must work as S()");
72+
static_assert(std::is_convertible_v<decltype(mapping), std::function<S(F, S)>>,
73+
"mapping must work as S(F, S)");
74+
static_assert(std::is_convertible_v<decltype(composition), std::function<F(F, F)>>,
75+
"composition must work as F(F, F)");
76+
static_assert(std::is_convertible_v<decltype(id), std::function<F()>>, "id must work as F()");
77+
5278
public:
5379
lazy_segtree() : lazy_segtree(0) {}
5480
explicit lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
5581
explicit lazy_segtree(const std::vector<S> &v) : _n(int(v.size())) {
56-
log = internal::ceil_pow2(_n);
57-
size = 1 << log;
82+
size = (int)internal::bit_ceil((unsigned int)(_n));
83+
log = internal::countr_zero((unsigned int)size);
5884
d = std::vector<S>(2 * size, e());
5985
lz = std::vector<F>(size, id());
6086
for (int i = 0; i < _n; i++) d[size + i] = v[i];
@@ -69,14 +95,14 @@ struct lazy_segtree {
6995
for (int i = 1; i <= log; i++) update(p >> i);
7096
}
7197

72-
S get(int p) const {
98+
S get(int p) {
7399
assert(0 <= p && p < _n);
74100
p += size;
75101
for (int i = log; i >= 1; i--) push(p >> i);
76102
return d[p];
77103
}
78104

79-
S prod(int l, int r) const {
105+
S prod(int l, int r) {
80106
assert(0 <= l && l <= r && r <= _n);
81107
if (l == r) return e();
82108

@@ -99,7 +125,7 @@ struct lazy_segtree {
99125
return op(sml, smr);
100126
}
101127

102-
S all_prod() const { return d[1]; }
128+
S all_prod() { return d[1]; }
103129

104130
void apply(int p, F f) {
105131
assert(0 <= p && p < _n);
@@ -138,10 +164,10 @@ struct lazy_segtree {
138164
}
139165
}
140166

141-
template <bool (*g)(S)> int max_right(int l) const {
167+
template <bool (*g)(S)> int max_right(int l) {
142168
return max_right(l, [](S x) { return g(x); });
143169
}
144-
template <class G> int max_right(int l, G g) const {
170+
template <class G> int max_right(int l, G g) {
145171
assert(0 <= l && l <= _n);
146172
assert(g(e()));
147173
if (l == _n) return _n;
@@ -167,10 +193,10 @@ struct lazy_segtree {
167193
return _n;
168194
}
169195

170-
template <bool (*g)(S)> int min_left(int r) const {
196+
template <bool (*g)(S)> int min_left(int r) {
171197
return min_left(r, [](S x) { return g(x); });
172198
}
173-
template <class G> int min_left(int r, G g) const {
199+
template <class G> int min_left(int r, G g) {
174200
assert(0 <= r && r <= _n);
175201
assert(g(e()));
176202
if (r == 0) return 0;
@@ -198,23 +224,23 @@ struct lazy_segtree {
198224

199225
protected:
200226
int _n, size, log;
201-
mutable std::vector<S> d;
202-
mutable std::vector<F> lz;
227+
std::vector<S> d;
228+
std::vector<F> lz;
203229

204-
void update(int k) const { d[k] = op(d[2 * k], d[2 * k + 1]); }
205-
virtual void all_apply(int k, F f) const {
230+
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
231+
virtual void all_apply(int k, F f) {
206232
d[k] = mapping(f, d[k]);
207233
if (k < size) lz[k] = composition(f, lz[k]);
208234
}
209-
void push(int k) const {
235+
void push(int k) {
210236
all_apply(2 * k, lz[k]);
211237
all_apply(2 * k + 1, lz[k]);
212238
lz[k] = id();
213239
}
214240
};
215241
} // namespace atcoder
216242
#endif // ATCODER_LAZYSEGTREE_HPP
217-
// Reference: https://atcoder.github.io/ac-library/document_ja/lazysegtree.html
243+
// Reference: https://atcoder.github.io/ac-library/production/document_ja/lazysegtree.html
218244
// https://betrue12.hateblo.jp/entry/2020/09/22/194541
219245
// https://betrue12.hateblo.jp/entry/2020/09/23/005940
220246
/*

‎segmenttree/acl_segtree.hpp‎

Lines changed: 26 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -5,21 +5,32 @@
55
#include <intrin.h>
66
#endif
77

8+
#if __cplusplus >= 202002L
9+
#include <bit>
10+
#endif
11+
812
namespace atcoder {
913

1014
namespace internal {
1115

12-
// @param n `0 <= n`
13-
// @return minimum non-negative `x` s.t. `n <= 2**x`
14-
int ceil_pow2(int n) {
15-
int x = 0;
16-
while ((1U << x) < (unsigned int)(n)) x++;
16+
#if __cplusplus >= 202002L
17+
18+
using std::bit_ceil;
19+
20+
#else
21+
22+
// @return same with std::bit::bit_ceil
23+
unsigned int bit_ceil(unsigned int n) {
24+
unsigned int x = 1;
25+
while (x < (unsigned int)(n)) x *= 2;
1726
return x;
1827
}
1928

29+
#endif
30+
2031
// @param n `1 <= n`
21-
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
22-
int bsf(unsigned int n) {
32+
// @return same with std::bit::countr_zero
33+
int countr_zero(unsigned int n) {
2334
#ifdef _MSC_VER
2435
unsigned long index;
2536
_BitScanForward(&index, n);
@@ -38,21 +49,24 @@ int bsf(unsigned int n) {
3849
#ifndef ATCODER_SEGTREE_HPP
3950
#define ATCODER_SEGTREE_HPP 1
4051

41-
#include <algorithm>
4252
#include <cassert>
53+
#include <functional>
4354
#include <vector>
4455

4556
// #include "atcoder/internal_bit"
4657

4758
namespace atcoder {
59+
template <class S, auto op, auto e> struct segtree {
60+
static_assert(std::is_convertible_v<decltype(op), std::function<S(S, S)>>,
61+
"op must work as S(S, S)");
62+
static_assert(std::is_convertible_v<decltype(e), std::function<S()>>, "e must work as S()");
4863

49-
template <class S, S (*op)(S, S), S (*e)()> struct segtree {
5064
public:
5165
segtree() : segtree(0) {}
5266
explicit segtree(int n) : segtree(std::vector<S>(n, e())) {}
5367
explicit segtree(const std::vector<S> &v) : _n(int(v.size())) {
54-
log = internal::ceil_pow2(_n);
55-
size = 1 << log;
68+
size = (int)internal::bit_ceil((unsigned int)(_n));
69+
log = internal::countr_zero((unsigned int)size);
5670
d = std::vector<S>(2 * size, e());
5771
for (int i = 0; i < _n; i++) d[size + i] = v[i];
5872
for (int i = size - 1; i >= 1; i--) { update(i); }
@@ -152,7 +166,7 @@ template <class S, S (*op)(S, S), S (*e)()> struct segtree {
152166

153167
#endif // ATCODER_SEGTREE_HPP
154168

155-
// Reference: https://atcoder.github.io/ac-library/document_ja/segtree.html
169+
// Reference: https://atcoder.github.io/ac-library/production/document_ja/segtree.html
156170
/* usage:
157171
struct S {
158172
long long su;

‎segmenttree/acl_segtree.md‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
---
2+
title: Segtree (based on atcoder::segtree)
3+
documentation_of: ./acl_segtree.hpp
4+
---
5+
6+
ACL-based segtree
7+
8+
## Example
9+
10+
```cpp
11+
struct S {};
12+
S op(S l, S r) {
13+
return {};
14+
}
15+
S e() { return {}; };
16+
vector<S> A;
17+
atcoder::segtree<S, op, e> seg(A);
18+
```
19+
20+
## Link
21+
22+
- [ACL reference](https://atcoder.github.io/ac-library/production/document_ja/segtree.html)

‎segmenttree/binary_indexed_tree_2d.hpp‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,7 @@
11
#pragma once
22
#include <array>
33

4-
// CUT begin
5-
// 2-dimentional 1-indexed BIT (i : [1, lenX][1, lenY])
4+
// 2-dimensional 1-indexed BIT (i : [1, lenX][1, lenY])
65
template <typename T, int lenX, int lenY> struct BIT_2D {
76
std::array<T, (lenX + 1) * (lenY + 1)> val;
87
constexpr static int M = lenY + 1;

0 commit comments

Comments
 (0)