結果
| 問題 |
No.2062 Sum of Subset mod 999630629
|
| コンテスト | |
| ユーザー |
 zkou
|
| 提出日時 | 2022-08-26 23:34:09 |
| 言語 | PyPy3 (7.3.15) |
| 結果 |
AC
|
| 実行時間 | 1,668 ms / 5,000 ms |
| コード長 | 11,789 bytes |
| コンパイル時間 | 322 ms |
| コンパイル使用メモリ | 82,268 KB |
| 実行使用メモリ | 257,676 KB |
| 最終ジャッジ日時 | 2024-10-14 01:10:12 |
| 合計ジャッジ時間 | 16,824 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge3 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 3 |
| other | AC * 29 |
ソースコード
# For the sake of speed,
# this convolution is specialized to mod 998244353.
_fft_mod = 998244353
_fft_imag = 911660635
_fft_iimag = 86583718
_fft_rate2 = (
911660635,
509520358,
369330050,
332049552,
983190778,
123842337,
238493703,
975955924,
603855026,
856644456,
131300601,
842657263,
730768835,
942482514,
806263778,
151565301,
510815449,
503497456,
743006876,
741047443,
56250497,
867605899,
)
_fft_irate2 = (
86583718,
372528824,
373294451,
645684063,
112220581,
692852209,
155456985,
797128860,
90816748,
860285882,
927414960,
354738543,
109331171,
293255632,
535113200,
308540755,
121186627,
608385704,
438932459,
359477183,
824071951,
103369235,
)
_fft_rate3 = (
372528824,
337190230,
454590761,
816400692,
578227951,
180142363,
83780245,
6597683,
70046822,
623238099,
183021267,
402682409,
631680428,
344509872,
689220186,
365017329,
774342554,
729444058,
102986190,
128751033,
395565204,
)
_fft_irate3 = (
509520358,
929031873,
170256584,
839780419,
282974284,
395914482,
444904435,
72135471,
638914820,
66769500,
771127074,
985925487,
262319669,
262341272,
625870173,
768022760,
859816005,
914661783,
430819711,
272774365,
530924681,
)
def _butterfly(a):
n = len(a)
h = (n - 1).bit_length()
len_ = 0
while len_ < h:
if h - len_ == 1:
p = 1 << (h - len_ - 1)
rot = 1
for s in range(1 << len_):
offset = s << (h - len_)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p] * rot
a[i + offset] = (l + r) % _fft_mod
a[i + offset + p] = (l - r) % _fft_mod
if s + 1 != (1 << len_):
rot *= _fft_rate2[(~s & -~s).bit_length() - 1]
rot %= _fft_mod
len_ += 1
else:
p = 1 << (h - len_ - 2)
rot = 1
for s in range(1 << len_):
rot2 = rot * rot % _fft_mod
rot3 = rot2 * rot % _fft_mod
offset = s << (h - len_)
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) % _fft_mod * _fft_imag
a[i + offset] = (a0 + a2 + a1 + a3) % _fft_mod
a[i + offset + p] = (a0 + a2 - a1 - a3) % _fft_mod
a[i + offset + p * 2] = (a0 - a2 + a1na3imag) % _fft_mod
a[i + offset + p * 3] = (a0 - a2 - a1na3imag) % _fft_mod
if s + 1 != (1 << len_):
rot *= _fft_rate3[(~s & -~s).bit_length() - 1]
rot %= _fft_mod
len_ += 2
def _butterfly_inv(a):
n = len(a)
h = (n - 1).bit_length()
len_ = h
while len_:
if len_ == 1:
p = 1 << (h - len_)
irot = 1
for s in range(1 << (len_ - 1)):
offset = s << (h - len_ + 1)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p]
a[i + offset] = (l + r) % _fft_mod
a[i + offset + p] = (l - r) * irot % _fft_mod
if s + 1 != (1 << (len_ - 1)):
irot *= _fft_irate2[(~s & -~s).bit_length() - 1]
irot %= _fft_mod
len_ -= 1
else:
p = 1 << (h - len_)
irot = 1
for s in range(1 << (len_ - 2)):
irot2 = irot * irot % _fft_mod
irot3 = irot2 * irot % _fft_mod
offset = s << (h - len_ + 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) * _fft_iimag % _fft_mod
a[i + offset] = (a0 + a1 + a2 + a3) % _fft_mod
a[i + offset + p] = (
(a0 - a1 + a2na3iimag) * irot % _fft_mod
)
a[i + offset + p * 2] = (
(a0 + a1 - a2 - a3) * irot2 % _fft_mod
)
a[i + offset + p * 3] = (
(a0 - a1 - a2na3iimag) * irot3 % _fft_mod
)
if s + 1 != (1 << (len_ - 2)):
irot *= _fft_irate3[(~s & -~s).bit_length() - 1]
irot %= _fft_mod
len_ -= 2
def _convolution_naive(a, b):
n = len(a)
m = len(b)
ans = [0] * (n + m - 1)
if n < m:
for j in range(m):
for i in range(n):
ans[i + j] += a[i] * b[j]
ans[i + j] %= _fft_mod
else:
for i in range(n):
for j in range(m):
ans[i + j] += a[i] * b[j]
ans[i + j] %= _fft_mod
return ans
def _convolution_fft(a, b):
a = a.copy()
b = b.copy()
n = len(a)
m = len(b)
z = 1 << (n + m - 2).bit_length()
a += [0] * (z - n)
_butterfly(a)
b += [0] * (z - m)
_butterfly(b)
for i in range(z):
a[i] *= b[i]
a[i] %= _fft_mod
_butterfly_inv(a)
a = a[: n + m - 1]
iz = pow(z, _fft_mod - 2, _fft_mod)
for i in range(n + m - 1):
a[i] *= iz
a[i] %= _fft_mod
return a
def _convolution_square(a):
a = a.copy()
n = len(a)
z = 1 << (2 * n - 2).bit_length()
a += [0] * (z - n)
_butterfly(a)
for i in range(z):
a[i] *= a[i]
a[i] %= _fft_mod
_butterfly_inv(a)
a = a[: 2 * n - 1]
iz = pow(z, _fft_mod - 2, _fft_mod)
for i in range(2 * n - 1):
a[i] *= iz
a[i] %= _fft_mod
return a
def convolution(a, b):
"""It calculates (+, x) convolution in mod 998244353.
Given two arrays a[0], a[1], ..., a[n - 1] and b[0], b[1], ..., b[m - 1],
it calculates the array c of length n + m - 1, defined by
> c[i] = sum(a[j] * b[i - j] for j in range(i + 1)) % 998244353.
It returns an empty list if at least one of a and b are empty.
Constraints
-----------
> len(a) + len(b) <= 8388609
Complexity
----------
> O(n log n), where n = len(a) + len(b).
"""
n = len(a)
m = len(b)
if n == 0 or m == 0:
return []
if min(n, m) <= 60:
return _convolution_naive(a, b)
if a is b:
return _convolution_square(a)
return _convolution_fft(a, b)
# Reference: https://opt-cp.com/fps-fast-algorithms/
def inv(a):
"""It calculates the inverse of formal power series in O(n log n) time, where n = len(a)."""
n = len(a)
assert n > 0 and a[0] != 0
res = [pow(a[0], _fft_mod - 2, _fft_mod)]
m = 1
while m < n:
f = a[: min(n, 2 * m)]
g = res.copy()
f += [0] * (2 * m - len(f))
_butterfly(f)
g += [0] * (2 * m - len(g))
_butterfly(g)
for i in range(2 * m):
f[i] = f[i] * g[i] % _fft_mod
_butterfly_inv(f)
f = f[m:] + [0] * m
_butterfly(f)
for i in range(2 * m):
f[i] = f[i] * g[i] % _fft_mod
_butterfly_inv(f)
f = f[:m]
iz = pow(2 * m, _fft_mod - 2, _fft_mod)
iz *= -iz
iz %= _fft_mod
for i in range(m):
f[i] = f[i] * iz % _fft_mod
res.extend(f)
m *= 2
res = res[:n]
return res
def integ_inplace(a):
n = len(a)
assert n > 0
if n == 1:
return []
a.pop()
a.insert(0, 0)
inv = [1, 1]
for i in range(2, n):
inv.append(-inv[_fft_mod % i] * (_fft_mod // i) % _fft_mod)
a[i] = a[i] * inv[i] % _fft_mod
def deriv_inplace(a):
n = len(a)
assert n > 0
for i in range(2, n):
a[i] = a[i] * i % _fft_mod
a.pop(0)
a.append(0)
def log(a):
a = a.copy()
n = len(a)
assert n > 0 and a[0] == 1
a_inv = inv(a)
deriv_inplace(a)
a = convolution(a, a_inv)[:n]
integ_inplace(a)
return a
def exp(a):
a = a.copy()
n = len(a)
assert n > 0 and a[0] == 0
g = [1]
a[0] = 1
h_drv = a.copy()
deriv_inplace(h_drv)
m = 1
while m < n:
f_fft = a[:m] + [0] * m
_butterfly(f_fft)
if m > 1:
_f = [f_fft[i] * g_fft[i] % _fft_mod for i in range(m)]
_butterfly_inv(_f)
_f = _f[m // 2 :] + [0] * (m // 2)
_butterfly(_f)
for i in range(m):
_f[i] = _f[i] * g_fft[i] % _fft_mod
_butterfly_inv(_f)
_f = _f[: m // 2]
iz = pow(m, _fft_mod - 2, _fft_mod)
iz *= -iz
iz %= _fft_mod
for i in range(m // 2):
_f[i] = _f[i] * iz % _fft_mod
g.extend(_f)
t = a[:m]
deriv_inplace(t)
r = h_drv[: m - 1]
r.append(0)
_butterfly(r)
for i in range(m):
r[i] = r[i] * f_fft[i] % _fft_mod
_butterfly_inv(r)
im = pow(-m, _fft_mod - 2, _fft_mod)
for i in range(m):
r[i] = r[i] * im % _fft_mod
for i in range(m):
t[i] = (t[i] + r[i]) % _fft_mod
t = [t[-1]] + t[:-1]
t += [0] * m
_butterfly(t)
g_fft = g + [0] * (2 * m - len(g))
_butterfly(g_fft)
for i in range(2 * m):
t[i] = t[i] * g_fft[i] % _fft_mod
_butterfly_inv(t)
t = t[:m]
i2m = pow(2 * m, _fft_mod - 2, _fft_mod)
for i in range(m):
t[i] = t[i] * i2m % _fft_mod
v = a[m : min(n, 2 * m)]
v += [0] * (m - len(v))
t = [0] * (m - 1) + t + [0]
integ_inplace(t)
for i in range(m):
v[i] = (v[i] - t[m + i]) % _fft_mod
v += [0] * m
_butterfly(v)
for i in range(2 * m):
v[i] = v[i] * f_fft[i] % _fft_mod
_butterfly_inv(v)
v = v[:m]
i2m = pow(2 * m, _fft_mod - 2, _fft_mod)
for i in range(m):
v[i] = v[i] * i2m % _fft_mod
for i in range(min(n - m, m)):
a[m + i] = v[i]
m *= 2
return a
def pow_fps(a, k):
a = a.copy()
n = len(a)
l = 0
while l < len(a) and not a[l]:
l += 1
if l * k >= n:
return [0] * n
ic = pow(a[l], _fft_mod - 2, _fft_mod)
pc = pow(a[l], k, _fft_mod)
a = log([a[i] * ic % _fft_mod for i in range(l, len(a))])
for i in range(len(a)):
a[i] = a[i] * k % _fft_mod
a = exp(a)
for i in range(len(a)):
a[i] = a[i] * pc % _fft_mod
a = [0] * (l * k) + a[: n - l * k]
return a
from collections import Counter
P1 = 998244353
P2 = 999630629
# N = 10**5
# As = [10000] * N
N = int(input())
As = list(map(int, input().split()))
answer = pow(2, N - 1, P1) * sum(As) % P1
# #{ S | P2 <= \sum_{i \in S} A_i }
# = #{ S' | sum(As) - P2 >= \sum_{i \in S'} A_i }
weight_ub = sum(As) - P2 + 1
if weight_ub < 0:
print(answer)
exit()
arg = [0] * weight_ub
arg[0] = arg[1] = 1
log_1_x = log(arg)
s = [0] * weight_ub
for A, count in Counter(As).items():
for i in range(0, weight_ub, A):
s[i] += log_1_x[i // A] * count
s[i] %= P1
e = exp(s)
answer -= P2 * (sum(e) % P1) % P1
answer %= P1
print(answer)