結果

問題 No.8030 ミラー・ラビン素数判定法のテスト
ユーザー Ryuhei Mori
提出日時 2017-10-31 15:25:11
言語 C
(gcc 13.3.0)
結果
AC  
実行時間 16 ms / 9,973 ms
コード長 4,609 bytes
コンパイル時間 217 ms
コンパイル使用メモリ 34,944 KB
実行使用メモリ 5,248 KB
最終ジャッジ日時 2024-11-16 23:04:27
合計ジャッジ時間 828 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge3
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
other AC * 10
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <unistd.h>
#include <stdint.h>
#include <math.h>


typedef __int128 int128_t;
typedef unsigned __int128 uint128_t;

char ibuf[300000];
char *ibufe = ibuf-1;
char buf[300000];
char *bufe = buf;

static inline void readall(){
  int k, t = 0;
  while((k=read(STDIN_FILENO, ibuf+t, sizeof(ibuf)-t))>0) t += k;
}

static inline uint64_t read_uintll(){
  uint64_t x=0;
  while(*(++ibufe) <'0');
  do {
    x *= 10;
    x += *ibufe-'0';
  } while(*(++ibufe) >='0');

  return x;
}

static inline uint64_t readwrite_uintll(){
  uint64_t x=0;
  while(*(++ibufe) <'0');
  do {
    x *= 10;
    x += *ibufe-'0';
    *bufe++ = *ibufe;
  } while(*(++ibufe) >='0');
  *bufe++ = ' ';

  return x;
}


static inline void write_bitln(int x){
  *bufe++ = '0'+x;
  *bufe++ = '\n';
}

static inline void writeall(){
  int k, t = 0;
  while((k=write(STDOUT_FILENO, buf+t, bufe-buf-t))>0) t += k;
}


static inline uint64_t ex_gcd(uint64_t y){
  int i;
  uint64_t u, v;
  u = 1; v = 0;
  uint64_t x = 1LL<<63;

  for(i=0;i<64;i++){
    if(u&1){
      u = (u + y) / 2;
      v = v/2 + x;
    }
    else {
      u >>= 1; v >>= 1;
    }
  }

  return v;
} 


static inline uint64_t MR(uint128_t x, uint64_t m, uint64_t n){
  uint64_t z = ((uint128_t) ((uint64_t) x * m) * n + x) >> 64;
  return z < n ? z : z - n;
}

static inline uint64_t RM(uint64_t x, uint64_t r2, uint64_t m, uint64_t n){
  return MR((uint128_t) r2 * x, m, n);
}

static inline uint64_t mulmod64(uint64_t x, uint64_t y, uint64_t m, uint64_t n){
  return MR((uint128_t) x*y, m, n);
}


static inline uint64_t modpowtwo64(uint64_t two, uint64_t k, uint64_t m, uint64_t n){
  uint64_t l = k << (__builtin_clzll(k)+1);
  for(;l;l<<=1){
    two = mulmod64(two, two, m, n);
    if(l>>63){
      two <<= 1;
      if(two>=n) two -= n;
    }
  }
  for(;!(k&1);k>>=1){
    two = mulmod64(two, two, m, n);
  }

  return two;
}

int jacobi(int64_t a, uint64_t n){
  uint64_t t;
  int j = 1;
  while(a){
    if(a<0){
      a = -a;
      if((n&3)==3) j = -j;
    }
    int ba = __builtin_ctzll(a);
    a >>= ba;
    if(((n&7)==3||(n&7)==5) && (ba&1)) j = -j;
    if((a&n&3)==3) j = -j;
    t = a; a = n; n = t;
    a %= n;
    if(a>n/2) a-=n;
  }
  return n == 1 ? j : 0;
}


static inline uint64_t addmod64(uint64_t x, uint64_t y, uint64_t n){
  return x + y >= n ? x + y - n : x + y;
}

static inline uint64_t submod64(uint64_t x, uint64_t y, uint64_t n){
  return x >= y  ? x - y : x - y + n;
}



int is_prime64(const uint64_t n){
//  static const uint32_t ps[] = {3, 7, 11, 13, 17, 19};
  int i, j, r;
  uint64_t d;
  if(n <= 1) return 0;
  if(n <= 3) return 1;
  if(!(n & 1)) return 0;

/*
  for(i=0;i<sizeof(ps)/sizeof(ps[0]);i++){
    if(n==ps[i]) return 1;
    if(n%ps[i] == 0) return 0;
  }
*/

  const uint64_t one = -1ULL % n + 1;
  const uint64_t r2 = (uint128_t) (int128_t) -1 % n + 1;
  const uint64_t m = ex_gcd(n);

  {
    uint64_t two, t, mone;
    r = __builtin_ctzll(n-1);
    d = (n-1) >> r;
    mone = n - one;
    two = one << 1;
    if(two >= n) two -= n;
    t = modpowtwo64(two, d, m, n);
    if(t != one){
      for(j=0;t!=mone;j++){
        if(j == r-1) return 0;
        t = MR((uint128_t) t * t, m, n);
  //      if(t == one) return 0;
      }
    }
  }


  {
    int64_t D = 5;
    for(i=0;jacobi(D, n) != -1 && i<64;i++){
      if(i==32){
        uint32_t k = round(sqrtl(n));
        if(k*k == n) return 0;
      }
      if(i&1) D -= 2;
      else D += 2;
      D = -D;
    }
//    if(i==64) puts("ERROR");

    uint64_t Q = RM(D < 0 ? (1-D)/4%n : n - (D-1)/4%n, r2, m, n);

    uint64_t u, v, Qn;
    uint64_t k = (n+1) << __builtin_clzll(n+1);
    u = one; v = one;
    Qn = Q;
    D %= (int64_t) n;
    D = RM(D < 0 ? n+D : D, r2, m, n);
    for(k<<=1;k;k<<=1){
      u = mulmod64(u,v,m,n);
      v = submod64(mulmod64(v,v,m,n), addmod64(Qn, Qn, n), n);
      Qn = mulmod64(Qn, Qn, m, n);
      if(k>>63){
        uint64_t uu = addmod64(u, v, n);
        if(uu&1) uu += n;
        uu >>= 1;
        uint64_t vv = addmod64(mulmod64(D,u,m,n), v, n);
        if(vv&1) vv += n;
        vv >>= 1;
        u = uu;
        v = vv;
        Qn = mulmod64(Qn, Q, m, n);
      }
    }

    if(u == 0 || v == 0) return 1;
    uint64_t s = n+1;
    for(s>>=1;!(s&1);s>>=1){
      u = mulmod64(u,v,m,n);
      v = submod64(mulmod64(v,v,m,n), addmod64(Qn, Qn, n), n);
      if(v == 0) return 1;
      Qn = mulmod64(Qn, Qn, m, n);
    }
  }

  return 0;
}



int main(){
  int i, n;


  readall();
  n = read_uintll();
  for(i=0;i<n;i++){
    uint64_t x;
    x = readwrite_uintll();
    write_bitln(is_prime64(x));
  }
  writeall();
  return 0;
}
0