#783739 (C) No.3030 ミラー・ラビン素数判定法のテスト

提出ソース
結果

問題	No.3030 ミラー・ラビン素数判定法のテスト
ユーザー	nonamae
提出日時	2022-08-02 03:16:47
言語	C (gcc 12.3.0)
結果	AC
実行時間	25 ms / 9,973 ms
コード長	13,027 bytes
コンパイル時間	797 ms
コンパイル使用メモリ	45,616 KB
実行使用メモリ	5,248 KB
最終ジャッジ日時	2024-11-16 23:51:16
合計ジャッジ時間	1,441 ms
ジャッジサーバーID （参考情報）	judge5 / judge3
このコードへのチャレンジ
（要ログイン）
テストケース

テストケース表示
入力	結果	実行時間実行使用メモリ
testcase_00	AC	1 ms 5,248 KB
testcase_01	AC	1 ms 5,248 KB
testcase_02	AC	1 ms 5,248 KB
testcase_03	AC	1 ms 5,248 KB
testcase_04	AC	16 ms 5,248 KB
testcase_05	AC	15 ms 5,248 KB
testcase_06	AC	8 ms 5,248 KB
testcase_07	AC	7 ms 5,248 KB
testcase_08	AC	8 ms 5,248 KB
testcase_09	AC	25 ms 5,248 KB
権限があれば一括ダウンロードができます
ソースコード

raw source code
#pragma region template
#pragma GCC target("avx2")
#pragma GCC optimize("O3")

#define _GNU_SOURCE
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <time.h>

typedef   int8_t      i8;
typedef   int16_t     i16;
typedef   int32_t     i32;
typedef   int64_t     i64;
typedef __int128_t    i128;
typedef   uint8_t     u8;
typedef   uint16_t    u16;
typedef   uint32_t    u32;
typedef   uint64_t    u64;
typedef __uint128_t   u128;
typedef   float       f32;
typedef   double      f64;
typedef   long double f80;

#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#define SWAP(a, b) (((a) ^= (b)), ((b) ^= (a)), ((a) ^= (b)))
#define POPCNT32(a) __builtin_popcount((a))
#define POPCNT64(a) __builtin_popcountll((a))
#define CTZ32(a) __builtin_ctz((a))
#define CLZ32(a) __builtin_clz((a))
#define CTZ64(a) __builtin_ctzll((a))
#define CLZ64(a) __builtin_clzll((a))
#define HAS_SINGLE_BIT32(a) (__builtin_popcount((a)) == (1))
#define HAS_SINGLE_BIT64(a) (__builtin_popcountll((a)) == (1))
#define MSB32(a) ((31) - __builtin_clz((a)))
#define MSB64(a) ((63) - __builtin_clzll((a)))
#define BIT_WIDTH32(a) ((a) ? ((32) - __builtin_clz((a))) : (0))
#define BIT_WIDTH64(a) ((a) ? ((64) - __builtin_clzll((a))) : (0))
#define LSBit(a) ((a) & (-(a)))
#define CLSBit(a) ((a) & ((a) - (1)))

static inline u64 get_bit_floor(u64 n) { if (n) return 1ull << (63 - __builtin_clzll(n)); return 0; }
static inline u64 get_bit_ceil(u64 n) { assert(n > 0); --n; n |= n >> 1; n |= n >> 2; n |= n >> 4; n |= n >> 8; n |= n >> 16; n |= n >> 32; ++n; return n; }
static inline u32 get_log2(u64 n) { assert(HAS_SINGLE_BIT64(n)); const u32 deBruijn[64] = {0,1,2,53,3,7,54,27,4,38,41,8,34,55,48,28,62,5,39,46,44,42,22,9,24,35,59,56,49,18,29,11,63,52,6,26,37,40,33,47,61,45,43,21,23,58,17,10,51,25,36,32,60,20,57,16,50,31,19,15,30,14,13,12}; return deBruijn[n * 0x022fdd63cc95386dull >> 58]; }
static inline u32 rotr32(u32 x, i64 r) { if (r < 0) { u64 l = ((u64)(-r)) % 32; return x << l | x >> (-l & 31); } r %= 32; return x >> r | x << (-r & 31); }
static inline u64 rotr64(u64 x, i64 r) { if (r < 0) { u64 l = ((u64)(-r)) % 64; return x << l | x >> (-l & 63); } r %= 64; return x >> r | x << (-r & 63); }
static inline u32 rotl32(u32 x, i64 r) { return rotr32(x, -r); }
static inline u64 rotl64(u64 x, i64 r) { return rotr64(x, -r); }
static inline int deBruijn_log2(u64 n) { static const u64 deBruijn = 0x022fdd63cc95386d; static const int convert[64] = {0, 1, 2, 53, 3, 7, 54, 27, 4, 38, 41, 8, 34, 55, 48, 28, 62, 5, 39, 46, 44, 42, 22, 9, 24, 35, 59, 56, 49, 18, 29, 11, 63, 52, 6, 26, 37, 40, 33, 47, 61, 45, 43, 21, 23, 58, 17, 10, 51, 25, 36, 32, 60, 20, 57, 16, 50, 31, 19, 15, 30, 14, 13, 12}; return convert[n * deBruijn >> 58]; }
static inline int bsf(u64 n) { return deBruijn_log2(n & ~(n - 1)); }

