結果
| 問題 | No.3030 ミラー・ラビン素数判定法のテスト |
| ユーザー |
 nonamae
|
| 提出日時 | 2022-08-22 23:27:16 |
| 言語 | C (gcc 12.3.0) |
| 結果 |
WA
|
| 実行時間 | - |
| コード長 | 11,275 bytes |
| コンパイル時間 | 525 ms |
| コンパイル使用メモリ | 38,912 KB |
| 実行使用メモリ | 6,948 KB |
| 最終ジャッジ日時 | 2024-04-18 13:32:23 |
| 合計ジャッジ時間 | 1,252 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge4 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 1 ms
6,812 KB |
| testcase_01 | AC | 1 ms
6,940 KB |
| testcase_02 | AC | 1 ms
6,944 KB |
| testcase_03 | AC | 1 ms
6,940 KB |
| testcase_04 | WA | - |
| testcase_05 | WA | - |
| testcase_06 | WA | - |
| testcase_07 | WA | - |
| testcase_08 | WA | - |
| testcase_09 | WA | - |
コンパイルメッセージ
main.c: In function 'in_i32':
main.c:95:94: warning: implicit declaration of function 'getchar_unlocked' [-Wimplicit-function-declaration]
95 | 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:96:79: warning: implicit declaration of function 'putchar_unlocked' [-Wimplicit-function-declaration]
96 | static inline void out_i32_inner(i32 x) { if (x >= 10) out_i32_inner(x / 10); putchar_unlocked(x - x / 10 * 10 + 48); }
| ^~~~~~~~~~~~~~~~
ソースコード
// clang-format off
#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 r_m64(u64 mod)
{
m64 ret = mod;
for (int _ = 0; _ < 5; ++_) {
ret *= 2 - mod * ret;
}
return ret;
}
m64 n2_m64(u64 mod) { return -(u128)(mod) % mod; }
m64 one_m64(u64 mod) { return (u64)-1ull % mod + 1; }
m64 reduce_m64(u128 b, m64 r, u64 mod)
{
return (b + (u128)((u64)(b) * (u64)(-r)) * mod) >> 64;
}
m64 to_m64(u64 a, m64 r, m64 n2, u64 mod)
{
return reduce_m64(((u128)a + mod) * n2, r, mod);
}
u64 from_m64(m64 a, m64 r, u64 mod)
{
u64 ret = reduce_m64((u128)a, r, mod);
return ret >= mod ? ret - mod : ret;
}
m64 add_m64(m64 a, m64 b, u64 mod)
{
if ((i64)(a += b - 2 * mod) < 0)
a += 2 * mod;
return a;
}
m64 sub_m64(m64 a, m64 b, u64 mod)
{
if ((i64)(a -= b) < 0)
a += 2 * mod;
return a;
}
m64 min_m64(m64 a, u64 mod) { return sub_m64(0, a, mod); }
m64 mul_m64(m64 a, m64 b, m64 r, u64 mod) { return reduce_m64((u128)a * b, r, mod); }
m64 pow_m64(m64 a, u64 k, m64 r, m64 one, u64 mod)
{
m64 ret = one;
m64 mul = a;
while (k > 0) {
if (k & 1)
ret = mul_m64(ret, mul, r, mod);
mul = mul_m64(mul, mul, r, mod);
k >>= 1;
}
return ret;
}
m64 inv_m64(m64 a, m64 r, m64 one, u64 mod)
{
return pow_m64(a, mod - 2, r, one, mod);
}
m64 div_m64(m64 a, m64 b, m64 r, m64 one, u64 mod)
{
return mul_m64(a, inv_m64(b, r, one, mod), r, mod);
}
bool eq_m64(m64 a, m64 b, u64 mod)
{
return (a >= mod ? a - mod : a) == (b >= mod ? b - mod : b);
}
bool neq_m64(m64 a, m64 b, u64 mod)
{
return (a >= mod ? a - mod : a) != (b >= mod ? b - mod : b);
}
m64 in_m64(m64 r, m64 n2, u64 mod)
{
u64 c;
u64 x = 0;
while (c = getchar_unlocked(), c < 48 || c > 57)
;
while (47 < c && c < 58) {
x = x * 10 + c - 48;
c = getchar_unlocked();
};
return to_m64(x, r, n2, mod);
}
void out_m64(m64 a, m64 r, u64 mod)
{
u64 x = from_m64(a, r, mod);
out_u32(x);
}
bool is_prime(u64 n)
{
{
if (n <= 1)
return false;
if (n <= 3)
return true;
if (!(n & 1))
return false;
}
u64 mod = n;
m64 r = r_m64(mod);
m64 n2 = n2_m64(mod);
m64 one = one_m64(mod);
m64 rev = to_m64(n - 1, r, n2, mod);
{
for (int _ = 0; _ < 15; ++_) {
u32 a = lcg_range(2u, ((n - 1) > ((1ull << 32) - 1)) ? 1u << 31 : n - 1);
int x = jacobi_symbol(a, n);
m64 y = (x == -1) ? rev : ((x == 0) ? 0 : one);
if (y == 0 ||
y != pow_m64(to_m64(a, r, n2, mod), (n - 1) / 2, r, one, mod))
return false;
}
}
return true;
}
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;
}