Improve bitpack, support dynamic

Author: adamant-pwn

cp-algo/structures/bit_array.hpp

@@ -1,31 +1,63 @@
 #ifndef CP_ALGO_STRUCTURES_BIT_ARRAY_HPP
 #define CP_ALGO_STRUCTURES_BIT_ARRAY_HPP
 #include "../util/bit.hpp"
+#include "../util/bump_alloc.hpp"
 namespace cp_algo::structures {
-    template<size_t N, typename Uint = uint64_t>
-    struct bit_array {
-        static constexpr size_t width = bit_width<Uint>;
-        static constexpr size_t blocks = N / width + 1;
-        std::array<Uint, blocks> data = {};
+    template<class Cont>
+    struct _bit_array {
+        static constexpr size_t width = bit_width<uint64_t>;
+        size_t words, n;
+        alignas(32) Cont data;
 
+        _bit_array(): words(0), n(0) {}
+        _bit_array(size_t N): words((N + width - 1) / width), n(N), data() {}
+
+        uint64_t& word(size_t x) {
+            return data[x];
+        }
         uint64_t word(size_t x) const {
             return data[x];
         }
         void set(size_t x) {
-            data[x / width] |= 1ULL << (x % width);
+            word(x / width) |= 1ULL << (x % width);
         }
         void reset(size_t x) {
-            data[x / width] &= ~(1ULL << (x % width));
+            word(x / width) &= ~(1ULL << (x % width));
+        }
+        void reset() {
+            for(auto& w: data) {
+                w = 0;
+            }
         }
         void flip(size_t x) {
-            data[x / width] ^= 1ULL << (x % width);
+            word(x / width) ^= 1ULL << (x % width);
         }
         bool test(size_t x) const {
-            return (data[x / width] >> (x % width)) & 1;
+            return (word(x / width) >> (x % width)) & 1;
         }
         bool operator[](size_t x) const {
             return test(x);
         }
+        size_t size() const {
+            return n;
+        }
     };
+
+    template<int N>
+    struct bit_array: _bit_array<std::array<uint64_t, (N + 63) / 64>> {
+        using Base = _bit_array<std::array<uint64_t, (N + 63) / 64>>;
+        using Base::Base, Base::words, Base::data;
+        bit_array(): Base(N) {
+            data.fill(0);
+        }
+    };
+    struct dynamic_bit_array: _bit_array<std::vector<uint64_t>> {
+        using Base = _bit_array<std::vector<uint64_t>>;
+        using Base::Base, Base::words;
+        dynamic_bit_array(size_t N): Base(N) {
+            data.resize(words);
+        }
+    };
+
 }
 #endif // CP_ALGO_STRUCTURES_BIT_ARRAY_HPP

cp-algo/structures/bitpack.hpp

@@ -7,38 +7,36 @@
 #include <string>
 #include <array>
 namespace cp_algo::structures {
-    template<size_t n>
-    struct bitpack: bit_array<n, uint64_t> {
-        using Base = bit_array<n, uint64_t>;
-        using Base::width, Base::blocks, Base::data;
-        using Base::set, Base::reset;
-        auto operator <=> (bitpack const& t) const = default;
+    template<typename BitArray>
+    struct _bitpack: BitArray {
+        using Base = BitArray;
+        using Base::Base, Base::width, Base::words, Base::data, Base::n, Base::word;
+        auto operator <=> (_bitpack const& t) const = default;
 
-        bitpack() {}
-        bitpack(std::string &bits) {
-            bits.resize((size(bits) + width - 1) / width * width);
-            for(size_t i = 0; i < blocks; i++) {
-                data[i] = read_bits64(bits.data() + i * width);
+        _bitpack(std::string &bits): _bitpack(std::size(bits)) {
+            bits += std::string(-std::size(bits) % width, '0');
+            for(size_t i = 0; i < words; i++) {
+                word(i) = read_bits64(bits.data() + i * width);
             }
         }
 
-        bitpack& xor_hint(bitpack const& t, size_t hint) {
-            for(size_t i = hint / width; i < blocks; i++) {
+        _bitpack& xor_hint(_bitpack const& t, size_t hint) {
+            for(size_t i = hint / width; i < std::size(data); i++) {
                 data[i] ^= t.data[i];
             }
             return *this;
         }
-        bitpack& operator ^= (bitpack const& t) {
+        _bitpack& operator ^= (_bitpack const& t) {
             return xor_hint(t, 0);
         }
-        bitpack operator ^ (bitpack const& t) const {
-            return bitpack(*this) ^= t;
+        _bitpack operator ^ (_bitpack const& t) const {
+            return _bitpack(*this) ^= t;
         }
 
         std::string to_string() const {
-            std::string res(blocks * width, '0');
-            for(size_t i = 0; i < blocks; i++) {
-                write_bits64(res.data() + i * width, data[i]);
+            std::string res(words * width, '0');
+            for(size_t i = 0; i < words; i++) {
+                write_bits64(res.data() + i * width, word(i));
             }
             res.resize(n);
             return res;
@@ -47,15 +45,19 @@ namespace cp_algo::structures {
         size_t ctz() const {
             size_t res = 0;
             size_t i = 0;
-            while(i < blocks && data[i] == 0) {
+            while(i < words && word(i) == 0) {
                 res += width;
                 i++;
             }
-            if(i < blocks) {
-                res += std::countr_zero(data[i]);
+            if(i < words) {
+                res += std::countr_zero(word(i));
             }
             return std::min(res, n);
         }
     };
+
+    template<int N>
+    using bitpack = _bitpack<bit_array<N>>;
+    using dynamic_bitpack = _bitpack<dynamic_bit_array>;
 }
 #endif // CP_ALGO_STRUCTURES_BITPACK_HPP

verify/structures/bitpack/prod_mod_2.test.cpp

@@ -7,52 +7,59 @@
 #include <bits/stdc++.h>
 
 using namespace std;
-using cp_algo::structures::bitpack;
 
 const int maxn = 1 << 12;
-bitpack<maxn> a[maxn], b[maxn], c[maxn];
-const int K = 8;
-bitpack<maxn> precalc[1 << K];
+const size_t K = 8;
+
+using bitpack = cp_algo::structures::bitpack<maxn>;
+
+bitpack a[maxn], b[maxn], c[maxn];
+bitpack precalc[1 << K];
 
 void process_precalc(int i) {
-    for(auto &it: precalc) {
-        it = bitpack<maxn>();
-    }
-    for(int j = 0; j < K; j++) {
+    for(size_t j = 0; j < K; j++) {
         int step = 1 << j;
         for(int k = 0; k < step; k++) {
-            precalc[k + step] = precalc[k] ^ b[K * i + j];
+            precalc[k + step] = precalc[k] ^ b[i + j];
         }
     }
 }
 
 void solve() {
-    cp_algo::checkpoint("init");
     int n, m, k;
     cin >> n >> m >> k;
+    cp_algo::checkpoint("init");
     string row;
     for(int i = 0; i < n; i++) {
         cin >> row;
         a[i] = row;
     }
+    for(auto &it: b) {
+        it = bitpack(k);
+    }
     for(int i = 0; i < m; i++) {
         cin >> row;
         b[i] = row;
     }
+    for(auto &it: c) {
+        it = bitpack(k);
+    }
+    for(auto &it: precalc) {
+        it = bitpack(k);
+    }
     cp_algo::checkpoint("read");
-    const int width = bitpack<maxn>::width;
+    const int width = bitpack::width;
     for(int j = 0; j < m; j += width) {
-        for(int z = 0; z < width / K; z++) {
-            process_precalc(j / K + z);
+        for(int offset = 0; offset < width; offset += K) {
+            process_precalc(j + offset);
             for(int i = 0; i < n; i++) {
-                c[i] ^= precalc[uint8_t(a[i].word(j / width) >> K * z)];
+                c[i] ^= precalc[uint8_t(a[i].word(j / width) >> offset)];
             }
         }
     }
     cp_algo::checkpoint("mul");
     for(int i = 0; i < n; i++) {
-        row = c[i].to_string().substr(0, k);
-        cout << row << "\n";
+        cout << c[i].to_string() << "\n";
     }
     cp_algo::checkpoint("write");
     cp_algo::checkpoint<1>();