fixed some tests

Author: lrvideckis

tests/library_checker_aizu_tests/data_structures/range_parallel_dsu.test.cpp

@@ -4,23 +4,19 @@
 #include "../template.hpp"
 #include "../../../library/data_structures/dsu/range_parallel_dsu.hpp"
 #include "../../../library/data_structures/dsu/range_parallel_equivalence_classes.hpp"
-#include "../../../library/math/mod_int.hpp"
+const int mod = 998244353;
 int main() {
   cin.tie(0)->sync_with_stdio(0);
   int n, q;
   cin >> n >> q;
   rp_dsu dsu(n);
-  vector<mint> y(n);
-  for (int i = 0; i < n; i++) {
-    int num;
-    cin >> num;
-    y[i] = num;
-  }
-  vector<mint> x = y;
-  mint ans = 0;
+  vi y(n);
+  for (int i = 0; i < n; i++) cin >> y[i];
+  vi x = y;
+  int ans = 0;
   auto f = [&](int u, int v) {
-    ans = ans + x[u] * x[v];
-    x[u] = x[u] + x[v];
+    ans = (ans + 1LL * x[u] * x[v]) % mod;
+    x[u] = (x[u] + x[v]) % mod;
   };
   vector<array<int, 3>> queries;
   queries.reserve(q);
@@ -29,18 +25,19 @@ int main() {
     cin >> k >> a >> b;
     dsu.join(a, b, k, f);
     queries.push_back({a, b, k});
-    cout << ans.x << '\n';
+    cout << ans << '\n';
     if (qq == 0 || qq == 1 || qq == 10 || qq == 1000 ||
       qq == 100'000 || qq == q - 1) {
       auto uf = get_rp_dsu(queries, n);
-      vector<mint> sums(n);
-      mint offline_ans = 0;
+      vi sums(n);
+      int offline_ans = 0;
       for (int i = 0; i < n; i++) {
         int id = uf.find(i);
-        offline_ans = offline_ans + sums[id] * y[i];
-        sums[id] = sums[id] + y[i];
+        offline_ans =
+          (offline_ans + 1LL * sums[id] * y[i]) % mod;
+        sums[id] = (sums[id] + y[i]) % mod;
       }
-      assert(ans.x == offline_ans.x);
+      assert(ans == offline_ans);
     }
   }
   return 0;

tests/library_checker_aizu_tests/graphs/offline_incremental_scc.test.cpp

@@ -3,13 +3,13 @@
 #include "../template.hpp"
 #include "../../../library/graphs/strongly_connected_components/offline_incremental_scc.hpp"
 #include "../../../library/data_structures/dsu/dsu.hpp"
-#include "../../../library/math/mod_int.hpp"
+const int mod = 998244353;
 int main() {
   cin.tie(0)->sync_with_stdio(0);
   int n, m;
   cin >> n >> m;
-  vector<mint> xs(n);
-  for (int i = 0; i < n; i++) cin >> xs[i].x;
+  vector<int> xs(n);
+  for (int i = 0; i < n; i++) cin >> xs[i];
   vector<array<int, 2>> eds(m);
   for (auto& [u, v] : eds) cin >> u >> v;
   auto joins = offline_incremental_scc(eds, n);
@@ -21,22 +21,22 @@ int main() {
   ranges::sort(all(order), {},
     [&](int i) { return joins[i]; });
   DSU dsu(n);
-  mint sum = 0;
+  int sum = 0;
   for (int t = 0, it = 0; t < m; t++) {
     while (it < m && joins[order[it]] <= t) {
       auto [u, v] = eds[order[it]];
       u = dsu.go(u);
       v = dsu.go(v);
       if (dsu.e[u] > dsu.e[v]) swap(u, v);
       if (u != v) {
-        sum = sum + xs[u] * xs[v];
-        xs[u] = xs[u] + xs[v];
+        sum = (sum + 1LL * xs[u] * xs[v]) % mod;
+        xs[u] = (xs[u] + xs[v]) % mod;
         xs[v] = xs[u];
       }
       dsu.join(u, v);
       it++;
     }
-    cout << sum.x << '\n';
+    cout << sum << '\n';
   }
   return 0;
 }

tests/library_checker_aizu_tests/handmade_tests/edge_cd_small_trees.test.cpp

@@ -3,7 +3,6 @@
 #include "../template.hpp"
 #include "../edge_cd_asserts.hpp"
 #include "../../../kactl/stress-tests/utilities/genTree.h"
-#include "../../../library/math/mod_int_pow.hpp"
 #include "../../../library/trees/edge_cd.hpp"
 int main() {
   {
@@ -21,7 +20,9 @@ int main() {
       });
   }
   for (int n = 2; n <= 7; n++) {
-    int num_codes = mpow(n, n - 2).x;
+    int num_codes = 1;
+    for (int k = 0; k < n - 2; k++) num_codes *= n;
+    // int num_codes = mpow(n, n - 2).x;
     vector<vector<int>> pruf_codes(num_codes,
       vector<int>(n - 2));
     for (int i = 0; i < num_codes; i++) {

tests/library_checker_aizu_tests/handmade_tests/mod_int.test.cpp

@@ -1,7 +1,6 @@
 #define PROBLEM \
   "https://judge.yosupo.jp/problem/gcd_convolution"
 #include "../template.hpp"
-#include "../../../library/math/mod_int.hpp"
 istream& operator>>(istream& is, vector<int>& v) {
   for (int i = 1; i < sz(v); i++) is >> v[i];
   return is;

tests/library_checker_aizu_tests/math/binary_exponentiation_mod.test.cpp

@@ -1,17 +1,12 @@
 #define PROBLEM \
   "https://judge.yosupo.jp/problem/binomial_coefficient_prime_mod"
 #include "../template.hpp"
-// trick to remove const so I can use arbitrary prime mode
-// here
-#define const ;
-#include "../../../library/math/mod_int.hpp"
-#undef const
 int main() {
   cin.tie(0)->sync_with_stdio(0);
-  int t;
+  int t, mod;
   cin >> t >> mod;
   const int mx_n = min(int(1e7), mod);
-  vector<mint> fact(mx_n, 1);
+  vector<int> fact(mx_n, 1);
   for (int i = 2; i < mx_n; i++) fact[i] = fact[i - 1] * i;
   vector<mint> inv_fact(mx_n, 1);
   inv_fact.back() = mint(1) / fact.back();

tests/library_checker_aizu_tests/math/mod_int_derangement.test.cpp

@@ -2,11 +2,6 @@
   "https://judge.yosupo.jp/problem/tetration_mod"
 #include "../template.hpp"
 #include "../../../library/math/totient.hpp"
-// trick to remove const so I can use arbitrary prime mode
-// here
-#define const ;
-#include "../../../library/math/mod_int_pow.hpp"
-#undef const
 int mod_int_tetration(int b, int e, int local_mod) {
   if (local_mod == 1) return 0;
   if (b == 0) return (e + 1) % 2 % local_mod;

tests/library_checker_aizu_tests/math/mod_int_gcd_convolution.test.cpp

@@ -3,18 +3,19 @@
 #undef _GLIBCXX_DEBUG
 #include "../template.hpp"
 #include "../../../library/trees/shallowest_decomp_tree.hpp"
-#include "../../../library/math/mod_int.hpp"
-using line = array<mint, 2>;
+const int mod = 998244353;
+using line = array<int, 2>;
 // returns f(g(x)) = f[0]*(g[0]*x+g[1]) + f[1]
 line compose(line f, line g) {
-  return {f[0] * g[0], f[1] + f[0] * g[1]};
+  return {int(1LL * f[0] * g[0] % mod),
+    int((f[1] + 1LL * f[0] * g[1]) % mod)};
 }
 int main() {
   cin.tie(0)->sync_with_stdio(0);
   int n;
   cin >> n;
-  vector<mint> a(n);
-  for (int i = 0; i < n; i++) cin >> a[i].x;
+  vector<int> a(n);
+  for (int i = 0; i < n; i++) cin >> a[i];
   vector<vector<int>> adj(n);
   vector<vector<line>> weight(n);
   for (int i = 0; i < n - 1; i++) {
@@ -25,30 +26,36 @@ int main() {
     weight[u].push_back({b, c});
     weight[v].push_back({b, c});
   }
-  vector<mint> res(n);
-  for (int i = 0; i < n; i++) res[i] = a[i];
+  vector<int> res(a);
   shallowest(adj, [&](int cent) {
     assert(ssize(adj[cent]) == ssize(weight[cent]));
-    mint total_sum_evaluated = 0;
+    int total_sum_evaluated = 0;
     int total_cnt_nodes = 0;
-    mint curr_sum_evaluated = 0;
+    int curr_sum_evaluated = 0;
     int curr_cnt_nodes = 0;
     auto dfs = [&](auto&& self, int v, int p,
                  line downwards, line upwards,
                  bool forwards) -> void {
       // f(x) + f(y) + f(z) = b*x+c + b*y+c + b*z+c =
       // b*(x+y+z) + c*3
-      res[v] = res[v] + upwards[0] * total_sum_evaluated +
-        upwards[1] * total_cnt_nodes;
+      res[v] =
+        (res[v] + 1LL * upwards[0] * total_sum_evaluated +
+          1LL * upwards[1] * total_cnt_nodes) %
+        mod;
       if (forwards) {
-        res[v] =
-          res[v] + upwards[0] * a[cent] + upwards[1];
+        res[v] = (res[v] + 1LL * upwards[0] * a[cent] +
+                   upwards[1]) %
+          mod;
         res[cent] =
-          res[cent] + downwards[0] * a[v] + downwards[1];
+          (res[cent] + 1LL * downwards[0] * a[v] +
+            downwards[1]) %
+          mod;
       }
       curr_cnt_nodes++;
-      curr_sum_evaluated = curr_sum_evaluated +
-        downwards[0] * a[v] + downwards[1];
+      curr_sum_evaluated =
+        (curr_sum_evaluated + 1LL * downwards[0] * a[v] +
+          downwards[1]) %
+        mod;
       for (int i = 0; i < ssize(adj[v]); i++) {
         int u = adj[v][i];
         line curr_line = weight[v][i];
@@ -64,7 +71,7 @@ int main() {
       dfs(dfs, adj[cent][i], cent, weight[cent][i],
         weight[cent][i], 1);
       total_sum_evaluated =
-        total_sum_evaluated + curr_sum_evaluated;
+        (total_sum_evaluated + curr_sum_evaluated) % mod;
       total_cnt_nodes += curr_cnt_nodes;
     }
     total_sum_evaluated = 0;
@@ -75,7 +82,7 @@ int main() {
       dfs(dfs, adj[cent][i], cent, weight[cent][i],
         weight[cent][i], 0);
       total_sum_evaluated =
-        total_sum_evaluated + curr_sum_evaluated;
+        (total_sum_evaluated + curr_sum_evaluated) % mod;
       total_cnt_nodes += curr_cnt_nodes;
     }
     for (int v : adj[cent]) {
@@ -88,6 +95,6 @@ int main() {
       }
     }
   });
-  for (int i = 0; i < n; i++) cout << res[i].x << ' ';
+  for (int i = 0; i < n; i++) cout << res[i] << ' ';
   cout << '\n';
 }