[BOJ][๐ก4][๋ฐฑ์ค#12869] ๋ฎคํ๋ฆฌ์คํฌ
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold IV
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
์๋น์ด๋ ๊ฐํธ์ ํจ๊ป ์คํํฌ๋ํํธ ๊ฒ์์ ํ๊ณ ์๋ค. ์๋น์ด๋ ๋ฎคํ๋ฆฌ์คํฌ 1๊ฐ๊ฐ ๋จ์์๊ณ , ๊ฐํธ๋ SCV N๊ฐ๊ฐ ๋จ์์๋ค. ๊ฐ๊ฐ์ SCV๋ ๋จ์์๋ ์ฒด๋ ฅ์ด ์ฃผ์ด์ ธ์์ผ๋ฉฐ, ๋ฎคํ๋ฆฌ์คํฌ๋ฅผ ๊ณต๊ฒฉํ ์๋ ์๋ค. ์ฆ, ์ด ๊ฒ์์ ์๋น์ด๊ฐ ์ด๊ฒผ๋ค๋ ๊ฒ์ด๋ค. ๋ฎคํ๋ฆฌ์คํฌ๊ฐ ๊ณต๊ฒฉ์ ํ ๋, ํ ๋ฒ์ ์ธ ๊ฐ์ SCV๋ฅผ ๊ณต๊ฒฉํ ์ ์๋ค.
์ฒซ ๋ฒ์งธ๋ก ๊ณต๊ฒฉ๋ฐ๋ SCV๋ ์ฒด๋ ฅ 9๋ฅผ ์๋๋ค. ๋ ๋ฒ์งธ๋ก ๊ณต๊ฒฉ๋ฐ๋ SCV๋ ์ฒด๋ ฅ 3์ ์๋๋ค. ์ธ ๋ฒ์งธ๋ก ๊ณต๊ฒฉ๋ฐ๋ SCV๋ ์ฒด๋ ฅ 1์ ์๋๋ค.
SCV์ ์ฒด๋ ฅ์ด 0 ๋๋ ๊ทธ ์ดํ๊ฐ ๋์ด๋ฒ๋ฆฌ๋ฉด, SCV๋ ๊ทธ ์ฆ์ ํ๊ดด๋๋ค. ํ ๋ฒ์ ๊ณต๊ฒฉ์์ ๊ฐ์ SCV๋ฅผ ์ฌ๋ฌ ๋ฒ ๊ณต๊ฒฉํ ์๋ ์๋ค. ๋จ์์๋ SCV์ ์ฒด๋ ฅ์ด ์ฃผ์ด์ก์ ๋, ๋ชจ๋ SCV๋ฅผ ํ๊ดดํ๊ธฐ ์ํด ๊ณต๊ฒฉํด์ผ ํ๋ ํ์์ ์ต์๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ SCV์ ์ N (1 โค N โค 3)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์๋ SCV N๊ฐ์ ์ฒด๋ ฅ์ด ์ฃผ์ด์ง๋ค. ์ฒด๋ ฅ์ 60๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๋ชจ๋ SCV๋ฅผ ํ๊ดดํ๊ธฐ ์ํ ๊ณต๊ฒฉ ํ์์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค.
์์
์์ 1
์ ๋ ฅ
3
12 10 4
์ถ๋ ฅ
2
์์ 2
์ ๋ ฅ
3
54 18 6
์ถ๋ ฅ
6
์์ 3
์ ๋ ฅ
1
60
์ถ๋ ฅ
7
์์ 4
์ ๋ ฅ
3
1 1 1
์ถ๋ ฅ
1
์์ 5
์ ๋ ฅ
2
60 40
์ถ๋ ฅ
9
My Sol
from collections import deque
def main():
N = int(input())
scvs = list(map(int, input().split()))
Q = deque([(scvs, N, 0)])
watched = set()
damages = [
[],
[[9]],
[[9,3], [3,9]],
[[9,3,1],[9,1,3],[3,9,1],[3,1,9],[1,9,3],[1,3,9]]
]
while Q:
cur_scvs, scvs_cnt, attack_cnt = Q.popleft()
if str(cur_scvs) in watched: continue
watched.add(str(cur_scvs))
for damage in damages[scvs_cnt]:
attacked_scvs = []
kill_cnt = 0
for n in range(scvs_cnt):
attacked_scv = cur_scvs[n] - damage[n]
if attacked_scv <= 0:
kill_cnt += 1
else:
attacked_scvs.append(attacked_scv)
if kill_cnt == scvs_cnt: return attack_cnt+1
Q.append((attacked_scvs, scvs_cnt-kill_cnt, attack_cnt+1))
print(main())
๊ต์ฅํ ์ฝ๊ฒ BFS๋ก ํ ์ ์๋ ๋ฌธ์ ์๋ค.
- ์ฒ์์ SCV์ ๊ฐ์์ ์ฒด๋ ฅ ์ ๋ณด๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ๋๋ค.
- deque
Q
์ (SCV์ ์ฒด๋ ฅ ์ ๋ณด ๋ฆฌ์คํธ, SCV ๊ฐ์, ๊ณต๊ฒฉํ์)๋ฅผ ๋ฃ๋๋ค. - ๊ฐ์ ์ฒด๋ ฅ์ ๋ํ ๊ณต๊ฒฉ์ ์งํํ์ ๊ฒฝ์ฐ ๊ฐ์ ๊ณต๊ฒฉ์ ๋ฐ๋ณตํ์ง ์๋๋ก ์ฌ์ค์ ๋ฐฉ๋ฌธ ์ฌ๋ถ๋ฅผ ๋ฐ์ง๋
watched
set์ ๋๋ค. - ๊ฐ SCV๋ค์ ์์ ๋ฐ๋ผ ๊ณต๊ฒฉ์ ํจํด์ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ ์ฅํ๋
damages
2์ฐจ์ ๋ฐฐ์ด์ ๋๋ค. - deque
Q
์์ SCV ๋ฐ ๊ณต๊ฒฉ ์ ๋ณด๋ฅผ ํ๋์ฉ ๋นผ๋ฉด์ ์กฐํํ๋๋ฐ, SCV์ ์ฒด๋ ฅ ์ ๋ณด๋ฅผ ๋ฌธ์์ด ์ฒ๋ฆฌํ ๊ฒ์ดwatched
์ ์กด์ฌํ๋ค๋ฉด continueํ๋ค. ์ด๋ ๋ฌธ์์ด ์ฒ๋ฆฌํ ์ด์ ๋ list๋ set์์ hashํํ ์ ์๋ ์๋ฃ๊ตฌ์กฐ์ด๊ธฐ ๋๋ฌธ์ด๋ค. ๋๋ฌธ์ ๊ทธ ์์ฒด๋ก string ์ฒ๋ฆฌํ์ฌ ์ ์ฅํ๊ณ ์กฐํํ๋ค.watched
์ ์กด์ฌํ์ง ์๋๋ค๋ฉด, ์ฒซ ์ฒด๋ ฅ ๊ตฌ์กฐ์ธ ๊ฒ์ด๊ธฐ ๋๋ฌธ์watched
์ ํ์ฌ ์ฒด๋ ฅ์ ์ถ๊ฐํ๊ณ ๊ณต๊ฒฉ์ ์์ํ๋ค. - SCV์ ์์ ๋ฐ๋ฅธ ๊ณต๊ฒฉ์ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ for๋ฌธ์ผ๋ก ๋ฐ๋ณต์ฒ๋ฆฌํ๋ค. ํ์ฌ SCV ์ฒด๋ ฅ ๋ฆฌ์คํธ์ ๊ฐ ์ฒด๋ ฅ๋ค์ ๋ํด ๊ณต๊ฒฉ์ ์งํํ๊ณ ์ฒด๋ ฅ์ด 0 ์ดํ๊ฐ ๋ SCV๋ค์ ์๋ฅผ ์ผ๋ค. ๊ณต๊ฒฉ์ ๋ง์น๊ณ ์ด ์ซ์๊ฐ ๊ณต๊ฒฉ ์ SCV์ ์์ ๊ฐ๋ค๋ฉด ๋ชจ๋ SCV๊ฐ ํ๊ดด๋ ๊ฒ์ด๋ฏ๋ก
attack_cnt
์ 1์ ๋ํด ๋ฐํํ๋ค. ๊ทธ๋ ์ง ์๋ค๋ฉด ์์ง SCV๊ฐ ๋จ์์๋ ๊ฒ์ด๊ณ , ์ด๋์ SCV ์ฒด๋ ฅ์attacked_scvs
์ ์ ์ฅ๋์ด์์ผ๋ฏ๋ก ์ด๋ฅผQ
์ ๋ฃ์ด ๋ค์ ๊ณต๊ฒฉ์ ์ฌ์ฉํ๋ค. ์ด๋ SCV์ ์ฒด๋ ฅ๋ค์watched
์ฒ๋ฆฌ๋ฅผ ์ ๋๋ก ํ๊ธฐ ์ํด ๋ชจ๋ ์ฒด๋ ฅ๋ค์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ๋ค. ๋ง์ฝ ์ ๋ ฌํ์ง ์์ผ๋ฉด ๊ฐ์ ์ฒด๋ ฅ ๊ตฌ์ฑ์ด๋๋ผ๋ ์์๊ฐ ๋ฌ๋ผwatched
๋ฅผ ํต๊ณผํ๊ฒ ๋๊ธฐ ๋๋ฌธ์ด๋ค. ์ค์ ๋ก sort ๊ณผ์ ์ ํตํด ์ฐ์ฐ์๋๊ฐ 10% ํฅ์๋์์์ ํ์ธํ๋ค. main
ํจ์์ ๋ฐํ๊ฐ์ ์ถ๋ ฅํ๋ค.
์ฒ์์๋ ์๋์ itertools์ ์์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํด damages
๋ฐฐ์ด์ ๋ง๋ค์๋ค.
from itertools import permutations
def make_damages():
damages = [9, 3, 1]
D = [[] for _ in range(4)]
for n in range(1, 4):
D[n] = [lst for lst in permutations(damages[:n], n)]
return D
damages = make_damages()
๊ทธ๋ฐ๋ฐ ์ซ์๊ฐ ๊ทธ๋ค์ง ๋ง์ง ์๊ธฐ ๋๋ฌธ์ ๊ทธ๋ฅ ํ๋์ฝ๋ฉ์ผ๋ก ๋ณ๊ฒฝํ๊ณ , ์๊ฐ์ ์ฐจ์ด๋ ๋ง์ด ์์์ผ๋ ์ฝ๋ ๊ธธ์ด๋ฅผ 100B ๊ฐ๋ ์ค์ผ ์ ์์๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋๊ธ๋จ๊ธฐ๊ธฐ