Redesign APIs of binary-indexed-tree

Author: xirc

lib/cpalgo/ds/binary-indexed-tree-2d-sparse.hpp

@@ -1,108 +1,94 @@
 #pragma once
 
-// Finding Sum in Two-Dimensional Array
-
-#include <map>
 #include <functional>
+#include <map>
+#include <stdexcept>
 
 // BinaryIndexedTree
-// Memory: O(NM)
-// Query: O(logN logM logNM)
-// Update: O(logN logM logNM)
-template<class T = long long>
-class BinaryIndexedTree {
+//
+// Space: O(NM)
+// Time:
+//   Query: O(logN logM logNM)
+//   Update: O(logN logM logNM)
+//
+template<class T = int64_t>
+class BinaryIndexedTree2D {
 public:
-    using F = std::function<T(const T&, const T&)>;
+    using F = std::function<T(T const&, T const&)>;
 
 protected:
-    int N, M;
-    std::map<std::pair<int,int>,T> bit;
-    T id;
-    F plus;
-    F minus;
+    size_t N, M;
+    std::map<std::pair<size_t,size_t>,T> bit;
+    T empty;
+    F combine_func;
+    F remove_func;
 
 public:
-    // O(NM)
-    BinaryIndexedTree(
-        int n = 0,
-        int m = 0,
-        T id = T(),
-        F plus = std::plus<T>(),
-        F minus = std::minus<T>()
+    // Time: O(1)
+    BinaryIndexedTree2D(
+        size_t n = 0,
+        size_t m = 0,
+        T empty = T(),
+        F combine = std::plus<T>(),
+        F remove = std::minus<T>()
     )
         : N(n + 1)
         , M(m + 1)
         , bit()
-        , id(id)
-        , plus(plus)
-        , minus(minus)
+        , empty(empty)
+        , combine_func(combine)
+        , remove_func(remove)
     {
         // Do nothing
     }
-    // O(1)
-    std::pair<int,int> size() {
+    // Time: O(1)
+    std::pair<size_t,size_t> size() const {
         return { N - 1, M - 1 };
     }
-    // Sum of array[[0,x),[0,y)]
-    // O(logN logM logNM)
+    // Fold elements of array[[0,x),[0,y)]
     // x = [0,N], y = [0,M]
-    T sum(int x, int y) {
-        if (x < 0 || x > N) throw;
-        if (y < 0 || y > M) throw;
-        T ans = id;
-        for (int i = x; i > 0; i -= i & -i) {
-            for (int j = y; j > 0; j -= j & -j) {
-                if (!bit.count({i,j})) {
-                    bit[{i,j}] = id;
+    // Time: O(logN logM logNM)
+    T fold(size_t x, size_t y) const {
+        if (x > N) throw std::out_of_range("x");
+        if (y > M) throw std::out_of_range("y");
+        T ans = empty;
+        for (size_t i = x; i > 0; i -= i & -i) {
+            for (size_t j = y; j > 0; j -= j & -j) {
+                if (bit.count({i,j})) {
+                    ans = combine_func(ans, bit.at({i,j}));
                 }
-                ans = plus(ans, bit[{i,j}]);
             }
         }
         return ans;
     }
-    // Sum of array[[xl,xr),[yl,yr)]
-    // O(logN logM logNM)
-    // xl = [0,N], xr = [0,N]
-    // yl = [0,M], yr = [0,M]
-    T sum(int xl, int xr, int yl, int yr) {
-        if (xl > xr || yl > yr) throw;
-        if (xl < 0 || xl > N || xr < 0 || xr > N) throw;
-        if (yl < 0 || yl > M || yr < 0 || yr > M) throw;
-        T ans = id;
-        ans = plus(ans, sum(xr, yr));
-        ans = minus(ans, sum(xl, yr));
-        ans = minus(ans, sum(xr, yl));
-        ans = plus(ans, sum(xl, yl));
+    // Fold elements of array[[xl,xr),[yl,yr)]
+    // xl = [0,N), xr = [xl,N]
+    // yl = [0,M), yr = [yl,M]
+    // Time: O(logN logM logNM)
+    T fold(size_t xl, size_t xr, size_t yl, size_t yr) const {
+        if (xl >= N) throw std::out_of_range("xl");
+        if (xr < xl || xr > N) throw std::out_of_range("xr");
+        if (yl >= M) throw std::out_of_range("yl");
+        if (yr < yl || yr > M) std::out_of_range("yr");
+        T ans = empty;
+        ans = combine_func(ans, fold(xr, yr));
+        ans = remove_func(ans, fold(xl, yr));
+        ans = remove_func(ans, fold(xr, yl));
+        ans = combine_func(ans, fold(xl, yl));
         return ans;
     }
-    // Add value at array[x,y]
-    // O(logN logN logNM)
-    // x = [0,N), y = [0,M)
-    void add(int x, int y, const T& value) {
-        if (x < 0 || x >= N) throw;
-        if (y < 0 || y >= M) throw;
-        for (int i = x + 1; i < N; i += i & -i) {
-            for (int j = y + 1; j < M; j += j & -j) {
-                if (!bit.count({i,j})) {
-                    bit[{i,j}] = id;
-                }
-                bit[{i,j}] = plus(bit[{i,j}], value);
-            }
-        }
-    }
-    // Set value at array[x,y]
-    // O(logN logN logNM)
+    // Combine given value at array[x,y]
     // x = [0,N), y = [0,M)
-    void set(int x, int y, const T& value) {
-        if (x < 0 || x >= N) throw;
-        if (y < 0 || y >= M) throw;
-        int new_value = value - sum(x,x+1,y,y+1);
-        for (int i = x + 1; i < N; i += i & -i) {
-            for (int j = y + 1; j < M; j += j & -j) {
+    // Time: O(logN logN logNM)
+    void combine(size_t x, size_t y, T const& value) {
+        if (x >= N) throw std::out_of_range("x");
+        if ( y >= M) throw std::out_of_range("y");
+        for (size_t i = x + 1; i < N; i += i & -i) {
+            for (size_t j = y + 1; j < M; j += j & -j) {
                 if (!bit.count({i,j})) {
-                    bit[{i,j}] = id;
+                    bit[{i,j}] = empty;
                 }
-                bit[{i,j}] = plus(bit[{i,j}], new_value);
+                bit[{i,j}] = combine_func(bit[{i,j}], value);
             }
         }
     }

lib/cpalgo/ds/binary-indexed-tree.hpp

@@ -1,80 +1,78 @@
 #pragma once
 
-// Finding Sum in One-Dimensional Array
-// Verified
-// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_2_B
-
-#include <vector>
 #include <functional>
+#include <stdexcept>
+#include <vector>
 
 // Binary Indexed Tree
-// Memory: O(N)
-// Query: O(logN)
-// Update: O(logN)
-template <class T = long long>
+//
+// Space: O(N)
+// Time:
+//   Query: O(logN)
+//   Update: O(logN)
+//
+// Verified:
+//  - http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_2_B
+//
+template <class T = int64_t>
 class BinaryIndexedTree {
 public:
-    using F = std::function<T(const T&, const T&)>;
+    using F = std::function<T(T const&, T const&)>;
 
 protected:
-    int N;
+    size_t N;
     std::vector<T> bit;
-    T id;
-    F plus;
-    F minus;
+    T empty;
+    F combine_func;
+    F remove_func;
 
 public:
-    // O(N)
+    // Time: O(N)
     BinaryIndexedTree(
-        int n = 0,
-        T id = T(),
-        F plus = std::plus<T>(),
-        F minus = std::minus<T>()
+        size_t n = 0,
+        T empty = T(),
+        F combine = std::plus<T>(),
+        F remove = std::minus<T>()
     )
         : N(n+1)
-        , bit(n+1, id)
-        , id(id)
-        , plus(plus)
-        , minus(minus)
+        , bit(n+1, empty)
+        , empty(empty)
+        , combine_func(combine)
+        , remove_func(remove)
     {
         // Do nothing
     }
-    // O(1)
-    int size() {
+    // Time: O(1)
+    size_t size() const {
         return N - 1;
     }
-    // Sum of array[0..index)
-    // O(logN)
+    // Fold elements of array[0..index)
     // index = [0,N]
-    T sum(int index) {
-        if (index < 0 || index > N) throw;
-        T ans = id;
+    // Time: O(logN)
+    T fold(size_t index) const {
+        if (index > N) throw std::out_of_range("index");
+        T ans = empty;
         for (; index > 0; index -= index & -index) {
-            ans = plus(ans, bit[index]);
+            ans = combine_func(ans, bit[index]);
         }
         return ans;
     }
-    // Sum of array[l, r)
-    // O(logN)
-    T sum(int l, int r) {
-        if (l > r) throw;
-        return minus(sum(r), sum(l));
+    // Fold elements of array[l, r)
+    // l = [0,N)
+    // r = [l,N]
+    // Time: O(logN)
+    T fold(size_t l, size_t r) const {
+        if (l >= N) throw std::out_of_range("l");
+        if (r < l || r > N) throw std::out_of_range("r");
+        return remove_func(fold(r), fold(l));
     }
-    // Add value to array[index]
-    // O(logN)
+    // Combine given value to array[index]
     // index = [0,N)
-    void add(int index, const T& value) {
-        if (index < 0 || index >= N) throw;
+    // Time: O(logN)
+    void combine(size_t index, T const& value) {
+        if (index >= N) throw std::out_of_range("index");
         for (++index; index < N; index += index & -index) {
-            bit[index] = plus(bit[index], value);
+            bit[index] = combine_func(bit[index], value);
         }
     }
-    // Set value to array[index]
-    // O(logN)
-    // index = [0,N)
-    void set(int index, const T& value) {
-        if (index < 0 || index >= N) throw;
-        T new_value = minus(value, sum(index, index+1));
-        add(index, new_value);
-    }
 };

lib/main/ds/binary-indexed-tree/main-binary-indexed-tree-2d-sparse.cpp

@@ -7,67 +7,51 @@
 
 using namespace std;
 
-using BIT = BinaryIndexedTree<long long>;
+using BIT = BinaryIndexedTree2D<int>;
 BIT bit;
 
 void action_init() {
-    int size_n, size_m;
+    size_t size_n, size_m;
     cin >> size_n >> size_m;
-    if (size_n <= 0 || size_m <= 0) {
-        cout << "false" << endl;
-        return;
-    }
     bit = BIT(size_n, size_m);
     cout << "true" << endl;
 }
 
 void action_sum() {
-    int N, M;
+    size_t N, M;
     tie(N, M) = bit.size();
-    int x, y;
+    size_t x, y;
     cin >> x >> y;
-    if (x < 0 || x > N || y < 0 || y > M) {
+    if (x > N || y > M) {
         cout << "false" << endl;
         return;
     }
-    auto ans = bit.sum(x, y);
+    auto ans = bit.fold(x, y);
     cout << ans << endl;
 }
 
 void action_add() {
-    int N, M;
-    tie(N, M) = bit.size();
-    int x, y, value;
-    cin >> x >> y >> value;
-    if (x < 0 || x >= N || y < 0 || y >= M) {
-        cout << "false" << endl;
-        return;
-    }
-    bit.add(x, y, value);
-    cout << "true" << endl;
-}
-
-void action_set() {
-    int N, M;
+    size_t N, M;
     tie(N, M) = bit.size();
-    int x, y, value;
+    size_t x, y;
+    int value;
     cin >> x >> y >> value;
-    if (x < 0 || x >= N || y < 0 || y >= M) {
+    if (x >= N || y >= M) {
         cout << "false" << endl;
         return;
     }
-    bit.set(x, y, value);
+    bit.combine(x, y, value);
     cout << "true" << endl;
 }
 
 void action_dump() {
-    int N, M;
+    size_t N, M;
     tie(N,M) = bit.size();
-    for (int y = 0; y < M; ++y) {
+    for (size_t y = 0; y < M; ++y) {
         if (y > 0) cout << endl;
-        for (int x = 0; x < N; ++x) {
+        for (size_t x = 0; x < N; ++x) {
             if (x > 0) cout << " ";
-            cout << bit.sum(x, x+1, y, y+1);
+            cout << bit.fold(x, x+1, y, y+1);
         }
     }
     cout << endl;
@@ -78,6 +62,5 @@ void setup(string& header, map<string,Command>& commands) {
     commands["init"] = { "init {size_n} {size_m}", action_init };
     commands["sum"] = { "sum {x} {y}", action_sum };
     commands["add"] = { "add {x} {y} {value}", action_add };
-    commands["set"] = { "set {x} {y} {value}", action_add };
     commands["dump"] = { "dump", action_dump };
 }