結果
| 問題 |
No.3273 Exactly One Match
|
| コンテスト | |
| ユーザー |
 lif4635
|
| 提出日時 | 2025-09-16 20:06:10 |
| 言語 | PyPy3 (7.3.15) |
| 結果 |
AC
|
| 実行時間 | 3,028 ms / 4,000 ms |
| コード長 | 21,040 bytes |
| コンパイル時間 | 316 ms |
| コンパイル使用メモリ | 82,240 KB |
| 実行使用メモリ | 308,340 KB |
| 最終ジャッジ日時 | 2025-09-16 20:06:47 |
| 合計ジャッジ時間 | 33,661 ms |
|
ジャッジサーバーID （参考情報） |
judge3 / judge4 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 3 |
| other | AC * 26 |
ソースコード
# input
import sys
input = sys.stdin.readline
II = lambda : int(input())
MI = lambda : map(int, input().split())
LI = lambda : [int(a) for a in input().split()]
SI = lambda : input().rstrip()
LLI = lambda n : [[int(a) for a in input().split()] for _ in range(n)]
LSI = lambda n : [input().rstrip() for _ in range(n)]
MI_1 = lambda : map(lambda x:int(x)-1, input().split())
LI_1 = lambda : [int(a)-1 for a in input().split()]
def graph(n:int, m:int, dir:bool=False, index:int=-1) -> list[set[int]]:
edge = [set() for i in range(n+1+index)]
for _ in range(m):
a,b = map(int, input().split())
a += index
b += index
edge[a].add(b)
if not dir:
edge[b].add(a)
return edge
def graph_w(n:int, m:int, dir:bool=False, index:int=-1) -> list[set[tuple]]:
edge = [set() for i in range(n+1+index)]
for _ in range(m):
a,b,c = map(int, input().split())
a += index
b += index
edge[a].add((b,c))
if not dir:
edge[b].add((a,c))
return edge
mod = 998244353
inf = 1001001001001001001
ordalp = lambda s : ord(s)-65 if s.isupper() else ord(s)-97
ordallalp = lambda s : ord(s)-39 if s.isupper() else ord(s)-97
yes = lambda : print("Yes")
no = lambda : print("No")
yn = lambda flag : print("Yes" if flag else "No")
def acc(a:list[int]):
sa = [0]*(len(a)+1)
for i in range(len(a)):
sa[i+1] = a[i] + sa[i]
return sa
prinf = lambda ans : print(ans if ans < 1000001001001001001 else -1)
alplow = "abcdefghijklmnopqrstuvwxyz"
alpup = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
alpall = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
URDL = {'U':(-1,0), 'R':(0,1), 'D':(1,0), 'L':(0,-1)}
DIR_4 = [[-1,0],[0,1],[1,0],[0,-1]]
DIR_8 = [[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1]]
DIR_BISHOP = [[-1,1],[1,1],[1,-1],[-1,-1]]
prime60 = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59]
sys.set_int_max_str_digits(0)
# sys.setrecursionlimit(10**6)
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
from collections import defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
DD = defaultdict
BSL = bisect_left
BSR = bisect_right
# https://github.com/atcoder/ac-library/blob/master/atcoder/convolution.hpp
from array import array
MOD = 998244353
IMAG = 911660635
IIMAG = 86583718
INV2 = 499122177
rate2 = array('I', [0, 911660635, 509520358, 369330050, 332049552, 983190778, 123842337, 238493703, 975955924, 603855026, 856644456, 131300601, 842657263, 730768835, 942482514, 806263778, 151565301, 510815449, 503497456, 743006876, 741047443, 56250497, 867605899, 0])
irate2 = array('I', [0, 86583718, 372528824, 373294451, 645684063, 112220581, 692852209, 155456985, 797128860, 90816748, 860285882, 927414960, 354738543, 109331171, 293255632, 535113200, 308540755, 121186627, 608385704, 438932459, 359477183, 824071951, 103369235, 0])
rate3 = array('I', [0, 372528824, 337190230, 454590761, 816400692, 578227951, 180142363, 83780245, 6597683, 70046822, 623238099, 183021267, 402682409, 631680428, 344509872, 689220186, 365017329, 774342554, 729444058, 102986190, 128751033, 395565204, 0])
irate3 = array('I', [0, 509520358, 929031873, 170256584, 839780419, 282974284, 395914482, 444904435, 72135471, 638914820, 66769500, 771127074, 985925487, 262319669, 262341272, 625870173, 768022760, 859816005, 914661783, 430819711, 272774365, 530924681, 0])
# https://judge.yosupo.jp/submission/55648
def butterfly(a: list):
n = len(a)
h = (n - 1).bit_length()
le = 0
while le < h:
if h - le == 1:
p = 1 << (h - le - 1)
rot = 1
for s in range(1 << le):
offset = s << (h - le)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p] * rot
a[i + offset] = (l + r) % MOD
a[i + offset + p] = (l - r) % MOD
rot *= rate2[(~s & -~s).bit_length()]
rot %= MOD
le += 1
else:
p = 1 << (h - le - 2)
rot = 1
for s in range(1 << le):
rot2 = rot * rot % MOD
rot3 = rot2 * rot % MOD
offset = s << (h - le)
for i in range(p):
a0 = a[i + offset]
a1 = a[i + offset + p] * rot
a2 = a[i + offset + p * 2] * rot2
a3 = a[i + offset + p * 3] * rot3
a1na3imag = (a1 - a3) % MOD * IMAG
a[i + offset] = (a0 + a2 + a1 + a3) % MOD
a[i + offset + p] = (a0 + a2 - a1 - a3) % MOD
a[i + offset + p * 2] = (a0 - a2 + a1na3imag) % MOD
a[i + offset + p * 3] = (a0 - a2 - a1na3imag) % MOD
rot *= rate3[(~s & -~s).bit_length()]
rot %= MOD
le += 2
def butterfly_inv(a: list):
n = len(a)
h = (n - 1).bit_length()
le = h
while le:
if le == 1:
p = 1 << (h - le)
irot = 1
for s in range(1 << (le - 1)):
offset = s << (h - le + 1)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p]
a[i + offset] = (l + r) % MOD
a[i + offset + p] = (l - r) * irot % MOD
irot *= irate2[(~s & -~s).bit_length()]
irot %= MOD
le -= 1
else:
p = 1 << (h - le)
irot = 1
for s in range(1 << (le - 2)):
irot2 = irot * irot % MOD
irot3 = irot2 * irot % MOD
offset = s << (h - le + 2)
for i in range(p):
a0 = a[i + offset]
a1 = a[i + offset + p]
a2 = a[i + offset + p * 2]
a3 = a[i + offset + p * 3]
a2na3iimag = (a2 - a3) * IIMAG % MOD
a[i + offset] = (a0 + a1 + a2 + a3) % MOD
a[i + offset + p] = (a0 - a1 + a2na3iimag) * irot % MOD
a[i + offset + p * 2] = (a0 + a1 - a2 - a3) * irot2 % MOD
a[i + offset + p * 3] = (a0 - a1 - a2na3iimag) * irot3 % MOD
irot *= irate3[(~s & -~s).bit_length()]
irot %= MOD
le -= 2
def intt(a):
if len(a) <= 1: return
butterfly_inv(a)
iv = pow(len(a), MOD - 2, MOD)
for i, x in enumerate(a): a[i] = x * iv % MOD
def multiply(s: list, t: list):
n = len(s)
m = len(t)
if min(n, m) <= 60:
a = [0] * (n + m - 1)
for i in range(n):
if i&0b111 == 0:
for j in range(m):
a[i + j] += s[i] * t[j]
a[i + j] %= MOD
else:
for j in range(m):
a[i + j] += s[i] * t[j]
return [x % MOD for x in a]
a = s.copy()
b = t.copy()
z = 1 << (n + m - 2).bit_length()
a += [0] * (z - n)
b += [0] * (z - m)
butterfly(a)
butterfly(b)
for i in range(z):
a[i] *= b[i]
a[i] %= MOD
butterfly_inv(a)
a = a[:n + m - 1]
iz = pow(z, MOD - 2, MOD)
return [v * iz % MOD for v in a]
def pow2(s: list):
n = len(s)
l = (n << 1) - 1
if n <= 60:
a = [0] * l
for i, x in enumerate(s):
for j, y in enumerate(s):
a[i + j] += x * y
return [x % MOD for x in a]
z = 1 << (l - 1).bit_length()
a = s + [0] * (z - n)
butterfly(a)
for i, x in enumerate(a): a[i] = x * x % MOD
butterfly_inv(a)
a[l:] = []
iz = pow(z, MOD - 2, MOD)
return [x * iz % MOD for x in a]
def shrink(a: list):
while a and not a[-1]: a.pop()
def fps_add(a: list, b: list):
if len(a) < len(b):
res = b.copy()
for i, x in enumerate(a):
res[i] += x
else:
res = a.copy()
for i, x in enumerate(b):
res[i] += x
return [x-MOD if MOD <= x else x for x in res]
def fps_sub(a: list, b: list):
if len(a) < len(b):
res = b.copy()
for i, x in enumerate(a):
res[i] -= x
return [MOD-x if 0 < x else -x for x in res]
else:
res = a.copy()
for i, x in enumerate(b):
res[i] -= x
return [x if 0 <= x else x+MOD for x in res]
def fps_neg(a: list):
return [MOD-x if x else 0 for x in a]
def fps_div(a: list, b: list) -> list:
if len(a) < len(b): return []
n = len(a) - len(b) + 1
cnt = 0
if len(b) > 64:
return multiply(a[::-1][:n], fps_inv(b[::-1], n))[:n][::-1]
f = a.copy()
g = b.copy()
while g and not g[-1]:
g.pop()
cnt += 1
coef = pow(g[-1], MOD - 2, MOD)
g = [x * coef % MOD for x in g]
deg = len(f) - len(g) + 1
lg = len(g)
res = [0] * deg
for i in reversed(range(deg)):
res[i] = x = f[i + lg - 1] % MOD
for j, y in enumerate(g):
f[i + j] -= x * y
return [x * coef % MOD for x in res] + [0] * cnt
def fps_mod(a: list, b: list) -> list:
res = fps_sub(a, multiply(fps_div(a, b), b))
while res and not res[-1]: res.pop()
return res
def fps_divmod(a: list, b: list):
q = fps_div(a, b)
r = fps_sub(a, multiply(q, b))
while r and not r[-1]: r.pop()
return q, r
def fps_eval(a: list, x: int) -> int:
r = 0
w = 1
for v in a:
r += w * v % MOD
w = w * x % MOD
return r % MOD
def fps_inv(a: list, deg: int=-1):
# assert(self[0] != 0)
if deg == -1: deg = len(a)
res = [0] * deg
res[0] = pow(a[0], MOD - 2, MOD)
d = 1
iv = INV2
while d < deg:
d2 = d << 1
f = [0] * d2
fl = min(len(a), d2)
f[:fl] = a[:fl]
g = [0] * d2
g[:d] = res[:d]
butterfly(g)
butterfly(f)
for i in range(d2): f[i] = f[i] * g[i] % MOD
butterfly_inv(f)
f[:d] = [0] * d
for i in range(d, d2): f[i] = f[i] * iv % MOD
butterfly(f)
for i in range(d2): f[i] = f[i] * g[i] % MOD
butterfly_inv(f)
for i in range(d, min(d2, deg)): res[i] = (MOD-f[i]) * iv % MOD
d <<= 1
iv = iv * INV2 % MOD
return res
def fps_pow(a: list, k: int, deg=-1) -> list:
n = len(a)
if deg == -1: deg = n
if k == 0:
if not deg: return []
res = [0] * deg
res[0] = 1
return res
for i, x in enumerate(a):
if x:
iz = pow(x, MOD - 2, MOD)
res = [x * iz % MOD for x in a[i:]]
res = fps_log(res, deg)
res = [x * k % MOD for x in res]
res = fps_exp(res, deg)
coef = pow(x, k, MOD)
res = [0] * (i * k) + [x * coef % MOD for x in res]
if len(res) < deg:
return res + [0] * (deg - len(res))
return res[:deg]
if (i + 1) * k >= deg: break
return [0] * deg
def fps_exp(a: list, deg: int=-1):
# assert a[0] == 0
if deg == -1: deg = len(a)
inv = [0, 1]
def inplace_integral(f: list) -> list:
n = len(f)
while len(inv) <= n:
j, k = divmod(MOD, len(inv))
inv.append((-inv[k] * j) % MOD)
return [0] + [x * inv[i + 1] % MOD for i, x in enumerate(f)]
b = [1, (a[1] if 1 < len(a) else 0)]
c = [1]
z1 = []
z2 = [1, 1]
m = 2
while m < deg:
y = b + [0] * m
butterfly(y)
z1 = z2
z = [y[i] * p % MOD for i, p in enumerate(z1)]
intt(z)
z[:m >> 1] = [0] * (m >> 1)
butterfly(z)
for i, p in enumerate(z1): z[i] = z[i] * (-p) % MOD
intt(z)
c[m >> 1:] = z[m >> 1:]
z2 = c + [0] * m
butterfly(z2)
tmp = min(len(a), m)
x = a[:tmp] + [0] * (m - tmp)
x = fps_diff(x)
x.append(0)
butterfly(x)
for i, p in enumerate(x): x[i] = y[i] * p % MOD
intt(x)
for i, p in enumerate(b):
if not i: continue
x[i - 1] -= p * i % MOD
x += [0] * m
for i in range(m - 1): x[m + i], x[i] = x[i], 0
butterfly(x)
for i, p in enumerate(z2): x[i] = x[i] * p % MOD
intt(x)
x.pop()
x = inplace_integral(x)
x[:m] = [0] * m
for i in range(m, min(len(a), m << 1)): x[i] += a[i]
butterfly(x)
for i, p in enumerate(y): x[i] = x[i] * p % MOD
intt(x)
b[m:] = x[m:]
m <<= 1
return b[:deg]
def fps_log(a: list, deg=-1) -> list:
# assert(a[0] == 1)
if deg == -1: deg = len(a)
return fps_integral(multiply(fps_diff(a), fps_inv(a, deg))[:deg - 1])
def fps_integral(a: list):
n = len(a)
res = [0] * (n + 1)
if n: res[1] = 1
for i in range(2, n + 1):
j, k = divmod(MOD, i)
res[i] = (-res[k] * j) % MOD
for i, x in enumerate(a): res[i + 1] = res[i + 1] * x % MOD
return res
def fps_diff(a: list):
return [i * x % MOD for i, x in enumerate(a) if i]
def LinearRecurrence(n: int, p: list, q: list):
"""
[x^n]P(x)/Q(x)
"""
# assert len(p) < len(q)
shrink(q)
while n:
q2 = q[:]
for i in range(1,len(q2),2): q2[i] = (-q2[i])%MOD
s = multiply(p,q2)
t = multiply(q,q2)
for i in range(n&1,len(s),2): p[i>>1] = s[i]
for i in range(0,len(t),2): q[i>>1] = t[i]
n >>= 1
return p[0] * pow(q[0], -1, MOD) % MOD
def fps_compsite(f: list, g: list):
"""
g(f(x)) mod x^(n+1)
"""
# assert len(f) == len(g)
def trans_multiply(s, t):
n = len(s)
m = len(t)
l = 1 << (max(n, m) - 1).bit_length()
a = s + [0] * (l - n)
b = t + [0] * (l - m)
a = [a[0]] + [a[l - i] for i in range(1, l)]
butterfly(a)
butterfly(b)
iz = pow(l, MOD-2, MOD)
for i, x in enumerate(b):
a[i] = a[i] * x % MOD * iz % MOD
butterfly_inv(a)
a = [a[0]] + [a[l - i] for i in range(1, l)]
return a[:n - m + 1]
n = len(f)
l = 1 << (n - 1).bit_length()
a = [MOD - x for x in f] + [0] * (2 * l - n)
b = g + [0] * (l - n)
def _inner(q, n, k):
if n == 1:
p = [0] * (2 * k)
p[0::2] = b[::-1]
return p
siz = 2 * n * k
r = [MOD - x if i & 1 else x for i,x in enumerate(q)]
qq = multiply(q, r)
qq.append(0)
for i in range(0, siz, 2):
qq[siz+i] = (qq[siz+i] + 2 * q[i]) % MOD
nq = [0] * siz
for j in range(2 * k):
for i in range(n >> 1):
nq[n * j + i] = qq[2 * n * j + 2 * i]
np = _inner(nq, n >> 1, k << 1)
pq = [0] * (2 * siz)
for j in range(2 * k):
for i in range(n >> 1):
pq[2 * n * j + 2 * i + 1] = np[n * j + i]
p = [pq[siz + i] for i in range(siz)]
pq.pop()
x = trans_multiply(pq, r)
p = [(p[i] + x[i]) % MOD for i in range(siz)]
return p
p = _inner(a, l, 1)
p = p[l-1::-1]
return p[:n]
def fps_compsitional_inv(calc, deg):
"""
input
calc(g, d) = f(g(x)) mod x^d を計算する
fps_compsite よりも良い計算量のものが存在するならば書く
output
g(x) mod x^deg s.t. f(g(x)) = x
"""
c = deg.bit_length()
g = calc([0, 1], 2)
g[1] = pow(g[1], -1, MOD)
d = 2
for i in range(c):
d <<= 1
fg = calc(g, d + 1)
fdg = multiply(fps_diff(fg), fps_inv(fps_diff(g)))
fdg[d:] = []
fg[1] -= 1
g = fps_sub(g, multiply(fg, fps_inv(fdg)))
g[d:] = []
g[deg:] = []
return g
INVMOD = [1,1]
def SubsetSum(d: list) -> list:
"""
\prod ( 1 + x^i ) ^ d[i]
d[w] = 重さ w が d[w] 種類 1 個ずつある
r[w] = 重さが w になるような選び方
"""
n = len(d)
for i in range(len(INVMOD), n):
INVMOD.append(-INVMOD[MOD%i] * (MOD//i) % MOD)
res = [0] * n
sgn = [-1, 1]
for i in range(1, n):
if d[i]:
tmp = d[i] * i
for j in range(i, n, i):
res[j] += tmp * INVMOD[j] * sgn[(j//i)&1] % MOD
res = fps_exp(res, n)
return res
def MultisetSum(d: list) -> list:
"""
\prod ( 1 / ( 1 - x^i ) ) ^ d[i]
d[w] = 重さ w が d[w] 種類 inf 個ずつある
r[w] = 重さが w になるような選び方
"""
n = len(d)
for i in range(len(INVMOD), n):
INVMOD.append(-INVMOD[MOD%i] * (MOD//i) % MOD)
res = [0] * n
for i in range(1, n):
if d[i]:
tmp = d[i] * i
for j in range(i, n, i):
res[j] += tmp * INVMOD[j] % MOD
res = fps_exp(res, n)
return res
fac = [1, 1]
finv = [1, 1]
def tayler_shift(a: list, c: int) -> list:
global fac, finv
n = len(a)
l = len(fac)
fac += [0] * (n - l)
finv += [0] * (n - l)
for i in range(l, n):
fac[i] = fac[i-1] * i % MOD
finv[n-1] = pow(fac[n-1], MOD-2, MOD)
for i in reversed(range(l, n-1)):
finv[i] = finv[i+1] * (i+1) % MOD
r = [x * fac[i] % MOD for i, x in enumerate(a)]
b = [0] * n
b[0] = 1
for i in range(1, n):
b[i] = b[i-1] * c % MOD * finv[i] % MOD * fac[i-1] % MOD
r.reverse()
res = multiply(r, b)[:n]
return [x * finv[i] % MOD for i, x in enumerate(reversed(res))]
def _fft2d(s: list[list]):
h, w = len(s), len(s[0])
for i in range(h):
butterfly(s[i])
buf = [0] * h
for j in range(w):
buf = [s[i][j] for i in range(h)]
butterfly(buf)
for i in range(h):
s[i][j] = buf[i]
def _ifft2d(s: list[list]):
h, w = len(s), len(s[0])
buf = [0] * h
for j in range(w):
buf = [s[i][j] for i in range(h)]
intt(buf)
for i in range(h):
s[i][j] = buf[i]
for i in range(h):
intt(s[i])
def multiply_2D(s: list[list], t: list[list]):
"""
not verify
"""
from copy import deepcopy
hs, ws = len(s), len(s[0])
ht, wt = len(t), len(t[0])
h = 1 << (hs + ht - 2).bit_length()
w = 1 << (ws + wt - 2).bit_length()
a = deepcopy(s)
b = deepcopy(t)
for i in range(hs):
a[i] += [0] * (w - ws)
for i in range(ht):
b[i] += [0] * (w - wt)
a += [[0]*w for i in range(h - hs)]
b += [[0]*w for i in range(h - ht)]
_fft2d(a)
_fft2d(b)
for i in range(h):
for j in range(w):
a[i][j] *= b[i][j]
a[i][j] %= MOD
_ifft2d(a)
a = a[:hs + ht - 1]
for i in range(hs + ht - 1):
a[i][ws + wt - 1:] = []
return a
class Comb:
__slots__ = ["fac", "finv", "mod"]
def __init__(self, lim:int, mod:int = mod):
"""
mod : prime
"""
self.fac = [1]*(lim+1)
self.finv = [1]*(lim+1)
self.mod = mod
for i in range(2,lim+1):
self.fac[i] = self.fac[i-1]*i%self.mod
self.finv[lim] = pow(self.fac[lim],-1,mod)
for i in range(lim,2,-1):
self.finv[i-1] = self.finv[i]*i%self.mod
def C(self, a, b):
if b < 0 or a < b: return 0
if a < 0: return 0
return self.fac[a]*self.finv[b]%self.mod*self.finv[a-b]%self.mod
def __call__(self, a, b):
if b < 0 or a < b: return 0
if a < 0: return 0
return self.fac[a]*self.finv[b]%self.mod*self.finv[a-b]%self.mod
def P(self, a, b):
if b < 0 or a < b: return 0
if a < 0: return 0
return self.fac[a]*self.finv[a-b]%self.mod
def H(self, a, b): return self.C(a+b-1,b)
def F(self, a): return self.fac[a]
def Fi(self, a): return self.finv[a]
n, k = MI()
k %= mod
comb = Comb(n)
# dp -> 0
# ep -> eq
dp = [0] * (n+1)
ep = [0] * (n+1)
dp[1] = 0
ep[1] = k
for i in range(1, n):
dp[i+1] = (ep[i] * (k-1) + dp[i] * (k-2)) % mod
ep[i+1] = dp[i] % mod
# 一つのサイクルの決め方
for i in range(1, n+1):
dp[i] = dp[i] * pow(i, -1, mod) % mod
ep[i] = ep[i] % mod
dp[0] = 0
r1 = fps_exp(dp) # サイクル上にない
r2 = multiply(r1, ep)[:n+1] # サイクル上にある
pk = [1] * (n + 2)
pn = [1] * (n + 2)
for i in range(n):
pk[i+1] = pk[i] * (k - 1) % mod
pn[i+1] = pn[i] * n % mod
pn[-1] = pow(n, -1, mod)
ans = 0
for i in range(1, n+1):
if i != n:
t1 = r1[i] * comb.F(i) % mod # サイクルの決め方
t1 = t1 * comb(n, i) % mod
t1 = t1 * (n - i) * pk[n-i-1] % mod # 一致の選択
t1 = t1 * pn[n-i-1] % mod * i % mod
ans += t1 % mod
t2 = r2[i] * comb.F(i) % mod # サイクルの決め方
t2 = t2 * comb(n, i) % mod # i 頂点の選び方
t2 = t2 * pk[n-i] % mod # 一致の選択
t2 = t2 * pn[n-i-1] % mod * i % mod # 親の選択
ans += t2 % mod
# print(t1, r1[i], t2, r2[i])
print(ans % mod)