data_structures -> structures, add fenwick and fenwick_set + ordered_set test

Author: adamant-pwn

.verify-helper/timestamps.remote.json

@@ -3,9 +3,9 @@
 "verify/algebra/poly/convolution107.test.cpp": "2024-02-11 15:34:32 +0100",
 "verify/algebra/poly/find_linrec.test.cpp": "2024-02-11 15:34:32 +0100",
 "verify/algebra/poly/poly_sqrt.test.cpp": "2024-02-11 15:34:32 +0100",
-"verify/data_structures/segtree/range_affine_range_sum.test.cpp": "2024-02-11 15:34:32 +0100",
-"verify/data_structures/segtree/range_chmin_chmax_add_range_sum.test.cpp": "2024-02-11 15:34:32 +0100",
-"verify/data_structures/treap/cartesian_tree.test.cpp": "2024-02-11 15:34:32 +0100",
-"verify/data_structures/treap/dynamic_sequence_range_affine_range_sum.test.cpp": "2024-02-11 15:34:32 +0100",
-"verify/data_structures/treap/range_reverse_range_sum.test.cpp": "2024-02-11 15:34:32 +0100"
+"verify/structures/segtree/range_affine_range_sum.test.cpp": "2024-02-11 15:34:32 +0100",
+"verify/structures/segtree/range_chmin_chmax_add_range_sum.test.cpp": "2024-02-11 15:34:32 +0100",
+"verify/structures/treap/cartesian_tree.test.cpp": "2024-02-11 15:34:32 +0100",
+"verify/structures/treap/dynamic_sequence_range_affine_range_sum.test.cpp": "2024-02-11 15:34:32 +0100",
+"verify/structures/treap/range_reverse_range_sum.test.cpp": "2024-02-11 15:34:32 +0100"
 }

cp-algo/data_structures/segtree/metas/base.hpp

@@ -1,7 +1,7 @@
 #ifndef CP_ALGO_GRAPH_BASE_HPP
 #define CP_ALGO_GRAPH_BASE_HPP
 #include "edge_types.hpp"
-#include "../data_structures/stack_union.hpp"
+#include "../structures/stack_union.hpp"
 #include <ranges>
 #include <vector>
 namespace cp_algo::graph {
@@ -56,7 +56,7 @@ namespace cp_algo::graph {
     private:
         node_index v0;
         std::vector<edge_t> edges;
-        data_structures::stack_union<edge_index> adj;
+        structures::stack_union<edge_index> adj;
     };
 }
 #endif // CP_ALGO_GRAPH_BASE_HPP

cp-algo/data_structures/treap/common.hpp

@@ -1,7 +1,7 @@
 #ifndef CP_ALGO_GRAPH_MST_HPP
 #define CP_ALGO_GRAPH_MST_HPP
 #include "base.hpp"
-#include "../data_structures/dsu.hpp"
+#include "../structures/dsu.hpp"
 #include <algorithm>
 namespace cp_algo::graph {
     template<weighted_edge_type edge_t>
@@ -11,7 +11,7 @@ namespace cp_algo::graph {
             edges.emplace_back(g.edge(e).w, e);
         });
         std::ranges::sort(edges);