i32 in_i32(void) {/* -2147483648 ～ 2147483647 (> 10 ^ 9) */ i32 c, x = 0, f = 1; while (c = getchar_unlocked(), c < 48 || c > 57) if (c == 45) f = -f; while (47 < c && c < 58) { x = x * 10 + c - 48; c = getchar_unlocked(); } return f * x; }
static inline void out_i32_inner(i32 x) { if (x >= 10) out_i32_inner(x / 10); putchar_unlocked(x - x / 10 * 10 + 48); }
void out_i32(i32 x) { if (x < 0) { putchar_unlocked('-'); x = -x; } out_i32_inner(x); }
i64 in_i64(void) {/* -9223372036854775808 ～ 9223372036854775807 (> 10 ^ 18) */ i64 c, x = 0, f = 1; while (c = getchar_unlocked(), c < 48 || c > 57) if (c == 45) f = -f; while (47 < c && c < 58) { x = x * 10 + c - 48; c = getchar_unlocked(); } return f * x; }
static inline void out_i64_inner(i64 x) { if (x >= 10) out_i64_inner(x / 10); putchar_unlocked(x - x / 10 * 10 + 48); }
void out_i64(i64 x) { if (x < 0) { putchar_unlocked('-'); x = -x; } out_i64_inner(x); }
u32 in_u32(void) {/* 0 ～ 4294967295 (> 10 ^ 9) */ u32 c, x = 0; while (c = getchar_unlocked(), c < 48 || c > 57); while (47 < c && c < 58) { x = x * 10 + c - 48; c = getchar_unlocked(); } return x; }
void out_u32(u32 x) { if (x >= 10) out_u32(x / 10); putchar_unlocked(x - x / 10 * 10 + 48); }
u64 in_u64(void) {/* 0 ～ 18446744073709551615 (> 10 ^ 19) */ u64 c, x = 0; while (c = getchar_unlocked(), c < 48 || c > 57); while (47 < c && c < 58) { x = x * 10 + c - 48; c = getchar_unlocked(); } return x; }
void out_u64(u64 x) { if (x >= 10) out_u64(x / 10); putchar_unlocked(x - x / 10 * 10 + 48); }
void NL(void) { putchar_unlocked('\n'); }
void SP(void) { putchar_unlocked(' '); }

void dump_int(int x) { fprintf(stderr, "\033[1;36m%d\033[0m\n", x); }
void dump_i64(i64 x) { fprintf(stderr, "\033[1;36m%ld\033[0m\n", x); }
void dump_u32(u32 x) { fprintf(stderr, "\033[1;36m%u\033[0m\n", x); }
void dump_u64(u64 x) { fprintf(stderr, "\033[1;36m%lu\033[0m\n", x); }
void dump_int_array(int *a, int a_len) { for (int i = 0; i < a_len; i++) { if (i == a_len - 1) { fprintf(stderr, "\033[1;36m%d\033[0m\n", a[i]); } else { fprintf(stderr, "\033[1;36m%d\033[0m ", a[i]); } } }
void dump_i64_array(i64 *a, int a_len) { for (int i = 0; i < a_len; i++) { if (i == a_len - 1) { fprintf(stderr, "\033[1;36m%ld\033[0m\n", a[i]); } else { fprintf(stderr, "\033[1;36m%ld\033[0m ", a[i]); } } }
void dump_u32_array(u32 *a, int a_len) { for (int i = 0; i < a_len; i++) { if (i == a_len - 1) { fprintf(stderr, "\033[1;36m%u\033[0m\n", a[i]); } else { fprintf(stderr, "\033[1;36m%u\033[0m ", a[i]); } } }
void dump_u64_array(u64 *a, int a_len) { for (int i = 0; i < a_len; i++) { if (i == a_len - 1) { fprintf(stderr, "\033[1;36m%lu\033[0m\n", a[i]); } else { fprintf(stderr, "\033[1;36m%lu\033[0m ", a[i]); } } }
void dump_int_array_range(int *a, int a_len, int l, int r) { if (a_len <= r) { r = a_len - 1; } if (l > r) { return; } for (int i = l; i <= r; i++) { if (i == r) { fprintf(stderr, "\033[1;36m%d\033[0m\n", a[i]); } else { fprintf(stderr, "\033[1;36m%d\033[0m ", a[i]); } } }
void dump_i64_array_range(i64 *a, int a_len, int l, int r) { if (a_len <= r) { r = a_len - 1; } if (l > r) { return; } for (int i = l; i <= r; i++) { if (i == r) { fprintf(stderr, "\033[1;36m%ld\033[0m\n", a[i]); } else { fprintf(stderr, "\033[1;36m%ld\033[0m ", a[i]); } } }
void dump_u32_array_range(u32 *a, int a_len, int l, int r) { if (a_len <= r) { r = a_len - 1; } if (l > r) { return; } for (int i = l; i <= r; i++) { if (i == r) { fprintf(stderr, "\033[1;36m%u\033[0m\n", a[i]); } else { fprintf(stderr, "\033[1;36m%u\033[0m ", a[i]); } } }
void dump_u64_array_range(u64 *a, int a_len, int l, int r) { if (a_len <= r) { r = a_len - 1; } if (l > r) { return; } for (int i = l; i <= r; i++) { if (i == r) { fprintf(stderr, "\033[1;36m%lu\033[0m\n", a[i]); } else { fprintf(stderr, "\033[1;36m%lu\033[0m ", a[i]); } } }
void printb_32bit(u32 v) { u32 mask = (u32)1 << (sizeof(v) * CHAR_BIT - 1); do { putchar_unlocked(mask & v ? '1' : '0'); } while (mask >>= 1); }
void printb_64bit(u64 v) { u64 mask = (u64)1 << (sizeof(v) * CHAR_BIT - 1); do { putchar_unlocked(mask & v ? '1' : '0'); } while (mask >>= 1); }
#pragma endregion template



