๋ฌธ์ ์์ฝ
m๊ฐ์ (n, s) ์์ด ์ฃผ์ด์ง๋ค. ๊ฐ ์์ n๋ฉด์ฒด ์ฃผ์ฌ์ ๊ตด๋ ค์ s๊ฐ ๋์ฌ ํ๋ฅ ์ด๋ผ๊ณ ๋ณด๋ฉด ๋๊ณ , ๊ฒฐ๊ตญ s/n ๊ฐ์ ๋ค ๋ํด์ mod 10^9+7๋ก ์ถ๋ ฅํ๋ผ๋ ์๋ฆฌ๋ค. ๋ฌธ์ ์์ฒด๋ ๊ทธ๋ฅ ๊ธฐ๋๊ฐ๋ค์ ํฉ์ ๊ตฌํ๋ผ๋ ๋ง์ฒ๋ผ ์๊ฒผ์ง๋ง, ์ ์ ๋๋์ ์ mod ์ฐ์ฐ ๋ค์ด๊ฐ ์๊ฐ ์๊ธฐ๋ ๋ฌ๋ผ์ง๋ค. ์ด๊ฑด ๋ฌด์กฐ๊ฑด ๋ชจ๋๋ฌ ์ญ์ ๋ฌธ์ ๋ก ๋ฐ๋๋ ๊ฑฐ๋ค.
์ ๊ทผ ๋ฐฉ์
s / n mod MOD๋ ๊ณง s * n^-1 mod MOD๋ก ๋ฐ๊ฟ์ผ ํ๋ค. ์ฌ๊ธฐ์ n^-1์ ์ญ์์ธ๋ฐ, MOD๊ฐ ์์๋๊น ๊ทธ๋ฅ n^(MOD-2) mod MOD๋ก ๊ตฌํ๋ฉด ๋๋๋ค. ์ด๊ฑด ํ๋ฅด๋ง ์์ ๋ฆฌ ๊ณต์ ๊ทธ๋๋ก ์ด ๊ฑฐ๊ณ , ๋น ๋ฅด๊ฒ ๊ณ์ฐํ๋ ค๋ฉด ๋ถํ ์ ๋ณต ๊ฑฐ๋ญ์ ๊ณฑ ์จ์ผ ํ๋ค. pow ํจ์ ์ฐ๋ฉด ๋์ง๋ง ์ฐ์ตํ๋ ค๋ฉด ์ง์ ๊ตฌํํด๋ ๋๋ค. ๋ถํ ์ ๋ณต ๋ฌธ์ ์ด๋ ๋งํผ ์ด ๋ถ๋ถ์ ์ง์ ๊ตฌํํ๋ฉด์ ์ดํดํ๋๊ฒ ์ข๋ค.
์ฃผ์ํ ์
๊ณฑ์ ํ ๋๋ mod ์ฒ๋ฆฌ ์ ํ๋ฉด ๊ฐ ํฐ์ง๋ค. ๋์ ํฉ ๋ํ ๋๋ mod ๊ฑธ์ด์ค์ผ ์์ ํ๊ฒ ๊ฐ๋ค. pow ํจ์๋ ์ธ์ด์ ๋ฐ๋ผ ์์ ์๋ ์์ผ๋ ์ง์ ์ง๋ ์ฐ์ต ํด๋๋ ๊ฒ ์ข๊ณ , ํ์ด์ฌ์ ๊ทธ๋ฅ pow(a, b, mod) ์ฐ๋ฉด ๋น ๋ฅด๊ณ ๊น๋ํ๋ค.
ํต์ฌ ๊ฐ๋
์ ์ ๋๋์ ์ mod ๋ค์ด์ค๋ฉด ๋ฌด์กฐ๊ฑด ๋ชจ๋๋ฌ ์ญ์์ผ๋ก ์ฒ๋ฆฌํด์ผ ํ๊ณ , MOD๊ฐ ์์์ผ ๋๋ง ํ๋ฅด๋ง ์์ ๋ฆฌ ์จ์ ์ญ์ ๊ตฌํ ์ ์๋ค.
๋ถํ ์ ๋ณต ๊ฑฐ๋ญ์ ๊ณฑ์ a๋ฅผ ์ ๊ณฑํ๋ฉด์ b๋ฅผ ์ ๋ฐ์ฉ ์ค์ด๊ณ , b์ ๋นํธ๊ฐ 1์ผ ๋๋ง ๊ทธ ์๊ฐ์ a๋ฅผ ๊ฒฐ๊ณผ์ ๊ณฑํด์ฃผ๋ ๋ฐฉ์์ด๋ค. ์ด๊ฑธ๋ก O(log b)์ ์์ ํ๊ฒ ์ง์ ๊ณ์ฐ ๊ฐ๋ฅํ๋ค.
# dac, python ์ค์ ์์๋ (a**b)%mod ์ฐ์ฐ์์๋ pow(a,b,mod) ํ์ฉ
import sys
input=sys.stdin.readline
# pow(a,b,mod) ์ฐ์ฐ์ ์ง์ ๊ตฌํ. ์ฌ๊ธฐ์ ๋ถํ ์ ๋ณต์ด ์ฌ์ฉ
def mod_pow(a,b,mod):
result=1
a%=mod
while b>0:
if b%2==1:
result=(result*a)%mod
a=(a*a)%mod
b//=2
return result
def mod_cal(n,s,mod):
b=mod_pow(n,mod-2,mod)
a=s
return (a*b)%mod
def main():
m=int(input().strip())
mod=10**9+7
result=0
for _ in range(m):
n,s=map(int,input().split())
result=(result+mod_cal(n,s,mod))%mod
print(result)
if __name__=="__main__":
main()'๐ Algorithm > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| โ BOJ 14938 - N๋ฒ ๋ค์ต์คํธ๋ผ (1) | 2025.07.16 |
|---|---|
| โ BOJ 30805 - LCS(Longest Common Subsequence) (0) | 2025.07.15 |
| โ BOJ 10830 - ํ๋ ฌ ์ ๊ณฑ (0) | 2025.07.12 |
| โ BOJ 12851 - BFS ๊ฐ์ง ์ ๋์ (1) | 2025.07.11 |
| โ BOJ 17144 - ๋นก๊ตฌํ (2) | 2025.07.11 |