Merge pull request #107 from hitonanode/adding_const_to_segtree_and_lazy_segtree

#106: make several methods of segtree and lazy_segtree const

Author: yosupo06

atcoder/lazysegtree.hpp

@@ -40,14 +40,14 @@ struct lazy_segtree {
         for (int i = 1; i <= log; i++) update(p >> i);
     }
 
-    S get(int p) {
+    S get(int p) const {
         assert(0 <= p && p < _n);
         p += size;
         for (int i = log; i >= 1; i--) push(p >> i);
         return d[p];
     }
 
-    S prod(int l, int r) {
+    S prod(int l, int r) const {
         assert(0 <= l && l <= r && r <= _n);
         if (l == r) return e();
 
@@ -70,7 +70,7 @@ struct lazy_segtree {
         return op(sml, smr);
     }
 
-    S all_prod() { return d[1]; }
+    S all_prod() const { return d[1]; }
 
     void apply(int p, F f) {
         assert(0 <= p && p < _n);
@@ -109,10 +109,10 @@ struct lazy_segtree {
         }
     }
 
-    template <bool (*g)(S)> int max_right(int l) {
+    template <bool (*g)(S)> int max_right(int l) const {
         return max_right(l, [](S x) { return g(x); });
     }
-    template <class G> int max_right(int l, G g) {
+    template <class G> int max_right(int l, G g) const {
         assert(0 <= l && l <= _n);
         assert(g(e()));
         if (l == _n) return _n;
@@ -138,10 +138,10 @@ struct lazy_segtree {
         return _n;
     }
 
-    template <bool (*g)(S)> int min_left(int r) {
+    template <bool (*g)(S)> int min_left(int r) const {
         return min_left(r, [](S x) { return g(x); });
     }
-    template <class G> int min_left(int r, G g) {
+    template <class G> int min_left(int r, G g) const {
         assert(0 <= r && r <= _n);
         assert(g(e()));
         if (r == 0) return 0;
@@ -169,15 +169,15 @@ struct lazy_segtree {
 
   private:
     int _n, size, log;
-    std::vector<S> d;
-    std::vector<F> lz;
+    mutable std::vector<S> d;
+    mutable std::vector<F> lz;
 
     void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
-    void all_apply(int k, F f) {
+    void all_apply(int k, F f) const {
         d[k] = mapping(f, d[k]);
         if (k < size) lz[k] = composition(f, lz[k]);
     }
-    void push(int k) {
+    void push(int k) const {
         all_apply(2 * k, lz[k]);
         all_apply(2 * k + 1, lz[k]);
         lz[k] = id();

atcoder/segtree.hpp

@@ -30,12 +30,12 @@ template <class S, S (*op)(S, S), S (*e)()> struct segtree {
         for (int i = 1; i <= log; i++) update(p >> i);
     }
 
-    S get(int p) {
+    S get(int p) const {
         assert(0 <= p && p < _n);
         return d[p + size];
     }
 
-    S prod(int l, int r) {
+    S prod(int l, int r) const {
         assert(0 <= l && l <= r && r <= _n);
         S sml = e(), smr = e();
         l += size;
@@ -50,12 +50,12 @@ template <class S, S (*op)(S, S), S (*e)()> struct segtree {
         return op(sml, smr);
     }
 
-    S all_prod() { return d[1]; }
+    S all_prod() const { return d[1]; }
 
-    template <bool (*f)(S)> int max_right(int l) {
+    template <bool (*f)(S)> int max_right(int l) const {
         return max_right(l, [](S x) { return f(x); });
     }
-    template <class F> int max_right(int l, F f) {
+    template <class F> int max_right(int l, F f) const {
         assert(0 <= l && l <= _n);
         assert(f(e()));
         if (l == _n) return _n;
@@ -79,10 +79,10 @@ template <class S, S (*op)(S, S), S (*e)()> struct segtree {
         return _n;
     }
 
-    template <bool (*f)(S)> int min_left(int r) {
+    template <bool (*f)(S)> int min_left(int r) const {
         return min_left(r, [](S x) { return f(x); });
     }
-    template <class F> int min_left(int r, F f) {
+    template <class F> int min_left(int r, F f) const {
         assert(0 <= r && r <= _n);
         assert(f(e()));
         if (r == 0) return 0;