///////////////////////////////////////////////////////////////////////////////
/// m32.c                                                                   ///
///////////////////////////////////////////////////////////////////////////////
typedef uint32_t m32;
m32 one_m32(u32 mod) { return (u32)-1u % mod + 1; }
m32 r2_m32(u32 mod) { return (u64)(i64)-1 % mod + 1; }
m32 N_m32(u32 mod) { u32 N = mod; for (int i = 0; i < 4; ++i) N *= 2 - mod * N; return N; }
m32 reduce_m32(u64 a, m32 N, u32 mod) { u32 y = (u32)(a >> 32) - (u32)(((u64)((u32)a * N) * mod) >> 32); return (i32)y < 0 ? y + mod : y; }
m32 to_m32(u32 a, m32 r2, m32 N, u32 mod) { return reduce_m32((u64)a * r2, N, mod); }
u32 from_m32(m32 A, m32 N, u32 mod) { return reduce_m32(A, N, mod); }
m32 add_m32(m32 A, m32 B, u32 mod) { if (A >= mod) A %= mod; if (B >= mod) B %= mod; A += B - (mod << 1u); A += (mod << 1u) & -(A >> 31u); return A; }
m32 sub_m32(m32 A, m32 B, u32 mod) { if (A >= mod) A %= mod; if (B >= mod) B %= mod; A -= B; A += (mod << 1u) & -(A >> 31u); return A; }
m32 min_m32(m32 A, u32 mod) { return sub_m32(0u, A, mod); }
m32 mul_m32(m32 A, m32 B, m32 N, u32 mod) { return reduce_m32((u64)A * B, N, mod); }
m32 pow_m32(m32 A, i32 n, m32 one, m32 N, u32 mod) { m32 ret = one, a = A; while (n > 0) { if (n & 1) ret = mul_m32(ret, a, N, mod); a = mul_m32(a, a, N, mod); n >>= 1; } return ret; }
m32 inv_m32(m32 A, m32 one, m32 N, u32 mod) { return pow_m32(A, (i32)mod - 2, one, N, mod); }
m32 div_m32(m32 A, m32 B, m32 one, m32 N, u32 mod) { /* assert(is_prime(mod)); */ return mul_m32(A, inv_m32(B, N, one, mod), N, mod); }
bool eq_m32(m32 A, m32 B, m32 N, u32 mod) { return from_m32(A, N, mod) == from_m32(B, N, mod); }
bool neq_m32(m32 A, m32 B, m32 N, u32 mod) { return from_m32(A, N, mod) != from_m32(B, N, mod); }
m32 in_m32(m32 r2, m32 N, u32 mod) { u32 c, a = 0; while (c = getchar(), c < 48 || c > 57); while (47 < c && c < 58) { a = a * 10 + c - 48; c = getchar(); } return to_m32(a, r2, N, mod); }
void out_m32(m32 A, m32 N, u32 mod) { u32 a = from_m32(A, N, mod); out_u32(a); }


