๋ฌธ์ ์ค๋ช
๋ธ๋ผ์ธ๋ ๊ณต์ฑ๋ฅผ ํต๊ณผํ ์ ์
์ฌ์ ๋ผ์ด์ธ์ ์ ๊ท ๊ฒ์ ๊ฐ๋ฐ ์
๋ฌด๋ฅผ ๋งก๊ฒ ๋์๋ค. ์ด๋ฒ์ ์ถ์ํ ๊ฒ์ ์ ๋ชฉ์ "ํ๋ ์ฆ4๋ธ๋ก".
๊ฐ์ ๋ชจ์์ ์นด์นด์คํ๋ ์ฆ ๋ธ๋ก์ด 2×2 ํํ๋ก 4๊ฐ๊ฐ ๋ถ์ด์์ ๊ฒฝ์ฐ ์ฌ๋ผ์ง๋ฉด์ ์ ์๋ฅผ ์ป๋ ๊ฒ์์ด๋ค.
๋ง์ฝ ํ์ด ์์ ๊ฐ์ด ์ฃผ์ด์ง ๊ฒฝ์ฐ, ๋ผ์ด์ธ์ด 2×2๋ก ๋ฐฐ์น๋ 7๊ฐ ๋ธ๋ก๊ณผ ์ฝ์ด 2×2๋ก ๋ฐฐ์น๋ 4๊ฐ ๋ธ๋ก์ด ์ง์์ง๋ค. ๊ฐ์ ๋ธ๋ก์ ์ฌ๋ฌ 2×2์ ํฌํจ๋ ์ ์์ผ๋ฉฐ, ์ง์์ง๋ ์กฐ๊ฑด์ ๋ง์กฑํ๋ 2×2 ๋ชจ์์ด ์ฌ๋ฌ ๊ฐ ์๋ค๋ฉด ํ๊บผ๋ฒ์ ์ง์์ง๋ค.
๋ธ๋ก์ด ์ง์์ง ํ์ ์์ ์๋ ๋ธ๋ก์ด ์๋๋ก ๋จ์ด์ ธ ๋น ๊ณต๊ฐ์ ์ฑ์ฐ๊ฒ ๋๋ค.
๋ง์ฝ ๋น ๊ณต๊ฐ์ ์ฑ์ด ํ์ ๋ค์ 2×2 ํํ๋ก ๊ฐ์ ๋ชจ์์ ๋ธ๋ก์ด ๋ชจ์ด๋ฉด ๋ค์ ์ง์์ง๊ณ ๋จ์ด์ง๊ณ ๋ฅผ ๋ฐ๋ณตํ๊ฒ ๋๋ค.
์ ์ด๊ธฐ ๋ฐฐ์น๋ฅผ ๋ฌธ์๋ก ํ์ํ๋ฉด ์๋์ ๊ฐ๋ค.
TTTANT
RRFACC
RRRFCC
TRRRAA
TTMMMF
TMMTTJ
๊ฐ ๋ฌธ์๋ ๋ผ์ด์ธ(R), ๋ฌด์ง(M), ์ดํผ์น(A), ํ๋ก๋(F), ๋ค์ค(N), ํ๋ธ(T), ์ ์ด์ง(J), ์ฝ(C)์ ์๋ฏธํ๋ค
์ ๋ ฅ์ผ๋ก ๋ธ๋ก์ ์ฒซ ๋ฐฐ์น๊ฐ ์ฃผ์ด์ก์ ๋, ์ง์์ง๋ ๋ธ๋ก์ ๋ชจ๋ ๋ช ๊ฐ์ธ์ง ํ๋จํ๋ ํ๋ก๊ทธ๋จ์ ์ ์ํ๋ผ.
์ ๋ ฅ ํ์
- ์ ๋ ฅ์ผ๋ก ํ์ ๋์ด m, ํญ n๊ณผ ํ์ ๋ฐฐ์น ์ ๋ณด board๊ฐ ๋ค์ด์จ๋ค.
- 2 โฆ n, m โฆ 30
- board๋ ๊ธธ์ด n์ธ ๋ฌธ์์ด m๊ฐ์ ๋ฐฐ์ด๋ก ์ฃผ์ด์ง๋ค. ๋ธ๋ก์ ๋ํ๋ด๋ ๋ฌธ์๋ ๋๋ฌธ์ A์์ Z๊ฐ ์ฌ์ฉ๋๋ค.
์ถ๋ ฅ ํ์
์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ํ ์ ๋ณด๋ฅผ ๊ฐ์ง๊ณ ๋ช ๊ฐ์ ๋ธ๋ก์ด ์ง์์ง์ง ์ถ๋ ฅํ๋ผ.
์ ์ถ๋ ฅ ์์
์์ ์ ๋ํ ์ค๋ช
- ์ ์ถ๋ ฅ ์์ 1์ ๊ฒฝ์ฐ, ์ฒซ ๋ฒ์งธ์๋ A ๋ธ๋ก 6๊ฐ๊ฐ ์ง์์ง๊ณ , ๋ ๋ฒ์งธ์๋ B ๋ธ๋ก 4๊ฐ์ C ๋ธ๋ก 4๊ฐ๊ฐ ์ง์์ ธ, ๋ชจ๋ 14๊ฐ์ ๋ธ๋ก์ด ์ง์์ง๋ค.
- ์ ์ถ๋ ฅ ์์ 2๋ ๋ณธ๋ฌธ ์ค๋ช ์ ์๋ ๊ทธ๋ฆผ์ ์ฎ๊ธด ๊ฒ์ด๋ค. 11๊ฐ์ 4๊ฐ์ ๋ธ๋ก์ด ์ฐจ๋ก๋ก ์ง์์ง๋ฉฐ, ๋ชจ๋ 15๊ฐ์ ๋ธ๋ก์ด ์ง์์ง๋ค.
ํ์ด ์ฝ๋
def check(m, n, board):
filter = [[0 for _ in range(n)] for _ in range(m)]
count = 0
# check can delete
for i in range(m-1):
for j in range(n-1):
a = board[i][j]
b = board[i][j+1]
c = board[i+1][j]
d = board[i+1][j+1]
if a == b == c == d and a != '0':
filter[i][j], filter[i][j+1], filter[i+1][j], filter[i+1][j+1] = 1, 1, 1, 1
for i in range(m):
for j in range(n):
if filter[i][j] == 1:
count += 1
board[i][j] = '0'
if count == 0:
return 0
# fill blank
for i in range(m-2, -1, -1):
for j in range(n):
k = i
while 0 <= k+1 < m and board[k+1][j] == '0':
k += 1
if k != i:
board[k][j] = board[i][j]
board[i][j] = '0'
return count
def solution(m, n, board):
answer = 0
board = list(map(list, board))
while True:
temp = check(m, n, board)
if temp == 0:
break
answer += temp
return answer
๊ตฌํ ๋ฌธ์ ์ด๋ค.
์ฒ์ ๊ตฌํ ๋ฌธ์ ๋ฅผ ์ ํ ์ฌ๋๋ค์ ์ด๋ ค์ธ ์ ์์ง๋ง, 2048 ๋ฌธ์ ๋ฅผ ํ ๋ฒ์ด๋ผ๋ ํ์ด๋ณธ ์ ์ด ์๊ฑฐ๋, ๋ฐฑ์ค ๊ณจ๋๊ธ ๊ตฌํ ๋ฌธ์ ๋ ์ผ์ฑ ๊ธฐ์ถ์ ๋ง์ด ํ์ด๋ณธ ์ฌ๋๋ค์ ์ฝ๊ฒ ํ ์ ์์ ๊ฒ์ด๋ค.
์ฝ๋๋ฅผ ํ์ด์ ๋ณด์.
board = list(map(list, board))
์ฐ์ , ๋ณด๋ ๋ฆฌ์คํธ ๋ด์ ๋ฌธ์์ด๋ก ์ ์ฅ์ด ๋์ด์๋๋ฐ, ๋ฌธ์์ด ๋ด๋ถ์ ์์๋ฅผ ์์ ํด์ผ ํ ์ผ์ด ์๋ค.
๋ธ๋ก์ด ํฐ์ง ํ, ์๋๋ก ๋ด๋ ค๊ฐ์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค.
ํ์ง๋ง ๋ฌธ์์ด ์ํ๋ก ์กด์ฌํ๋ฉด ์ธ๋ฑ์ค๋ก ์ ๊ทผํด ๊ฐ์ ์์ ํ๊ธฐ ์ด๋ ต๊ธฐ ๋๋ฌธ์,
board๋ฅผ 2์ค ๋ฐฐ์ด๋ก ๋ณํํ๋ค.
check ํจ์๊ฐ ํ๋ ์ญํ ์ ๋ค์๊ณผ ๊ฐ๋ค.
1) ๋ด๋ถ์ 2x2 ๋ธ๋ก์ด ํฐ์ง ๊ฒ์ด ์๋์ง ํ์ธ
2) ํฐ์ง ์ ์๋ ๋ธ๋ก board์ ์ ์ฉํ๊ณ , ํฐ์ง ๋ธ๋ก์ ๊ฐฏ์ ์ธ๊ธฐ
3) ํฐ์ง๊ณ ๋จ์ ๋น ๊ณต๊ฐ์ ๋ํด ๊ณต๋ฐฑ์ ๋ฉ๊พธ๋ ์์ ํ board์ ๊ฐฑ์
4) ํฐ์ง ๋ธ๋ก์ ๊ฐฏ์ ๋ฆฌํด
ํฐ์ง ์ ์๋ ๋ธ๋ก์ ์๋ก ๊ฒน์น ์ ์๋ ์ํ์ด๋ค.
2x2์ฉ ๊ณ์ ๋๋ฉด์ ๊ทธ๋ ๊ทธ๋ ํฐ๋จ๋ฆฌ๊ฒ ๋๋ฉด, ํฐ์ง ์ ์๋ ๊ฒน์น ๋ธ๋ก์ ํฐ์ง์ง ์๊ฒ ๋ฐ์๋ ์ ์๋ค.
์๊ฐ ๋ณต์ก๋๊ฐ ๋ ๋์ค๋๋ผ๋, ํฐ๋จ๋ฆด ์ ์๋ ๋ธ๋ก์ ๋ํด์ filter ๋ณ์๋ฅผ ํตํด ๋งํน์ ํด๋๊ณ ,
ํ ๋ฒ์ ํฐ๋จ๋ฆฐ๋ค.
์ด๋ ํฐ๋จ๋ฆฐ ๋ธ๋ก์ ๊ฐฏ์๋ฅผ ์ธ์ด๋๋๋ค.
๋ธ๋ก์ ์ ์ผ ์๋๋ก ๋ด๋ฆฌ๋ ๋ฐฉ๋ฒ์,
์ ์ผ ์๋์์ ๋ ๋ฒ์งธ ํ๋ถํฐ ์ฒดํฌํ๋ค.
์ ์ผ ์๋๋ ๋ด๋ ค๊ฐ ๊ณต๊ฐ์ด ์๊ธฐ ๋๋ฌธ์ด๋ค.
์์ ์ ๋ธ๋ก ๋ฐ์ '0'์ผ๋ก ์ฑ์์ ธ์๊ณ , '0'์ด ์๋ ๊ฒ์ด ๋์ค๊ฑฐ๋ ๋ฐ๋ฅ์ด ๋์ฌ ๋๊น์ง k ๊ฐ์ ์ฌ๋ ค์ค๋ค.
๊ทธ ํ, ๋ฐ์ ๋ด๋ ค๊ฐ ์ ์๋ ์ํฉ์ด๋ผ๋ฉด ๊ฐ์ ๊ฐฑ์ ํด์ค๋ค.
๊ทธ ํ ์ ์ผ ์๋์์ ์ธ๋ฒ์งธ ํ, ๋ค ๋ฒ์งธ ํ ์์ผ๋ก ๋ชจ๋ ๊ฐฑ์ ํด์ฃผ๋ฉด ํ์ดํ ์ ์๋ค.
'๐ ์ฝ๋ฉํ ์คํธ ๋๋น : PS' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค] [3์ฐจ] n์ง์ ๊ฒ์ (level2, python) (0) | 2022.09.13 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค] ๋ฑ๊ตฃ๊ธธ (level3, python) (0) | 2022.09.13 |
[ํ๋ก๊ทธ๋๋จธ์ค] ํผ๋ก๋ (level2, python) (0) | 2022.09.13 |
[ํ๋ก๊ทธ๋๋จธ์ค] ๋จ์ด ๋ณํ (level3, python) (0) | 2022.09.13 |
[ํ๋ก๊ทธ๋๋จธ์ค] ์ฃผ์๊ฐ๊ฒฉ (level2, python) (1) | 2022.09.13 |