
WIL: Weekly I Learned; ๋๋ What I Learned This Week
4์์ ์ ๊ธ์ ๊ฑฐ์ง๋ง

์ง๋ 2์ฃผ์ฐจ WIL์ ์์ฑํ๊ธฐ๊ฐ ๋ฌด์ญ๊ฒ ์ ๊ธ์ด ๋ ๋ค์ ๋๋ฐญ์ด ๋์์ต๋๋ค. ์ ๋ ๋์ ์ฐธ ์ข์ํ์ง๋ง, ๊ทธ๋ผ์๋ ์ ํฌ ๋ฐ ์น๊ตฌ๊ฐ ์ด์ผ๊ธฐํ ๊ฒ๊ณผ ๊ฐ์ด ์ง๊ธ ์ฝ๋ฉ์ ํ ๋๊ฐ ๋ง์๊น?๋ผ๋ ์๊ฐ์ด ๋ค๊ธฐ๋ ํ๋ ์ฃผ์์ต๋๋ค. ๊ธฐํ ๋ณํ๋ ์ฐธ ๋ฌด์์ด ๊ฒ์ ๋๋ค.
๋ฐฅ๋ง ์ ๋จน๋๋ผ

ํฌ๋ํํค์ ๊ตฌ๋ด์๋น์ด ์์ฃผ ์ ๋์ค๋ ๊ฒ์ผ๋ก ์ ํ์ด ๋ ์์ต๋๋ค. ์ ์ ๋น์ ๊ทธ๊ฑธ ๋ชจ๋ฅด๋ ๊ฒ์ ์๋์์ง๋ง, ์ ๊ฐ ๊ฐ๋ ๊ณณ์ ํฌ๋ํํค ๋ณธ์ฌ๊ฐ ์๋ ์ ๊ธ ์บ ํผ์ค์ด๋, ์ฌ์ค ํฐ ๊ธฐ๋๋ ํ์ง ์์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ ์ 3์ฃผ์ฐจ๋ฅผ ๋๊ธฐ๋ ์ด ์์ ์์ ์ ๊ฐ ๋จ๊ธธ ์ ์๋ ๋ง์, ์ฌ๊ธฐ ๋ฐฅ๋ ์๋นํ ๋ง์๋ค์ ๋๋ค. ์ ์ ์ฒซ ๋ฉฐ์น ๊ฐ์ ์ผ๋ถ ๋ฉ๋ด๊ฐ (์ ์ ๋ง์๋) ๋ค์๊ฐ ๋งค์ ๊ฑฑ์ ์ด ์ด์ง ๋ค๊ธฐ๋ ํ์ต๋๋ค๋ง ์ด๋ ์๊ฐ๋ถํฐ ๋งค์ด ๋ง์ด ์ ์ ๋ฉ๋ ๊ฐ๋ฅํ ์์ค์ผ๋ก ๋ด๋ ค์ค๋๊ตฐ์. ์๋นํ ๋ง์กฑ์ค๋ฝ์ต๋๋ค.
3์ฃผ์ฐจ์ ์ ํฌ๊ฐ ํํํ ๋ด์ฉ์ ํฌ๊ฒ ์ธ ๊ฐ์ง๋ก ๋๋ ์ ์์ต๋๋ค.
์๋ฃ๊ตฌ์กฐ:
- ๊ทธ๋ํ (๋ ธ๋, ์์ง, ๊ฐ์ค์น, ๋ฐฉํฅ์ฑ ๋ฑ)
- ํธ๋ฆฌ
- Trie
- B-ํธ๋ฆฌ (B-Tree)
์๊ณ ๋ฆฌ์ฆ:
- DFS
- BFS
- Disjoint Set (์ ๋์จ-ํ์ธ๋ ๊ธฐ๋ฒ)
- ์ด๋ถ ๊ทธ๋ํ
- ์ต์ ์ ์ฅ ํธ๋ฆฌ (ํ๋ฆผ, ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ)
- ์์ ์ ๋ ฌ
- ์ต์ ๋น์ฉ ๊ณ์ฐ (๋ค์ต์คํธ๋ผ, ํ๋ฃจ์ด๋-์์ฌ ์๊ณ ๋ฆฌ์ฆ)
๋ง์ง๋ง์ผ๋ก CS:APP ์ฑ ์์๋ ์ฑํฐ 1 (๊ฐ์)์ ๋คํธ์ํฌ, ์๋ฌ์ ๋ฒ์น, ๋์์ฑ, ๋ณ๋ ฌ์ฑ, ์ถ์ํ ๊ฐ๋ ์ ๋ํด ํ์ตํ์์ต๋๋ค.
์ด๋ฒ ์ํ์ ๋ฐฑ์ค "๋ฐ๋ฅ ์ฅ์", "๋จ์๋ฒํธ๋ถ์ด๊ธฐ", "๊ฒฝ์์ ์ ์ผ"์ผ๋ก, 1๋ฒ์ BFS๋ก ํ๋ ค๋ค๊ฐ 30๋ถ์ ๋ ๋ ค๋จน๊ณ ์๋์ ๊ฐ์ ํฐ๋ฌด๋์์ด ๊ฐ๋จํ ์ด์ค for๋ฌธ์ ํตํด ์์ฑํ์ฌ ์ ์ถํ์์ต๋๋ค. (๋๋๊ฒ๋ ํต๊ณผ๊ฐ ๋ฉ๋๋ค!)
import sys
input=sys.stdin.readline
def is_within_bounds(row, col):
global rows_n, cols_n
return (0<=row<rows_n) and (0<=col<cols_n)
def kazari():
global rows_n,cols_n,visited,yuka,count
for i in range(rows_n):
for j in range(cols_n):
if yuka[i][j] == '-':
if j == 0 or yuka[i][j-1] != '-':
count += 1
elif yuka[i][j] == '|':
if i == 0 or yuka[i-1][j] != '|':
count += 1
# ์
๋ ฅ & ์ธํ
rows_n, cols_n = map(int,input().split()) # N, M
yuka = [input().strip() for _ in range(rows_n)]
count = 0
# ๊ณ์ฐ & ์ถ๋ ฅ
kazari()
print(count)