///////////////////////////////////////////////////////////////////////////////
/// m64.c                                                                   ///
///////////////////////////////////////////////////////////////////////////////
typedef uint64_t m64;
m64 one_m64(u64 mod) { return (u64)-1ull % mod + 1; }
m64 r2_m64(u64 mod) { return (u128)(i128)-1 % mod + 1; }
m64 N_m64(u64 mod) { m64 N = mod; for (int i = 0; i < 5; i++) { N *= 2 - N * mod; } return N; }
m64 reduce_m64(u128 a, m64 N, u64 mod) { u64 y = (u64)(a >> 64) - (u64)(((u128)((u64)a * N) * mod) >> 64); return (i64)y < 0 ? y + mod : y; }
m64 to_m64(u64 a, m64 r2, m64 N, u64 mod) { return reduce_m64((u128)a * r2, N, mod); }
u64 from_m64(m64 A, m64 N, u64 mod) { return reduce_m64((u128)A, N, mod); }
m64 add_m64(m64 A, m64 B, u64 mod) { if (A >= mod) A %= mod; if (B >= mod) B %= mod; return A + B >= mod ? A + B - mod : A + B; }
m64 sub_m64(m64 A, m64 B, u64 mod) { if (A >= mod) A %= mod; if (B >= mod) B %= mod; return A >= B ? A - B : mod + A - B; }
m64 min_m64(m64 A, u64 mod) { return sub_m64(0ull, A, mod); }
m64 mul_m64(m64 A, m64 B, m64 N, u64 mod) { return reduce_m64((u128)A * B, N, mod); }
m64 pow_m64(m64 A, i64 n, m64 one, m64 N, u64 mod) { m64 ret = one; while (n > 0) { if (n & 1) ret = mul_m64(ret, A, N, mod); A = mul_m64(A, A, N, mod); n >>= 1; } return ret; }
m64 inv_m64(m64 A, m64 one, m64 N, u64 mod) { return pow_m64(A, (i64)mod - 2, one, N, mod); }
m64 div_m64(m64 A, m64 B, m64 one, m64 N, u64 mod) { /* assert(is_prime(mod)); */ return mul_m64(A, inv_m64(B, one, N, mod), N, mod); }
bool eq_m64(m64 A, m64 B, m64 N, u64 mod) { return from_m64(A, N, mod) == from_m64(B, N, mod); }
bool neq_m64(m64 A, m64 B, m64 N, u64 mod) { return from_m64(A, N, mod) != from_m64(B, N, mod); }
m64 in_m64(m64 r2, m64 N, u64 mod) { u64 c = 0; u64 a = 0; while (c = getchar(), c < 48 || c > 57); while (47 < c && c < 58) { a = a * 10 + c - 48; c = getchar(); } return to_m64(a, r2, N, mod); }
void out_m64(m64 A, m64 N, u64 mod) { u64 a = from_m64(A, N, mod); out_u64(a); }

///////////////////////////////////////////////////////////////////////////////
/// Miller-Rabin.c                                                          ///
///////////////////////////////////////////////////////////////////////////////
bool miller_rabin(u64 n) {
    {
        if (n <= 1) return false;
        if (n <= 3) return true;
        if (!(n & 1)) return false;
    }
    if (n < (1ull << 30)) {
        u32 m   = (u32)n - 1;
        m32 one = one_m32(n);
        m32 r2  = r2_m32(n);
        m32 N   = N_m32(n);
        m32 rev = to_m32(m, r2, N, n);
        u32 d   = m >> __builtin_ctz(m);
        u32 base[] = { 2u, 7u, 61u };
        for (int i = 0; i < 3; ++i) {
            if (n <= base[i]) break;
            u32 t = d;
            m32 y = pow_m32(to_m32(base[i], r2, N, n), t, one, N, n);
            while (t != m && y != one && y != rev) {
                y = mul_m32(y, y, N, n);
                t <<= 1;
            }
            if (y != rev && (!(t & 1))) return false;
        }
        return true;
    }
    u64 m   = n - 1;
    m64 one = one_m64(n);
    m64 r2  = r2_m64(n);
    m64 N   = N_m64(n);
    m64 rev = to_m64(m, r2, N, n);
    u64 d   = m >> __builtin_ctzll(m);
    u64 base[] = { 2ul, 325ul, 9375ul, 28178ul, 450775ul, 9780504ul, 1795265022ul };
    for (int i = 0; i < 7; ++i) {
      if (n <= base[i]) break;
      u64 t = d;
      m64 y = pow_m64(to_m64(base[i], r2, N, n), t, one, N, n);
      while (t != m && y != one && y != rev) {
        y = mul_m64(y, y, N, n);
        t <<= 1;
      }
      if (y != rev && (!(t & 1))) return false;
    }
    return true;
}


int main(void) {
    u64 Q = in_u64();
    while (Q--) {
        u64 x = in_u64();
        out_u64(x);
        SP();
        out_u32(miller_rabin(x) ? 1u : 0u);
        NL();
    }
    return 0;
}
yukicoder

結果

テストケース

ソースコード
