๐ค๋ฌธ์ ํด๊ฒฐ
Lv 3 | ์ ๋ต๋ฅ : 0.6%
์ฃผ์ด์ง ๊ฐ์ ํฌ๊ธฐ๊ฐ ํฌ์ง ์๊ธฐ ๋๋ฌธ์ ์์ ํ์์ผ๋ก ํด๊ฒฐ์ด ๊ฐ๋ฅํ๋ค.
๋จผ์ ์น๊ตฌ๋ฅผ ์์ด๋ก ๋ง๋ ๋ค. ex) [1,2,3] ์ด๋ฉด [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]
์ธ๋ฒฝ์ด ์ํ์ด๋ฏ๋ก ์๊ณผ ๋ค๊ฐ ์ด์ด์ ธ ์๋ค๊ณ ์๊ฐํด์ผ ํ๋ค.
์ทจ์ฝ์ ๋ ์ฒซ๋ฒ์งธ ์ทจ์ฝ์ ์ ๋จผ์ ๊ฐ๊ฒ์ธ๊ฐ ๋๋ฒ์งธ ์ทจ์ฝ์ ์ ๋จผ์ ๊ฐ๊ฒ์ธ๊ฐ... ์์๋ฅผ ์ ํด์ ๊ฐ์ผํ๋ค.
- ์ฒซ๋ฒ ์งธ ํ ์คํธ์ผ์ด์ค์ ์ทจ์ฝ์ ([1, 5, 6, 10])์ ๋ฐฐ์ด(n=12)๋ก ๋ํ๋ด๋ฉด [0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0]
์์ ๊ฒฝ์ฐ๋ ์ฒซ๋ฒ์งธ ์ทจ์ฝ์ (1)์ด ๊ฐ์ฅ ๋จผ์ ๋์ค๋ ๊ฒฝ์ฐ
- ๋ค์ ์ทจ์ฝ์ 2๊ฐ ๊ฐ์ฅ ๋จผ์ ๋์ค๋ ๊ฒฝ์ฐ๋ 0,1์ ๋งจ๋ค๋ก ์ฎ๊ฒจ์ฃผ๋ฉด ๋๋ค.
[0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0] => [0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1]
- ๋ค์ ์ทจ์ฝ์ 3์ด ๊ฐ์ ๋จผ์ ๋์ค๋ ๊ฒฝ์ฐ 0,0,0,1์ ๋งจ ๋ค๋ก ์ฎ๊ฒจ์ค๋ค.
[0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1] => [1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1]
์ด๋ฐ์์ผ๋ก ์ทจ์ฝ์ ํ์ ์์๋ฅผ ๋ฐ๊ฟ์ฃผ๋ฉด ๋๋ค.
๋ง์ง๋ง์ผ๋ก ์ทจ์ฝ์ ์ ํ์ํ๋ ๋ฐฉ๋ฒ์ด๋ค.
์ ๊ฒ์ ์์ํ ์น๊ตฌ(dist์ ํ๋)๋ฅผ ๊บผ๋ด๊ณ ์ทจ์ฝ์ ๋ฆฌ์คํธ๋ฅผ ํ์ํ๋ค.
์ทจ์ฝ์ ๋ฆฌ์คํธ์์ 1์ ๋ง๋๋ฉด ์ ๊ฒ์์.
์น๊ตฌ๊ฐ ์ ๊ฒ ๊ฐ๋ฅํ ๊ธธ์ด๋งํผ ์ทจ์ฝ์ ๋ฆฌ์คํธ๋ฅผ ๊ฑด๋๋ฐ๊ณ ๋ค๋ฅธ ์น๊ตฌ๋ฅผ ๋ถ๋ฅธ๋ค.
์ข ๋ฃ ์กฐ๊ฑด
- ์ ๊ฒํ๊ณ ๊ฑด๋๋ฐ์๋๋ฐ ๋ฒฝ์ด ๋๋ ๊ฒฝ์ฐ O
- ๋ฒฝ์ด ๋๋์ง ์์์ ์น๊ตฌ๋ฅผ ๋ณด๋๋๋ฐ ๋์ด์ ์ทจ์ฝ์ ์ด ์๋ ๊ฒฝ์ฐ O
- ์น๊ตฌ๋ฅผ ๋ค ํฌ์ ํ์ง๋ง ์์ง ์ทจ์ฝ์ ์ด ๋จ์์๋ ๊ฒฝ์ฐ X
๐จ ์์ ํ์์ผ๋ก ๋ง ์ฝ๋๋ฅผ ์งฐ๋๋ฐ ํด๊ฒฐ๋๋ค. ์ฌ๊ธฐ์ ์ข ๋ ๋ค๋ฌ๊ณ ์ถ์ง๋ง ์ฝ๋ฉํ ์คํธ๊ฐ ์ฝ์์ด๋ผ ์๋ฒฝํ๊ฒ ๋ค๋ฌ์ง๋ ๋ชปํ๋ค. ์๋ง ์ฌ๊ธฐ์ ์๊ฐ์ ์ค์ผ ์ ์๋ ๋ถ๋ถ์ด ๋ง์ด ์์ ๊ฒ์ด๋ค.( ํ์ง๋ง ์ด ์ฝ๋๋ก๋ ์ถฉ๋ถํ ํต๊ณผ ๊ฐ๋ฅ )
๐ป์์ค ์ฝ๋
from itertools import permutations
# ์ธ๋ฒฝ์ ์ ๊ฒํ ์์๋ฅผ ๊ฒฐ์ ํ๋ ๊ฒ
def lotation_wall(wall):
for i in range(len(wall)):
if wall[i] == 1:
return wall[i+1:]+wall[:i+1]
# ์ธ๋ฒฝ ์๋ฆฌ
def repair(dist_permu, wall):
idx = 0 # ๋ฒฝ์ ์ธ๋ฑ์ค
for i in range(len(dist_permu)):
dist = dist_permu[i] # ์ ๊ฒํ ์น๊ตฌ๋ฅผ ํ๋ ๊บผ๋ด์
while idx < len(wall):
if wall[idx] == 1: # ์ทจ์ฝ์ ์ ๋ง๋๋ฉด
idx += dist + 1 # ๋ค์ ์ทจ์ฝ์ ์ผ๋ก ๊ฑด๋ ๋ด๋ค.
# ๋ง์ง๋ง ์ธ๋ฒฝ ์ ๊ฒ
if idx >= len(wall): # ๊ฑด๋ ๋ฐ์๋๋ฐ ์ทจ์ฝ์ ์ด ๋ ์ด์ ์์ผ๋ฉด ๋ค ์ ๊ฒํ์ผ๋ฏ๋ก ๋
return i + 1
break # ์ด๋ฒ ์น๊ตฌ๋ ์ ๊ฒ์ ๋ง์ณค์ผ๋ฏ๋ก ๋ค์ ์น๊ตฌ๊ฐ ์ค๊ธฐ ์ํด์ ์ ๊ฒ while ๋ฌธ์ ๋๋ธ๋ค.
idx += 1
else:
# ๋ง์ง๋ง์ธ์ค ๋ชจ๋ฅด๊ณ ์น๊ตฌํ๋ช
๋ ํฌ์
์์ผฐ์ ๋
# ์น๊ตฌ๊ฐ ์ ๊ฒํ๋ฌ ๋๊ฐ๋๋ฐ ๋ ์ด์ ์ทจ์ฝ์ ์ด ์์ ๋
return i
else:
# ์น๊ตฌ ๋ค ํฌ์
ํ๋๋ฐ ์ ๊ฒ ๋๋ด์ง ๋ชปํจ
# ์ทจ์ฝ์ ์ด ์์ง ๋จ์์ ๋
return 10
def solution(n, weak, dist):
# ์ทจ์ฝ์ ๋์ดํ๊ธฐ
wall = [0]*n
for w in weak:
wall[w] = 1
# ๊ฒฐ๊ณผ ๊ฐ๋ค ์ ์ฅ
result = []
# ๊ณ ์น ์์ ์ ํ๊ธฐ
length_dist = len(dist)
for d in permutations(dist, length_dist):
# ์ฒ์ ์ทจ์ฝ ์ ์์๋ก ํ์
re_wall = wall
result.append(repair(d, re_wall))
# ์ทจ์ฝ ์ ์์๋ฅผ ๋ฐ๊ฟ๊ฐ๋ฉฐ ํ์
for i in range(length_dist):
re_wall = lotation_wall(re_wall)
result.append(repair(d, re_wall))
# ๊ฒฐ๊ณผ ์ค์์ ๊ฐ์ฅ ์์ ๊ฐ ์ ํ
answer = min(result)
# ๋ง์ฝ ์์ ๊ฐ์ด 10(์ธ๋ฒฝ์ ๊ฒ์คํจ)๋ผ๋ฉด -1 ๋ฐํ
if answer == 10:
answer = -1
return answer
๐๋ฌธ์ ํ์ธ
์ถ์ฒ: ํ๋ก๊ทธ๋๋จธ์ค
๋งํฌ: https://programmers.co.kr/learn/courses/30/lessons/60062
๋ฌธ์ ์ค๋ช
๋ ์คํ ๋์ ์ด์ํ๊ณ ์๋ ์ค์นดํผ๋ ๋ ์คํ ๋ ๋ด๋ถ๊ฐ ๋๋ฌด ๋ก์ ์น๊ตฌ๋ค๊ณผ ํจ๊ป ์ง์ ๋ฆฌ๋ชจ๋ธ๋ง ํ๊ธฐ๋ก ํ์ต๋๋ค. ๋ ์คํ ๋์ด ์๋ ๊ณณ์ ์ค๋ ธ์ฐํ์ด์ผ๋ก ๋งค์ฐ ์ถ์ด ์ง์ญ์ด์ด์ ๋ด๋ถ ๊ณต์ฌ๋ฅผ ํ๋ ๋์ค์ ์ฃผ๊ธฐ์ ์ผ๋ก ์ธ๋ฒฝ์ ์ํ๋ฅผ ์ ๊ฒํด์ผ ํ ํ์๊ฐ ์์ต๋๋ค.
๋ ์คํ ๋์ ๊ตฌ์กฐ๋ ์์ ํ ๋๊ทธ๋ ๋ชจ์์ด๊ณ ์ธ๋ฒฝ์ ์ด ๋๋ ๋ n๋ฏธํฐ์ด๋ฉฐ, ์ธ๋ฒฝ์ ๋ช๋ช ์ง์ ์ ์ถ์๊ฐ ์ฌํ ๊ฒฝ์ฐ ์์๋ ์๋ ์๋ ์ทจ์ฝํ ์ง์ ๋ค์ด ์์ต๋๋ค. ๋ฐ๋ผ์ ๋ด๋ถ ๊ณต์ฌ ๋์ค์๋ ์ธ๋ฒฝ์ ์ทจ์ฝ ์ง์ ๋ค์ด ์์๋์ง ์์๋ ์ง, ์ฃผ๊ธฐ์ ์ผ๋ก ์น๊ตฌ๋ค์ ๋ณด๋ด์ ์ ๊ฒ์ ํ๊ธฐ๋ก ํ์ต๋๋ค. ๋ค๋ง, ๋น ๋ฅธ ๊ณต์ฌ ์งํ์ ์ํด ์ ๊ฒ ์๊ฐ์ 1์๊ฐ์ผ๋ก ์ ํํ์ต๋๋ค. ์น๊ตฌ๋ค์ด 1์๊ฐ ๋์ ์ด๋ํ ์ ์๋ ๊ฑฐ๋ฆฌ๋ ์ ๊ฐ๊ฐ์ด๊ธฐ ๋๋ฌธ์, ์ต์ํ์ ์น๊ตฌ๋ค์ ํฌ์ ํด ์ทจ์ฝ ์ง์ ์ ์ ๊ฒํ๊ณ ๋๋จธ์ง ์น๊ตฌ๋ค์ ๋ด๋ถ ๊ณต์ฌ๋ฅผ ๋๋๋ก ํ๋ ค๊ณ ํฉ๋๋ค. ํธ์ ์ ๋ ์คํ ๋์ ์ ๋ถ ๋ฐฉํฅ ์ง์ ์ 0์ผ๋ก ๋ํ๋ด๋ฉฐ, ์ทจ์ฝ ์ง์ ์ ์์น๋ ์ ๋ถ ๋ฐฉํฅ ์ง์ ์ผ๋ก๋ถํฐ ์๊ณ ๋ฐฉํฅ์ผ๋ก ๋จ์ด์ง ๊ฑฐ๋ฆฌ๋ก ๋ํ๋ ๋๋ค. ๋, ์น๊ตฌ๋ค์ ์ถ๋ฐ ์ง์ ๋ถํฐ ์๊ณ, ํน์ ๋ฐ์๊ณ ๋ฐฉํฅ์ผ๋ก ์ธ๋ฒฝ์ ๋ฐ๋ผ์๋ง ์ด๋ํฉ๋๋ค.
์ธ๋ฒฝ์ ๊ธธ์ด n, ์ทจ์ฝ ์ง์ ์ ์์น๊ฐ ๋ด๊ธด ๋ฐฐ์ด weak, ๊ฐ ์น๊ตฌ๊ฐ 1์๊ฐ ๋์ ์ด๋ํ ์ ์๋ ๊ฑฐ๋ฆฌ๊ฐ ๋ด๊ธด ๋ฐฐ์ด dist๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ทจ์ฝ ์ง์ ์ ์ ๊ฒํ๊ธฐ ์ํด ๋ณด๋ด์ผ ํ๋ ์น๊ตฌ ์์ ์ต์๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- n์ 1 ์ด์ 200 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
- weak์ ๊ธธ์ด๋ 1 ์ด์ 15 ์ดํ์
๋๋ค.
- ์๋ก ๋ค๋ฅธ ๋ ์ทจ์ฝ์ ์ ์์น๊ฐ ๊ฐ์ ๊ฒฝ์ฐ๋ ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- ์ทจ์ฝ ์ง์ ์ ์์น๋ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์ฃผ์ด์ง๋๋ค.
- weak์ ์์๋ 0 ์ด์ n - 1 ์ดํ์ธ ์ ์์ ๋๋ค.
- dist์ ๊ธธ์ด๋ 1 ์ด์ 8 ์ดํ์
๋๋ค.
- dist์ ์์๋ 1 ์ด์ 100 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
- ์น๊ตฌ๋ค์ ๋ชจ๋ ํฌ์ ํด๋ ์ทจ์ฝ ์ง์ ์ ์ ๋ถ ์ ๊ฒํ ์ ์๋ ๊ฒฝ์ฐ์๋ -1์ return ํด์ฃผ์ธ์.
์ ์ถ๋ ฅ ์
nweakdistresult
12 | [1, 5, 6, 10] | [1, 2, 3, 4] | 2 |
12 | [1, 3, 4, 9, 10] | [3, 5, 7] | 1 |
์ ์ถ๋ ฅ ์์ ๋ํ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
์ํ ๋ ์คํ ๋์์ ์ธ๋ฒฝ์ ์ทจ์ฝ ์ง์ ์ ์์น๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์น๊ตฌ๋ค์ ํฌ์ ํ๋ ์์ ์ค ํ๋๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- 4m๋ฅผ ์ด๋ํ ์ ์๋ ์น๊ตฌ๋ 10m ์ง์ ์์ ์ถ๋ฐํด ์๊ณ๋ฐฉํฅ์ผ๋ก ๋์ 1m ์์น์ ์๋ ์ทจ์ฝ ์ง์ ์์ ์ธ๋ฒฝ ์ ๊ฒ์ ๋ง์นฉ๋๋ค.
- 2m๋ฅผ ์ด๋ํ ์ ์๋ ์น๊ตฌ๋ 4.5m ์ง์ ์์ ์ถ๋ฐํด 6.5m ์ง์ ์์ ์ธ๋ฒฝ ์ ๊ฒ์ ๋ง์นฉ๋๋ค.
๊ทธ ์ธ์ ์ฌ๋ฌ ๋ฐฉ๋ฒ๋ค์ด ์์ง๋ง, ๋ ๋ช ๋ณด๋ค ์ ์ ์น๊ตฌ๋ฅผ ํฌ์ ํ๋ ๋ฐฉ๋ฒ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์น๊ตฌ๋ฅผ ์ต์ ๋ ๋ช ํฌ์ ํด์ผ ํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
์ํ ๋ ์คํ ๋์์ ์ธ๋ฒฝ์ ์ทจ์ฝ ์ง์ ์ ์์น๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
7m๋ฅผ ์ด๋ํ ์ ์๋ ์น๊ตฌ๊ฐ 4m ์ง์ ์์ ์ถ๋ฐํด ๋ฐ์๊ณ ๋ฐฉํฅ์ผ๋ก ์ ๊ฒ์ ๋๋ฉด ๋ชจ๋ ์ทจ์ฝ ์ง์ ์ ์ ๊ฒํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์น๊ตฌ๋ฅผ ์ต์ ํ ๋ช ํฌ์ ํ๋ฉด ๋ฉ๋๋ค.
'Algorithm Problem > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[python] ๋ฐฑ์ค - 1926. ๊ทธ๋ฆผ (0) | 2020.09.08 |
---|---|
[python] ๋ฐฑ์ค - 1743. ์์๋ฌผ ํผํ๊ธฐ (0) | 2020.09.07 |
[python] ๋ฐฑ์ค - 11052. ์นด๋ ๊ตฌ๋งคํ๊ธฐ / 16194. ์นด๋ ๊ตฌ๋งคํ๊ธฐ 2 (0) | 2020.09.05 |
[python] ๋ฐฑ์ค - 1722. ์์ด์ ์์ (0) | 2020.09.04 |
[python] ๋ฐฑ์ค - 2240. ์๋๋๋ฌด (0) | 2020.09.03 |