結果

問題 No.187 中華風 (Hard)
ユーザー onakasuitacityonakasuitacity
提出日時 2021-02-28 18:54:02
言語 PyPy3
(7.3.15)
結果
WA  
実行時間 -
コード長 3,253 bytes
コンパイル時間 195 ms
コンパイル使用メモリ 81,920 KB
実行使用メモリ 88,960 KB
最終ジャッジ日時 2024-10-02 21:52:07
合計ジャッジ時間 5,258 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge5
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 109 ms
87,680 KB
testcase_01 AC 107 ms
87,424 KB
testcase_02 AC 210 ms
88,704 KB
testcase_03 AC 211 ms
88,448 KB
testcase_04 AC 196 ms
88,448 KB
testcase_05 AC 195 ms
88,448 KB
testcase_06 AC 195 ms
88,704 KB
testcase_07 AC 196 ms
88,448 KB
testcase_08 AC 148 ms
87,808 KB
testcase_09 AC 151 ms
87,552 KB
testcase_10 AC 152 ms
87,680 KB
testcase_11 AC 201 ms
88,704 KB
testcase_12 AC 198 ms
88,448 KB
testcase_13 AC 124 ms
87,552 KB
testcase_14 AC 141 ms
87,808 KB
testcase_15 AC 215 ms
88,832 KB
testcase_16 AC 204 ms
88,960 KB
testcase_17 AC 108 ms
87,424 KB
testcase_18 AC 111 ms
87,424 KB
testcase_19 AC 105 ms
87,168 KB
testcase_20 AC 181 ms
88,448 KB
testcase_21 AC 115 ms
87,424 KB
testcase_22 AC 201 ms
88,576 KB
testcase_23 WA -
testcase_24 AC 112 ms
87,296 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()

from math import gcd
from collections import Counter

def _primality_test(n):
    d = (n - 1) // ((n - 1) & -(n - 1))
    s = ((n - 1) // d).bit_length()
    for a in (2, 7, 61) if n < 4_759_123_141 else (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37):
        y = pow(a, d, n)
        if y == 1:
            continue
        for _ in range(s):
            if y == n - 1:
                break
            y = y * y % n
        else:
            return False
    return True

N = 1_000_000
primes = []
sieve = list(range(N + 1))
for i in range(2, N + 1):
    if sieve[i] == i:
        primes.append(i)
    for p in primes:
        if sieve[i] < p or i * p > N:
            break
        sieve[i * p] = p

def prime_factorization(n):
    res = Counter()
    queue = [n]
    for n in queue:
        if n < len(sieve):
            while n > 1:
                res[sieve[n]] += 1
                n //= sieve[n]
            continue
        if _primality_test(n):
            res[n] += 1
            continue
        c, m = 0, 1 << n.bit_length() - 3
        while True:
            c += 1
            y = g = q = r = 1
            while g == 1:
                x, k = y, 0
                for _ in range(r):
                    y = (y * y + c) % n
                while k < r and g == 1:
                    ys = y
                    for i in range(min(m, r - k)):
                        y = (y * y + c) % n
                        q = q * abs(x - y) % n
                    g = gcd(q, n)
                    k += m
                r <<= 1
            if g == n:
                g = 1
                while g == 1:
                    ys = (ys * ys + c) % n
                    g = gcd(abs(x - ys), n)
            if g != n:
                queue.append(g)
                queue.append(n // g)
                break
    return res

def modinv(a, m):
    b, u, v = m, 1, 0
    while b:
        a, b, u, v = b, a - a // b * b, v, u - a // b * v
    return u % m

def garner(B, M):
    T = []
    for b, m in zip(B, M):
        x, c = 0, 1
        for t, _m in zip(T[::-1], M[len(T)-1::-1]):
            x = (x * _m + t) % m
            c = c * _m  % m
        T.append((b - x) * modinv(c, m) % m)
    return T

def crt(B, M):
    X = {} # p -> (e, b) s.t. x = b mod p^e
    for b, m in zip(B, M):
        for p, e in prime_factorization(m).items():
            if p in X:
                _e, _b = X[p]
                if (b - _b) % (p ** min(e, _e)):
                    return [], []
                if e > _e:
                    X[p] = (e, b)
            else:
                X[p] = (e, b)
    B, M = [], []
    for p, v in X.items():
        e, b = v
        B.append(b)
        M.append(p ** e)
    return garner(B, M), M

def resolve():
    n = int(input())
    B, M = [0] * n, [0] * n
    for i in range(n):
        B[i], M[i] = map(int, input().split())

    T, M = crt(B, M)
    if not T:
        print(-1)
        return

    ans = 0
    for t, m in zip(T[::-1], M[::-1]):
        ans = (ans * m + t) % MOD
    if ans == 0:
        ans = 1
        for m in M:
            ans = ans * m % MOD
    print(ans)
resolve()
0