-        data_structures::dsu me(g.n());
+        structures::dsu me(g.n());
         int64_t total = 0;
         std::vector<edge_index> mst;
         for(auto [w, e]: edges) {

cp-algo/graph/base.hpp

@@ -1,12 +1,12 @@
 
-#ifndef CP_ALGO_DATA_STRUCTURES_BITPACK_HPP
-#define CP_ALGO_DATA_STRUCTURES_BITPACK_HPP
+#ifndef CP_ALGO_STRUCTURES_BITPACK_HPP
+#define CP_ALGO_STRUCTURES_BITPACK_HPP
 #include <cstdint>
 #include <cstddef>
 #include <string>
 #include <array>
 #include <bit>
-namespace cp_algo::data_structures {
+namespace cp_algo::structures {
     template<size_t n, typename Int = uint64_t>
     struct bitpack {
         static constexpr uint8_t bits_per_block = 8 * sizeof(Int);
@@ -76,4 +76,4 @@ namespace cp_algo::data_structures {
         }
     };
 }
-#endif // CP_ALGO_DATA_STRUCTURES_BITPACK_HPP
+#endif // CP_ALGO_STRUCTURES_BITPACK_HPP

cp-algo/graph/mst.hpp

@@ -1,8 +1,8 @@
-#ifndef CP_ALGO_DATA_STRUCTURES_DSU_HPP
-#define CP_ALGO_DATA_STRUCTURES_DSU_HPP
+#ifndef CP_ALGO_STRUCTURES_DSU_HPP
+#define CP_ALGO_STRUCTURES_DSU_HPP
 #include <numeric>
 #include <vector>
-namespace cp_algo::data_structures {
+namespace cp_algo::structures {
     struct disjoint_set_union {
         disjoint_set_union (int n): par(n) {
             std::iota(begin(par), end(par), 0);
@@ -21,4 +21,4 @@ namespace cp_algo::data_structures {
     };
     using dsu = disjoint_set_union;
 }
-#endif // CP_ALGO_DATA_STRUCTURES_DSU_HPP
+#endif // CP_ALGO_STRUCTURES_DSU_HPP

cp-algo/data_structures/bitpack.hpp renamed to cp-algo/structures/bitpack.hpp

@@ -1,12 +1,12 @@
-#ifndef CP_ALGO_DATA_STRUCTURES_EERTREE_HPP
-#define CP_ALGO_DATA_STRUCTURES_EERTREE_HPP
+#ifndef CP_ALGO_STRUCTURES_EERTREE_HPP
+#define CP_ALGO_STRUCTURES_EERTREE_HPP
 #include <forward_list>
 #include <functional>
 #include <iostream>
 #include <vector>
 #include <string>
 #include "../bump_alloc.hpp"
-namespace cp_algo::data_structures {
+namespace cp_algo::structures {
     template<int sigma = 26, char mch = 'a'>
     struct eertree {
         eertree(size_t q) {
@@ -69,4 +69,4 @@ namespace cp_algo::data_structures {
         int n = 1, sz = 2, last = 0;
     };
 }
-#endif // CP_ALGO_DATA_STRUCTURES_EERTREE_HPP
+#endif // CP_ALGO_STRUCTURES_EERTREE_HPP

cp-algo/data_structures/dsu.hpp renamed to cp-algo/structures/dsu.hpp

@@ -0,0 +1,59 @@
+#ifndef CP_ALGO_STRUCTURES_FENWICK_HPP
+#define CP_ALGO_STRUCTURES_FENWICK_HPP
+#include <cassert>
+#include <vector>
+#include <bit>
+namespace cp_algo::structures {
+    template<typename T, typename Container = std::vector<T>>
+    struct fenwick {
+        size_t n;
+        Container data;
+
+        fenwick(auto &&range) {
+            assign(range);
+        }
+        void to_prefix_sums() {
+            for(size_t i = 1; i < n; i++) {
+                if(i + (i & -i) <= n) {
+                    data[i + (i & -i)] += data[i];
+                }
+            }
+        }
+        void assign(auto &&range) {
+            n = size(range) - 1;
+            data = move(range);
+            to_prefix_sums();
+        }
+        void add(size_t x, T const& v) {
+            for(++x; x <= n; x += x & -x) {
+                data[x] += v;
+            }
+        }
+        // sum of [0, r)
+        T prefix_sum(size_t r) const {
+            assert(r <= n);
+            T res = 0;
+            for(; r; r -= r & -r) {
+                res += data[r];
+            }
+            return res;
+        }
+        // sum of [l, r)
+        T range_sum(size_t l, size_t r) const {
+            return prefix_sum(r) - prefix_sum(l);
+        }
+        // First r s.t. prefix_sum(r) >= k
+        // Assumes data[x] >= 0 for all x
+        size_t prefix_lower_bound(T k) const {
+            int x = 0;
+            for(size_t i = std::bit_floor(n); i; i /= 2) {
+                if(x + i <= n && data[x + i] < k) {
+                    k -= data[x + i];
+                    x += i;
+                }
+            }
+            return x;
+        }
+    };
+}
+#endif // CP_ALGO_STRUCTURES_FENWICK_HPP

cp-algo/data_structures/eertree.hpp renamed to cp-algo/structures/eertree.hpp

@@ -0,0 +1,51 @@
+#ifndef CP_ALGO_STRUCTURES_FENWICK_SET_HPP
+#define CP_ALGO_STRUCTURES_FENWICK_SET_HPP
+#include "fenwick.hpp"
+#include <bitset>
+namespace cp_algo::structures {
+    // fenwick-based set for [0, maxc)
+    template<size_t maxc>
+    struct fenwick_set: fenwick<int, std::array<int, maxc+1>> {
+        using Base = fenwick<int, std::array<int, maxc+1>>;
+        size_t sz = 0;
+        std::bitset<maxc> present;
+        fenwick_set(): Base(std::array<int, maxc+1>()) {}
+        fenwick_set(auto &&range): fenwick_set() {
+            for(auto x: range) {
+                Base::data[x + 1] = 1;
+                sz += !present[x];
+                present[x] = 1;
+            }
+            Base::to_prefix_sums();
+        }
+        void insert(size_t x) {
+            if(present[x]) return;
+            present[x] = 1;
+            sz++;
+            Base::add(x, 1);
+        }
+        void erase(size_t x) {
+            if(!present[x]) return;
+            present[x] = 0;
+            sz--;
+            Base::add(x, -1);
+        }
+        size_t order_of_key(size_t x) const {
+            return Base::prefix_sum(x);
+        }
+        size_t find_by_order(size_t order) const {
+            return order < sz ? Base::prefix_lower_bound(order + 1) : -1;
+        }
+        size_t lower_bound(size_t x) const {
+            if(present[x]) {return x;}
+            auto order = order_of_key(x);
+            return order < sz ? find_by_order(order) : -1;
+        }
+        size_t pre_upper_bound(size_t x) const {
+            if(present[x]) {return x;}
+            auto order = order_of_key(x);
+            return order ? find_by_order(order - 1) : -1;
+        }
+    };
+}
+#endif // CP_ALGO_STRUCTURES_FENWICK_SET_HPP