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

提出ソース

結果

問題	No.3030 ミラー・ラビン素数判定法のテスト
ユーザー	nonamae
提出日時	2022-08-22 23:40:29
言語	C (gcc 12.3.0)
結果	AC
実行時間	16 ms / 9,973 ms
コード長	13,292 bytes
コンパイル時間	804 ms
コンパイル使用メモリ	41,652 KB
実行使用メモリ	5,248 KB
最終ジャッジ日時	2024-11-16 23:54:34
合計ジャッジ時間	1,459 ms
ジャッジサーバーID （参考情報）	judge3 / judge5

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
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	12 ms 5,248 KB
testcase_05	AC	12 ms 5,248 KB
testcase_06	AC	11 ms 5,248 KB
testcase_07	AC	10 ms 5,248 KB
testcase_08	AC	11 ms 5,248 KB
testcase_09	AC	16 ms 5,248 KB

権限があれば一括ダウンロードができます

コンパイルメッセージ

main.c: In function 'in_i32':
main.c:104:94: warning: implicit declaration of function 'getchar_unlocked' [-Wimplicit-function-declaration]
  104 | 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; }
      |                                                                                              ^~~~~~~~~~~~~~~~
main.c: In function 'out_i32_inner':
main.c:105:79: warning: implicit declaration of function 'putchar_unlocked' [-Wimplicit-function-declaration]
  105 | static inline void out_i32_inner(i32 x) { if (x >= 10) out_i32_inner(x / 10); putchar_unlocked(x - x / 10 * 10 + 48); }
      |                                                                               ^~~~~~~~~~~~~~~~

ソースコード

raw source code

// clang-format off
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("omit-frame-pointer")
#pragma GCC optimize("inline")
#pragma GCC option("arch=native")
#pragma GCC option("no-zero-upper")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#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;

/// (3, 7) -> 3
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
/// (4, 5) -> 5
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
/// (1, 2) -> (2, 1)
#define SWAP_REF(a, b)      \
            do {            \
                (a) ^= (b); \
                (b) ^= (a); \
                (a) ^= (b); \
            }               \
            while(0);

/// {0, 1, 2, 3, 4, ...} -> {0, 1, 1, 2, 1, ...}
#define POPCNT32(a) ((a) ? __builtin_popcount((a)) : (0))
/// {0, 1, 2, 4, 8, ...} -> {32, 0, 1, 2, 3, ...}
#define CTZ32(a) ((a) ? __builtin_ctz((a)) : 32)
/// {0, 1, 2, 4, 8, ...} -> {32, 31, 30, 29, 28, ...}
#define CLZ32(a) ((a) ? __builtin_clz((a)) : 32)
/// {0, 1, 2, 3, 4, ...} -> {0, 1, 1, 2, 1, ...}
#define POPCNT64(a) ((a) ? __builtin_popcountll((a)) : (0))
/// {0, 1, 2, 4, 8, ...} -> {64, 0, 1, 2, 3, ...}
#define CTZ64(a) ((a) ? __builtin_ctzll((a)) : 64)
/// {0, 1, 2, 4, 8, ...} -> {64, 63, 62, 61, 60, ...}
#define CLZ64(a) ((a) ? __builtin_clzll((a)) : 64)
/// {0, 1, 2, 4, 8, ...} -> {-1, 0, 1, 2, 3, ...}
#define MSB32(a) ((a) ? ((31) - __builtin_clz((a))) : (-1))
/// {0, 1, 2, 4, 8, ...} -> {-1, 0, 1, 2, 3, ...}
#define MSB64(a) ((a) ? ((63) - __builtin_clzll((a))) : (-1))
/// {1, 2, 3, 4, 5, ...} -> {1, 2, 1, 4, 1, ...}
#define LSBit(a) ((a) & (-(a)))
/// {1, 2, 3, 4, 5, ...} -> {0, 0, 2, 0, 4, ...}
#define CLSBit(a) ((a) & ((a) - (1)))
/// {1, 2, 3, 4, 5, ...} -> {1, 2, 2, 4, 4, ...}
#define BIT_FLOOR32(a) ((a) ? (1u) << MSB32((a)) : (0))
/// {6, 7, 8, 9, 10, ...} -> {4, 4, 8, 8, 8, ...}
#define BIT_FLOOR64(a) ((a) ? (1ull) << MSB64((a)) : (0))
/// {1, 2, 3, 4, 5, ...} -> {1, 2, 4, 4, 8, ...}
#define BIT_CEIL32_REF(a)           \
            do {                    \
                --(a);              \
                (a) |= (a) >> (1);  \
                (a) |= (a) >> (2);  \
                (a) |= (a) >> (4);  \
                (a) |= (a) >> (8);  \
                (a) |= (a) >> (16); \
                (a)++;              \
            } while(0);
