Primitive root test

Author: adamant-pwn

cp-algo/algebra/modint.hpp

@@ -85,7 +85,7 @@ namespace cp_algo::algebra {
         using Base::Base;
 
         // Wrapper for temp switching
-        auto static with_switched_mod(int64_t tmp, auto callback) {
+        auto static with_mod(int64_t tmp, auto callback) {
             auto prev = mod();
             switch_mod(tmp);
             if constexpr(std::is_void_v<std::invoke_result_t<decltype(callback)>>) {

cp-algo/algebra/number_theory.hpp

@@ -48,7 +48,7 @@ namespace cp_algo::algebra {
             }
             return x == -1;
         };
-        return base::with_switched_mod(m, [&](){
+        return base::with_mod(m, [&](){
             // Works for all m < 2^64: https://miller-rabin.appspot.com
             return std::ranges::all_of(std::array{
                 2, 325, 9375, 28178, 450775, 9780504, 1795265022
@@ -64,7 +64,7 @@ namespace cp_algo::algebra {
             res.push_back(m);
         } else if(m > 1) {
             using base = dynamic_modint;
-            base::with_switched_mod(m, [&]() {
+            base::with_mod(m, [&]() {
                 base t = random::rng();
                 auto f = [&](auto x) {
                     return x * x + t;
@@ -90,10 +90,29 @@ namespace cp_algo::algebra {
             });
         }
     }
-    auto factorize(int64_t m) {
+    std::vector<int64_t> factorize(int64_t m) {
         std::vector<int64_t> res;
         factorize(m, res);
         return res;
     }
+    int64_t primitive_root(int64_t p) {
+        using base = dynamic_modint;
+        return base::with_mod(p, [p](){
+            auto fact = factorize(p - 1);
+            auto is_primitive_root = [&](base x) {
+                for(auto t: fact) {
+                    if(bpow(x, (p - 1) / t) == 1) {
+                        return false;
+                    }
+                }
+                return true;
+            };
+            base t = 1;
+            while(!is_primitive_root(t)) {
+                t = random::rng();
+            }
+            return t.getr();
+        });
+    }
 }
 #endif // CP_ALGO_ALGEBRA_NUMBER_THEORY_HPP

verify/number_theory/primitive_root.test.cpp

@@ -0,0 +1,28 @@
+// @brief Primitive Root
+#define PROBLEM "https://judge.yosupo.jp/problem/primitive_root"
+#pragma GCC optimize("Ofast,unroll-loops")
+#pragma GCC target("avx2,tune=native")
+#include "cp-algo/algebra/number_theory.hpp"
+#include <bits/stdc++.h>
+
+using namespace std;
+using namespace cp_algo;
+using namespace algebra;
+using base = dynamic_modint;
+
+void solve() {
+    int64_t p;
+    cin >> p;
+    cout << primitive_root(p) << "\n";
+}
+
+signed main() {
+    //freopen("input.txt", "r", stdin);
+    ios::sync_with_stdio(0);
+    cin.tie(0);
+    int t = 1;
+    cin >> t;
+    while(t--) {
+        solve();
+    }
+}