Binary Indexed Tree
(library/data-structure/bit.hpp)

• View this file on GitHub
• Last update: 2025-03-03 00:33:48+09:00
• Include: #include "library/data-structure/bit.hpp"

概要

Binary Indexed Tree (Fenwick Tree)

使い方

BIT<T, op, invop, e>(n)

• T : 要素の型
• op: 演算 (デフォルトは +)
• invop : 逆演算 (デフォルトは -)
• e : 単位元 (デフォルトは 0)
• n : 要素数
• bit.add(i, x) : i 番目の要素に x を加算する
• bit.sum(l, r) : [l, r) の要素の和を返す

Depends on

• library/_internal/modint-base.hpp
• 内部型 (library/_internal/types.hpp)

Required by

• Meissel–Lehmer Algorithm (library/math/meissel-lehmer.hpp)

Verified with

• tests/data-structure/bit/abc185-f.test.cpp
• tests/data-structure/bit/abc222-d.test.cpp
• tests/data-structure/bit/libchecker-rsq.test.cpp
• tests/data-structure/bit/libchecker-static.test.cpp
• tests/math/meissel-lehmer/libchecker.test.cpp

Code

#pragma once

#include <vector>
using namespace std;

#include "../_internal/types.hpp"

namespace asalib {
  namespace ds {
    template<_internal::numeric_like T, T (*op)(T, T) = _internal::plus<T>, T (*invop)(T, T) = _internal::minus<T>, T (*e)() = _internal::zero<T>>
    class BIT {
      public:
      BIT(): _n(0) {}
      explicit BIT(size_t n) {
        _n = n;
        data.reserve(n);
        data.resize(n, 0);
      }

      void add(size_t i, T x) {
        assert(0 <= i && i < _n);
        ++i;
        while (i <= _n) {
          data[i - 1] = op(data[i - 1], x);
          i += i & -i;
        }
      }

      T sum(size_t l, size_t r) const {
        assert(0 <= l && l <= r && r <= _n);
        return invop(_sum(r), _sum(l));
      }

      private:
      size_t _n;
      vector<T> data;
      T _sum(size_t i) const {
        T s = e();
        while (i > 0) {
          s = op(s, data[i - 1]);
          i -= i & -i;
        }
        return s;
      }
    };
  }  // namespace ds
}  // namespace asalib

#line 2 "library/data-structure/bit.hpp"

#include <vector>
using namespace std;

#line 2 "library/_internal/types.hpp"

#include <concepts>
#include <type_traits>
using namespace std;

#line 2 "library/_internal/modint-base.hpp"

#line 5 "library/_internal/modint-base.hpp"
using namespace std;

namespace asalib {
  namespace _internal {
    class modint_base {};

    template<typename T>
    concept is_modint = is_base_of_v<modint_base, T>;
  }  // namespace _internal
}  // namespace asalib
#line 8 "library/_internal/types.hpp"

namespace asalib {
  namespace _internal {
    // ---------- concept definition ---------- //
    template<class T>
    concept integral_like = integral<T> || is_modint<T>;

    template<class T>
    concept floating_like = floating_point<T>;

    template<class T>
    concept numeric_like = integral_like<T> || floating_like<T>;

    // ---------- function definition ---------- //
    template<class T>
    T plus(T a, T b) { return a + b; }

    template<class T>
    T minus(T a, T b) { return a - b; }

    // ---------- constant definition ---------- //
    template<class T>
    T zero() { return 0; }
  }  // namespace _internal
}  // namespace asalib
#line 7 "library/data-structure/bit.hpp"

namespace asalib {
  namespace ds {
    template<_internal::numeric_like T, T (*op)(T, T) = _internal::plus<T>, T (*invop)(T, T) = _internal::minus<T>, T (*e)() = _internal::zero<T>>
    class BIT {
      public:
      BIT(): _n(0) {}
      explicit BIT(size_t n) {
        _n = n;
        data.reserve(n);
        data.resize(n, 0);
      }

      void add(size_t i, T x) {
        assert(0 <= i && i < _n);
        ++i;
        while (i <= _n) {
          data[i - 1] = op(data[i - 1], x);
          i += i & -i;
        }
      }

      T sum(size_t l, size_t r) const {
        assert(0 <= l && l <= r && r <= _n);
        return invop(_sum(r), _sum(l));
      }

      private:
      size_t _n;
      vector<T> data;
      T _sum(size_t i) const {
        T s = e();
        while (i > 0) {
          s = op(s, data[i - 1]);
          i -= i & -i;
        }
        return s;
      }
    };
  }  // namespace ds
}  // namespace asalib

Back to top page