/// {8, 9, 10, 11, 12, ...} -> {8, 16, 16, 16, 16, ...}
#define BIT_CEIL64_REF(a)           \
            do {                    \
                --(a);              \
                (a) |= (a) >> (1);  \
                (a) |= (a) >> (2);  \
                (a) |= (a) >> (4);  \
                (a) |= (a) >> (8);  \
                (a) |= (a) >> (16); \
                (a) |= (a) >> (32); \
                (a)++;              \
            } while(0);
#define ROTL32_INNER(x, l) (((x) << (l)) | ((x) >> ((-l) & (31))))
#define ROTR32_INNER(x, r) (((x) >> (r)) | ((x) << ((-r) & (31))))
#define ROTR32(x, r) (((r) < (0)) ? (ROTL32_INNER((x), ((u64)(-r) % (32)))) : (ROTR32_INNER((x), ((r) % (32)))))
#define ROTL32(x, l) ROTR32((x), (-l))
#define ROTL64_INNER(x, l) (((x) << (l)) | ((x) >> ((-l) & (63))))
#define ROTR64_INNER(x, r) (((x) >> (r)) | ((x) << ((-r) & (63))))
#define ROTR64(x, r) (((r) < (0)) ? (ROTL64_INNER((x), ((u64)(-r) % (64)))) : (ROTR64_INNER((x), ((r) % (64)))))
#define ROTL64(x, l) ROTR64((x), (-l))

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); }
// clang-format on

static u64 lcg_state = 14534622846793005ull;
u32 lcg_rand(void)
{
    return lcg_state = 6364136223846793005ull * lcg_state + 1442695040888963407ull;
}
u32 lcg_range(u32 l, u32 r) { return l + lcg_rand() % (r - l + 1); }

int jacobi_symbol(i64 a, u64 n)
{
    u64 t;
    int j = 1;
    while (a) {
        if (a < 0) {
            a = -a;
            if ((n & 3) == 3)
                j = -j;
        }
        int s = __builtin_ctzll(a);
        a >>= s;
        if (((n & 7) == 3 || (n & 7) == 5) && (s & 1))
            j = -j;
        if ((a & n & 3) == 3)
            j = -j;
        t = a, a = n, n = t;
        a %= n;
        if ((u64)(a) > n / 2)
            a -= n;
    }
    return n == 1 ? j : 0;
}

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) { return A + B >= mod ? A + B - mod : A + B; }
m64 sub_m64(m64 A, m64 B, u64 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);
}

bool is_prime(u64 n)
{
    {
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;
        if (!(n & 1))
            return false;
    }
    const u64 mod = n;
    const m64 one = one_m64(n);
    const m64 r2 = r2_m64(n);
    const m64 N = N_m64(n);
    {
        u64 d = (mod - 1) << __builtin_clzll(mod - 1);
        m64 t = one << 1;
        if (t >= mod)
            t -= mod;
        for (d <<= 1; d; d <<= 1) {
            t = mul_m64(t, t, N, mod);
            if (d >> 63) {
                t <<= 1;
                if (t >= mod)
                    t -= mod;
            }
        }
        if (t != one) {
            u64 x = LSBit(mod - 1);
            m64 rev = mod - one;
            for (x >>= 1; t != rev; x >>= 1) {
                if (x == 0)
                    return false;
                t = mul_m64(t, t, N, mod);
            }
        }
    }
    {
        i64 D = 5;
        for (int i = 0; jacobi_symbol(D, n) != -1 && i < 64; ++i) {
            if (i == 32) {
                u32 k = round(sqrtl(n));
                if (k * k == n)
                    return false;
            }
            if (i & 1)
                D -= 2;
            else
                D += 2;
            D = -D;
        }
        m64 Q = to_m64(D < 0 ? (1 - D) / 4 % mod : mod - (D - 1) / 4 % mod, r2, N,
                       mod);
        m64 u = one, v = one, Qn = Q;
        u64 k = (n + 1) << __builtin_clzll(n + 1);
        D %= (i64)mod;
        D = to_m64(D < 0 ? mod + D : D, r2, N, mod);
        for (k <<= 1; k; k <<= 1) {
            u = mul_m64(u, v, N, mod);
            v = sub_m64(mul_m64(v, v, N, mod), add_m64(Qn, Qn, mod), mod);
            Qn = mul_m64(Qn, Qn, N, mod);
            if (k >> 63) {
                u64 uu = add_m64(u, v, mod);
                if (uu & 1)
                    uu += mod;
                uu >>= 1;
                v = add_m64(mul_m64(D, u, N, mod), v, mod);
                if (v & 1)
                    v += mod;
                v >>= 1;
                u = uu;
                Qn = mul_m64(Qn, Q, N, mod);
            }
        }
        if (u == 0 || v == 0)
            return true;
        u64 x = (n + 1) & ~n;
        for (x >>= 1; x; x >>= 1) {
            u = mul_m64(u, v, N, mod);
            v = sub_m64(mul_m64(v, v, N, mod), add_m64(Qn, Qn, mod), mod);
            if (v == 0)
                return true;
            Qn = mul_m64(Qn, Qn, N, mod);
        }
    }
    return false;
}

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

yukicoder

結果

テストケース

コンパイルメッセージ

ソースコード