ํ๋ ฌ ์ ๊ณฑ (๋ฐฑ์ค 10830)
N×N ์ ์ ํ๋ ฌ A์ ์ ์ B๊ฐ ์ฃผ์ด์ง. A๋ฅผ B๋ฒ ๊ณฑํ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํด์ผ ํจ. ๋จ, ๋ชจ๋ ๊ณ์ฐ์ mod 1000.
์ ๋ต
์ ๋ ฅ ํฌ๊ธฐ ์์๋ณด์ด์ง๋ง B๋ ์ต๋ 10^9๋ผ์ ๋จ์ ๊ณฑ์ ์ผ๋ก ์๊ฐ ์ด๊ณผ. ๋ถํ ์ ๋ณต์ผ๋ก ์ ๊ณฑ ์ฒ๋ฆฌํด์ผ ํต๊ณผ ๊ฐ๋ฅ.
๊ทธ๋ฅ A^B ๊ตฌํ๋ ๋ฌธ์ . B๊ฐ ์ต๋ 10^9๋ผ์ ๋จ์ํ ๊ณฑํ๋ฉด ์๊ฐ ํฐ์ง. ๋ฌด์กฐ๊ฑด ๋ถํ ์ ๋ณต ์จ์ผ ํจ.
ํต์ฌ์ ํ๋ ฌ ๊ณฑ์ ์ ์ ๋๋ก ๊ตฌํํ๊ณ , b๋ฅผ ๋ฐ์ผ๋ก ์ชผ๊ฐ๋ฉด์ ์ฌ๊ท๋ก ์ฒ๋ฆฌํ๋ ๊ฒ.
1. ํ๋ ฌ ๊ณฑ์ ์ A[i][k] * B[k][j] ๋์ ํด์ result[i][j]์ ์ ์ฅํ๋ ๊ตฌ์กฐ.
2. ์ฌ๊ท์์ ์ข
๋ฃ ์กฐ๊ฑด b==1์ผ ๋ mod 1000 ์ฒ๋ฆฌ๋ ์๋ณธ ๊ทธ๋๋ก ๋ฆฌํดํด์ผ ํจ. ๋ฌธ์ ์์ ์ถ๋ ฅ์ ์ ๋ถ mod 1000์ด๋ผ ์ ํ๋ฉด ํ๋ฆผ.
3. ํ์ ์ ๊ณฑ์ผ ๋๋ ๋ฐ์ผ๋ก ๋๋ ๊ฑฐ ๋ ๋ฒ ๊ณฑํ๊ณ , ๋ง์ง๋ง์ ํ ๋ฒ ๋ ๊ณฑํด์ค์ผ ์ง์ง b์ ๊ณฑ ๋จ. ์ด๊ฑฐ ์ ํ๋ฉด b๊ฐ ํ์์ผ ๋ ๊ฒฐ๊ณผ ์๋ฆผ.
4. ๊ทธ๋ฆฌ๊ณ base case์์ ๋ฆฌํด ์ ํ๋ฉด ๋ฌดํ์ฌ๊ท ๋น ์ ธ์ RecursionError ๋ฌ๋ค. ๋ง๋ ์ ๋๋ ์ค์๋ก ์๊ฐ ๋ ๋ฆฌ์ง ๋ง๋ผ.
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**6)
# ํ๋ ฌ ๊ณฑ์
def mat_mul(A, B):
n=len(A)
result=[[0]*n for _ in range(n)]
for i in range(n):
for j in range(n):
for k in range(n):
result[i][j]+=A[i][k]*B[k][j]
result[i][j]%=1000
return result
def mat_pow(matrix,b):
# base case
if b==1:
return [[x%1000 for x in row] for row in matrix]
half=mat_pow(matrix,b//2)
result=mat_mul(half,half)
# ํ์ ์ ๊ณฑ์ผ ๊ฒฝ์ฐ ํ ๋ฒ ๋ ๊ณฑํด์ค
if b%2==1:
result=mat_mul(result,matrix)
return result
def main():
n,b=map(int,input().split())
matrix=[list(map(int,input().split())) for _ in range(n)]
result=mat_pow(matrix,b)
for row in result:
print(*row)
if __name__=="__main__":
main()'๐ Algorithm > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| โ BOJ 30805 - LCS(Longest Common Subsequence) (0) | 2025.07.15 |
|---|---|
| โ BOJ 13172 - pow ์ฐ์ฐ (๋ถํ ์ ๋ณต ๊ฑฐ๋ญ์ ๊ณฑ, ๋ชจ๋๋ฌ ์ญ์) (1) | 2025.07.14 |
| โ BOJ 12851 - BFS ๊ฐ์ง ์ ๋์ (1) | 2025.07.11 |
| โ BOJ 17144 - ๋นก๊ตฌํ (2) | 2025.07.11 |
| โ BOJ 11054 - DP, LIS (4) | 2025.07.09 |