๋ฌธ์
https://www.acmicpc.net/problem/1086
๋ฐฑ์ค ๋จ๊ณ๋ณ๋ก ํ์ด๋ณด๊ธฐ - ๋์ ๊ณํ๋ฒ 3
ํ์ด
๋นํธ๋ง์คํน + DP ๋ฅผ ๊ณ ๋ คํ์ง ์๊ณ ํ์์๋ ์ฌ์ ๋๋ฐ, ์ด ๋์ ์ ์ฉํ๋ ค๋ ์ด๋ ค์ ๋ ๋ฌธ์ ๋ค...
์๊ฐํด๋ณด๋ฉด ๋น์ฐํ๋ค. ๋จ์ํ permutations ๋ชจ๋์ ์ฌ์ฉํด์ ํ๋ฉด ๋ฉ๋ชจ๋ฆฌ&์๊ฐ์ด ์์ฒญ๋๊ฒ ์์๋๋ค.
๊ทธ๋์ ์๋ํ๋๋ฐ...
DP๋ ์ด๋ ค์ด๋ฐ ๋นํธ๋ง์คํน๊น์ง ์ ์ฉํ๋ ค๋ ํ๋ค์๋ค... ๊ฒฐ๊ตญ ๋ค๋ฅธ ํ์ด๋ฅผ ์ฐธ๊ณ ํด์ ๊ณต๋ถํ๋ค^^;;
๋ค๋ฅธ ํ์ด๋ค์ ์ฐพ์๋ณด๋ ๋จ์ํ ์ ๋์ ์ ๋ชฉ์ํจ๋ค๊ณ ํด๊ฒฐ๋๋ ๋ฌธ์ ๊ฐ ์๋๋ฏํ๋ค. (์๊ฐ์ด๊ณผ)
๋ ํจ์จ์ ์ธ ๋ฐฉ๋ฒ์ ์๊ฐํด๋ด์ผํ๋ ๋ฌธ์ ๋ค.
์ด๋ ํ ์๋ฅผ K๋ก ๋๋์์๋ ๋๋จธ์ง๊ฐ์ ๋ฒ์๋ 0 ~ K-1์ด๋ค.
์ด๊ฑธ ์ด์ฉํด์ ์ฃผ์ด์ง ์งํฉ์ ๊ฐ ์ซ์ S[i]์ ๋ํด ๊ฐ๋ฅํ ๋๋จธ์ง๊ฐ๋ค์ ์ ์ฅํ๋ค.
remain = [[(j * 10 ** len(str(S[i])) + S[i]) % K for j in range(K)] for i in range(N)]
ํ๋์ฉ ๋ฏ์ด๋ณด๋ฉด,for i in range(N): ์งํฉ S์ ๊ฐ ์์์ ๋ํ ์ธ๋ฑ์ค ifor j in range(K): i๋ฅผ ์ถ๊ฐํ๊ธฐ ์ ์ ๋๋จธ์ง๊ฐ j
์ฆ, remain[i][j]๋ "ํ์ฌ ๋๋จธ์ง๊ฐ j์ธ ์ํฉ์์, S[i]๋ฅผ ์ถ๊ฐํ์์ ๋๋จธ์ง" ๋ฅผ ๋ํ๋ธ๋ค.
(j * 10 ** len(str(S[i])) + S[i]) % K๋ฅผ ๋ฏ์ด๋ณด๋ฉด ์๋์ ๊ฐ๋ค.j * 10 ** len(str(S[i])): ๊ธฐ์กด ๋๋จธ์ง j๋ฅผ S[i]์ ๊ธธ์ด๋งํผ ์ผ์ชฝ์ผ๋ก ๋ฐ์ด๋+ S[i]: ๊ทธ ํ S[i]๋ฅผ ๋ํด์ค% K: ์์ ๊ฐ์ K๋ก ๋๋ ๋๋จธ์ง
๋ง์ฝ ๊ธฐ์กด ๋๋จธ์ง๊ฐ 3์ธ ์ํฉ์์ S[1] = 2๋ฅผ ์ถ๊ฐํ๊ณ ์ถ๋ค๋ฉด remain[1][3]๊ฐ์ ๊ฐ์ ธ์ค๋ฉด ๋๋ค.
๊ทธ๋ฆฌ๊ณ dp๋ ์๋์ ๊ฐ์ด ์ด๊ธฐํํ๋ค.
dp = [[0] * K for _ in range(1 << N)]
dp[0][0] = 1
์ซ์์ ์กฐํฉ์ ๋นํธ๋ง์คํน์ผ๋ก ๋ํ๋์๋์ ๊ฐ์ i๋ผ๊ณ ํ์๋, ๊ทธ ์กฐํฉ์ ๋๋จธ์ง๊ฐ j์ธ์
์ด๋ค.dp[3(011)][2]: ์ฒซ๋ฒ์งธ์ ๋๋ฒ์งธ ์์๋ฅผ ์กฐํฉํ์๋, ๋๋จธ์ง๊ฐ 2์ธ๊ฒฝ์ฐ.
์ ์ฒด ์ฝ๋๋ ์๋์ ๊ฐ๋ค.
from sys import stdin
import math
input = stdin.readline
N = int(input())
S = [int(input()) for _ in range(N)]
K = int(input())
remain = [[(j * 10 ** len(str(S[i])) + S[i]) % K for j in range(K)] for i in range(N)]
dp = [[0] * K for _ in range(1 << N)]
dp[0][0] = 1
for mask in range(1 << N):
for i in range(N):
if mask & (1 << i): # ๐จ if not์ผ๋ก ์ฒดํฌํ ๋๋ณด๋ค ๋ ๋น ๋ฆ.
continue
for j in range(K):
dp[mask | (1 << i)][remain[i][j]] += dp[mask][j]
correct = dp[(1 << N) - 1][0]
total = sum(dp[(1 << N) - 1])
m = math.gcd(correct, total)
print(f"{correct // m}/{total // m}")
mask๋ ๊ฐ๋ฅํ ์กฐํฉ์ ๋ํ๋ธ๋ค. (๋ง์ฝ N์ด 3์ด๋ผ๋ฉด 000 ~ 111)i๋ ์ถ๊ฐํ ์ธ๋ฑ์ค๋ฅผ ์๋ฏธํ๋ฉฐ, ๋ง์ฝ i๋ฒ์งธ ์ธ๋ฑ์ค๊ฐ ์ด๋ฏธ mask์กฐํฉ์ ํฌํจ๋ ์ํ๋ผ๋ฉด ํจ์ค.j๋ ๋๋จธ์ง๊ฐ์ผ๋ก ์ฌ ์ ์๋ ๋ฒ์๋ค.
[mask | (1 << i)]: i๋ฒ์งธ ์ธ๋ฑ์ค๋ฅผ ์ถ๊ฐํ ๋ค์ ์กฐํฉ[remain[i][j]]: ๊ธฐ์กด ๋๋จธ์ง๊ฐ์ด j์ผ๋ i๋ฒ์งธ ์ธ๋ฑ์ค๋ฅผ ์ถ๊ฐํ ํ ๋๋จธ์ง๊ฐ
=> dp[mask | (1 << i)][remain[i][j]]: ์ ํํ ์กฐํฉ์ i์ธ๋ฑ์ค๋ฅผ ์ถ๊ฐํ์๋, ๋๋จธ์ง๊ฐ remain[i][j]์ธ ๊ฒฝ์ฐ์ ์.
์ด ๊ฒฝ์ฐ์ ์์ "i์ธ๋ฑ์ค๋ฅผ ์ถ๊ฐํ๊ธฐ ์ ๊ฒฝ์ฐ์ ์"๋ฅผ ๋ํด์ค๋ค.
dp[mask][j]: ์ ํํ ์กฐํฉ์ด mask์ผ๋ ๋๋จธ์ง๊ฐ j์ธ ๊ฒฝ์ฐ์ ์
์ด๋ ๊ฒ ๋ฐ๋ณต๋ฌธ์ ์งํํ๋ฉฐ ๊ฐ ์กฐํฉ์ ๋ํด ๊ฐ๋ฅํ ๋ชจ๋ ๋๋จธ์ง๊ฐ์ ๊ณ์ฐํ๊ณ ,
์ต์ข
์ ์ผ๋ก ๋ชจ๋ ์กฐํฉ์ ์ฌ์ฉํ์๋ ๋๋จธ์ง๊ฐ 0์ธ ๊ฒฝ์ฐ, ๋ชจ๋ ์กฐํฉ์ ์ฌ์ฉํ์๋์ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ ์ ์๋ค.
๋ง์ง๋ง์ผ๋ก math๋ชจ๋์ gcd()ํจ์๋ฅผ ์ฌ์ฉํด ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๊ณ , ๊ฐ ๊ฐ์ ์ต๋๊ณต์ฝ์๋ก ๋๋ ์ถ๋ ฅํ๋ค.
+ ๊ทธ๋ฆฌ๊ณ if not mask $ (1 << i):๋ก ์ฌ์ฉํ์๋๋ณด๋ค ์์ฒ๋ผ ์์ฑํ์๋๊ฐ ๋ ๋นจ๋๋ค.if not์ฒ๋ผ ์ฌ์ฉํ ๊ฒฝ์ฐ "ํด๋น ์กฐ๊ฑด๋ฌธ์ ๋ง์กฑํ์ง ์์ ๊ฒฝ์ฐ"๋ ์ฒดํฌํ๊ธฐ ๋๋ฌธ์, ๋ชจ๋ ๊ฒฝ์ฐ์ ๋ํด ์ถ๊ฐ์ ์ธ ์์
์ด ์งํ๋ ์๋ ์๋ค๊ณ ํ๋ค.
๋ฐ๋ฉด continue๋ ์กฐ๊ฑด์ด ์ฐธ์ผ ๊ฒฝ์ฐ ๋ฐ๋ก ๋ฐ๋ณต๋ฌธ์ ๋น ์ ธ๋์ค๋ฏ๋ก ์ ๋ฌธ์ ์ฒ๋ผ ๋ฐ๋ณต์ด ๋ง์์ง ๋ ํจ๊ณผ์ ์ด๋ผ๊ณ ํ๋ค.
... ~๊ทธ๋ ๋ค๊ณ ํ๋ค. GPT๋ฅผ 100% ์ ๋ขฐํ ์ ์์ผ๋ ๊ฐ๋ฅ์ฑ์ผ๋ก๋ง ๋จ๊ฒจ๋์.