bitpack fixes

Author: adamant-pwn

cp-algo/structures/bit_array.hpp

@@ -2,15 +2,31 @@
 #define CP_ALGO_STRUCTURES_BIT_ARRAY_HPP
 #include "../util/bit.hpp"
 #include "../util/bump_alloc.hpp"
+#include <cassert>
 namespace cp_algo::structures {
+    template<typename C>
+    concept Resizable = requires(C& c, std::size_t n) { c.resize(n); };
+
     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() {}
+        void resize(size_t N) {
+            n = N;
+            words = (n + width - 1) / width;
+            if constexpr (Resizable<Cont>) {
+                data.resize(words);
+            } else {
+                assert(std::size(data) >= words);
+            }
+        }
+
+        _bit_array(): n(0), words(0), data() {}
+        _bit_array(size_t N): data() {
+            resize(N);
+        }
 
         uint64_t& word(size_t x) {
             return data[x];
@@ -47,9 +63,7 @@ namespace cp_algo::structures {
     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);
-        }
+        bit_array(): Base(N) {}
     };
     struct dynamic_bit_array: _bit_array<std::vector<uint64_t>> {
         using Base = _bit_array<std::vector<uint64_t>>;

cp-algo/structures/fenwick_set.hpp

@@ -3,17 +3,17 @@
 #include "fenwick.hpp"
 #include "bit_array.hpp"
 namespace cp_algo::structures {
-    template<size_t maxc, typename Uint = uint64_t>
-    using popcount_array = std::array<int, maxc / bit_width<Uint> + 1>;
+    template<size_t maxc>
+    using popcount_array = std::array<int, maxc / bit_width<uint64_t> + 1>;
     // fenwick-based set for [0, maxc)
-    template<size_t maxc, typename Uint = uint64_t>
-    struct fenwick_set: fenwick<int, popcount_array<maxc, Uint>> {
-        using Base = fenwick<int, popcount_array<maxc, Uint>>;
-        static constexpr size_t word = bit_width<Uint>;
+    template<size_t maxc>
+    struct fenwick_set: fenwick<int, popcount_array<maxc>> {
+        using Base = fenwick<int, popcount_array<maxc>>;
+        static constexpr size_t word = bit_width<uint64_t>;
         size_t sz = 0;
-        bit_array<maxc, Uint> bits;
+        bit_array<maxc> bits;
 
-        fenwick_set(): Base(popcount_array<maxc, Uint>{}) {}
+        fenwick_set(): Base(popcount_array<maxc>{}) {}
         fenwick_set(auto &&range): fenwick_set() {
             for(auto x: range) {
                 Base::data[x / word + 1] += 1;

verify/structures/bitpack/det_mod_2.test.cpp

@@ -2,7 +2,6 @@
 // @brief Determinant of Matrix (Mod 2)
 #define PROBLEM "https://judge.yosupo.jp/problem/matrix_det_mod_2"
 #pragma GCC optimize("Ofast,unroll-loops")
-#pragma GCC target("tune=native")
 #include "cp-algo/structures/bitpack.hpp"
 #include <bits/stdc++.h>
 
@@ -13,20 +12,20 @@ const int maxn = 1 << 12;
 bitpack<maxn> a[maxn];
 
 void solve() {
-    int n;
+    size_t n;
     cin >> n;
     string row;
     vector<size_t> lead(n);
-    for(int i = 0; i < n; i++) {
+    for(size_t i = 0; i < n; i++) {
         cin >> row;
         a[i] = row;
-        for(int j = 0; j < i; j++) {
+        for(size_t j = 0; j < i; j++) {
             if(a[i][lead[j]]) {
                 a[i].xor_hint(a[j], lead[j]);
             }
         }
         lead[i] = a[i].ctz();
-        if(lead[i] == maxn) {
+        if(lead[i] == n) {
             cout << 0 << "\n";
             return;
         }

verify/structures/bitpack/inv_mod_2.test.cpp

@@ -7,8 +7,8 @@
 using namespace std;
 using namespace cp_algo::structures;
 
-const int maxn = 1 << 13;
-bitpack<maxn> a[maxn];
+const int maxn = 1 << 12;
+bitpack<2 * maxn> a[maxn];
 
 void solve() {
     size_t n;
@@ -18,6 +18,7 @@ void solve() {
     for(size_t i = 0; i < n; i++) {
         cin >> row;
         a[i] = row;
+        a[i].resize(2 * n);
         a[i].set(n + i);
         for(size_t j = 0; j < i; j++) {
             if(a[i][lead[j]]) {