์ด๋ฒ ์ฃผ์ฐจ์ ๋ฐฐ์ ๋ ๊ฒ DFS, BFS ๊ฐ์ ๊ฒ๋ค์ด๋ผ ์ํ์๋ ๋น์ฐํ ์ด๋ฅผ ์ ์ฉํด๋ณด๋ ค ํ์๋๋ฐ, ๊ฒฐ๊ตญ ์ ๋๋ก ๋ ๊ฒฐ๊ณผ๊ฐ ๋์ค์ง ์์ ์์ ๊ฐ์ด ํ๊ณ ๋ง์๋ ๊ฒ์ ๋๋ค. ์ฌ์ค ์ด๊ฒ๋ง ํด๋ ์ฅ์กฑ์ ๋ฐ์ ์์ ๋ถ๋ช ํฉ๋๋ค. ๋ง์ฝ ์ ์ํ๊ธฐ ์ ์ ์ ์๊ฒ ์ด ๋ฌธ์ ๋ฅผ ํ๋ผ๊ณ ์์ผฐ๋ค๋ฉด ์๋ง ๋ชป ํ๊ฑฐ๋, ์ ์ด๋ ์ด๋ฐ ๊น๋ํ ๋ต์์ ๋ด์ง ๋ชปํ์ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ๋๋ค.
์ฐธ๊ณ ๋ก ์ ๋ฌธ์ ๋ ๋ถ๋ฆฌ ์งํฉ (disjoint sets)์ ์ ๋์ธ-ํ์ธ๋ ๋ฐฉ์์ผ๋ก๋ ํ ์ ์์ต๋๋ค.
import sys
input = sys.stdin.readline
def find(parent, x):
if parent[x] != x:
parent[x] = find(parent, parent[x])
return parent[x]
def union(parent, a, b):
root_a = find(parent, a)
root_b = find(parent, b)
if root_a != root_b:
parent[root_b] = root_a
# ์
๋ ฅ & ์ธํ
n, m = map(int, input().split())
yuka = [list(input().strip()) for _ in range(n)]
# ๊ฐ ์
์ ํ๋์ ๋
ธ๋๋ก ํํ (0๋ฒ๋ถํฐ n*m-1๋ฒ๊น์ง)
parent = [i for i in range(n * m)]
for i in range(n):
for j in range(m):
index = i * m + j
if yuka[i][j] == '-':
if j + 1 < m and yuka[i][j + 1] == '-':
union(parent, index, i * m + (j + 1))
elif yuka[i][j] == '|':
if i + 1 < n and yuka[i + 1][j] == '|':
union(parent, index, (i + 1) * m + j) # ๊ฐ์ ๋ฐฉํฅ์ ์ด์๊ณผ union ์ฒ๋ฆฌ
unique_roots = set() # ๋ชจ๋ ํ์ผ์ ๋ํด ๋ฃจํธ ์ฐพ๊ธฐ
for i in range(n * m):
unique_roots.add(find(parent, i))
print(len(unique_roots))
์ด์จ๋ ์ด ๋ฌธ์ ์ ๋จ์๋ฒํธ๋ถ์ด๊ธฐ, ์ด 2๊ฐ์ ๋ฌธ์ ๋ฅผ ํ์ด๋๋ค๋ ์ ์ ์ข์ง๋ง์๋, ๋ง์ง๋ง ๋ฌธ์ ์ ๋ต์์ ๋ฏธ์ฒ ์์ฑํ์ง ๋ชปํ ๊ฒ์ ์์ฝ๊ธฐ๋ ํ๊ณ , ๊ทธ๋ผ์๋ ๋ถ๊ณผ 3์ฃผ๋ผ๋ ์งง์ ๊ธฐ๊ฐ์๋ ์์ผ ๋ง์ ๊ฒ์ ๋ฐฐ์ ๋ค๋ ๊ฒ์ ๋๋ผ๊ฒ ํ ์ฃผ์์ต๋๋ค.
'๋์ ์ด์ผ๊ธฐ > ํฌ๋ํํค ์ ๊ธ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํฌ๋ํํค ์ ๊ธ 2์ฃผ์ฐจ WIL (0) | 2025.03.27 |
---|---|
ํฌ๋ํํค ์ ๊ธ 1์ฃผ์ฐจ WIL (2) | 2025.03.20 |
ํฌ๋ํํค ์ ๊ธ ์ ์ ํ๊ธฐ & 3๋ฐ4์ผ ๋ฏธ๋ํ๋ก์ ํธ & WIL & ์บ ํผ์ค ์ ๊ฒฝ (2) | 2025.03.13 |
์๋ ํ์ธ์.
ํฌ์คํ ์ด ์ข์๋ค๋ฉด "์ข์์โค๏ธ" ๋๋ "๊ตฌ๋ ๐๐ป" ํด์ฃผ์ธ์!