๋ฌธ์ ๋ถ์
์ฒซ ๋ฒ์งธ ๋จ๊ณ(๋ฌธ์ ์์ฝ ๋ฐ ์กฐ๊ฑด ํ์
)
๋ฐฉํฅ ์๋ ๊ทธ๋ํ๊ฐ ์ฃผ์ด์ก์๋, ์ฐ๊ฒฐ ์์์ ๊ฐ์๋ฅผ ๊ตฌํ๊ธฐ.
์
๋ ฅ
- ์ ์ ์ ๊ฐ์ N, ๊ฐ์ ์ ๊ฐ์ M(1 โค N โค 1,000, 0 โค M โค Nร(N-1)/2)
- M๊ฐ์ ์ค์ ๊ฐ์ ์ ์ ๋์ u, v๊ฐ ์ฃผ์ด์ง(1 โค u, v โค N, u โ v)
- ๊ฐ์ ๊ฐ์ ์ ํ ๋ฒ๋ง ์ฃผ์ด์ง.
์ถ๋ ฅ
- ์ฐ๊ฒฐ ์์์ ๊ฐ์ ์ถ๋ ฅ
๋ ๋ฒ์งธ ๋จ๊ณ (๋ฌธ์ ํต์ฌ ํ์
)
๋ฐฉํฅ ์๋ ๊ทธ๋ํ๋ ์ฆ, ์ํ์ฑ ๊ทธ๋ํ์ด๋ค.
์ฐ๊ฒฐ ์์๋ ๊ทธ๋ํ ๋ณ๋ก ๋ฉ์ด๋ฆฌ๋ก ๋์ด์๊ธฐ ๋๋ฌธ์, ๋ชจ๋ ๋
ธ๋๋ฅผ ๋ฐฉ๋ฌธํด์ฃผ์ด์ผ ํจ(์ด๋ ํ์ ์์๋ ์๊ด์ด ์์.)
๊ทธ๋ํ ํํ์โ ์ธ์ ํ๋ ฌ or ์ธ์ ๋ฆฌ์คํธ(์ธ์ ๋ฆฌ์คํธ(ํฌ์), ์ธ์ ํ๋ ฌ(๋ฐ์ง))
์ด๋ ์ต๋ ๊ฐ์ ์ ๊ฐ์๊ฐ Nร(N-1)/2์ธ๋ฐ, ์ด ๊ฐ์ ํฐ ๊ฐ(๋ฐ์ง)์ธ๊ฐ ์์ ๊ฐ(ํฌ์)์ธ๊ฐ?
u โ v์ด๋ฏ๋ก nC2์. nC2๋ ์์์ผ๋ก Nร(N-1)/2์ด๋ค. ์ด๋ N์ด 1000์ผ๋ ํฐ ๊ฐ์ด๋ฏ๋ก, ์ธ์ ํ๋ ฌ์ ์ฌ์ฉํ๋ค.
์ฝ๋ ์์ฑ
์ต์ข
์ฝ๋
import sys
input = sys.stdin.readline # n์ด ์ต๋๊ฐ์ผ ๊ฒฝ์ฐ์ ๋๋นํด ๋น ๋ฅธ ์
๋ ฅ
# RecursionError ๋ฐฉ์ง์ฉ
sys.setrecursionlimit(10 ** 8)
def dfs(now): # ํ์ฌ ๋
ธ๋
for nxt in range(n): # ๋ค์ ์ด
if graph[now][nxt] and not chk[nxt]: # ๊ทธ๋ํ๋ก ๊ฐ ์ ์๊ณ , ๋ฐฉ๋ฌธ์ ์ ํ์ ๊ฒฝ์ฐ
chk[nxt] = True # ๋ฐฉ๋ฌธ ์ฒดํฌ
dfs(nxt) # dfs ์คํ
n, m = map(int, input().split())
# ์ธ์ ํ๋ ฌ(N X N 2์ฐจ์ ๋ฆฌ์คํธ)
graph = [[0] * n for _ in range(n)] # 0-based
# ๊ฐ์
for _ in range(m):
u, v = map(lambda x: x - 1, map(int, input().split())) # 1-based to 0-based
graph[u][v] = 1 # ๊ฐ์ ์ผ๋ก ์ฐ๊ฒฐ๋ ๋
ธ๋์.
graph[v][u] = 1 # ๋ฌด๋ฐฉํฅ==์๋ฐฉํฅ
# for i, row in enumerate(graph):
# print(f'{i}: {row}')
ans = 0
# ๋ฐฉ๋ฌธ ์ฒดํฌ์ฉ
chk = [False] * n
for i in range(n):
if not chk[i]:
chk[i] = True
ans += 1
dfs(i) # dfs
print(ans)
์๋ ์ฝ๋๋ก ์ ์ถ ํ๋ฉด RecursionError ๊ฐ ๋ฐ์ํ๋ค.
ํ์ด์ฌ ๊ธฐ๋ณธ ์ฌ๊ท depth๋ฅผ ์ด๊ณผ(10*3)ํ๊ธฐ ๋๋ฌธ์ด๋ค.
๋ฐ๋ผ์, ์ต์ข
์ฝ๋์ธ ์์๋ depth๋ฅผ ๋๋ ค์ฃผ์๋ค.
RecursionError ๋ฐ์ ์ฝ๋
import sys
input = sys.stdin.readline # n์ด ์ต๋๊ฐ์ผ ๊ฒฝ์ฐ์ ๋๋นํด ๋น ๋ฅธ ์
๋ ฅ
def dfs(now): # ํ์ฌ ๋
ธ๋
for nxt in range(n): # ๋ค์ ์ด
if graph[now][nxt] and not chk[nxt]: # ๊ทธ๋ํ๋ก ๊ฐ ์ ์๊ณ , ๋ฐฉ๋ฌธ์ ์ ํ์ ๊ฒฝ์ฐ
chk[nxt] = True # ๋ฐฉ๋ฌธ ์ฒดํฌ
dfs(nxt) # dfs ์คํ
n, m = map(int, input().split())
# ์ธ์ ํ๋ ฌ(N X N 2์ฐจ์ ๋ฆฌ์คํธ)
graph = [[0] * n for _ in range(n)] # 0-based
# ๊ฐ์
for _ in range(m):
u, v = map(lambda x: x - 1, map(int, input().split())) # 1-based to 0-based
graph[u][v] = 1 # ๊ฐ์ ์ผ๋ก ์ฐ๊ฒฐ๋ ๋
ธ๋์.
graph[v][u] = 1 # ๋ฌด๋ฐฉํฅ==์๋ฐฉํฅ
# for i, row in enumerate(graph):
# print(f'{i}: {row}')
ans = 0
# ๋ฐฉ๋ฌธ ์ฒดํฌ์ฉ
chk = [False] * n
for i in range(n):
if not chk[i]:
chk[i] = True
ans += 1
dfs(i) # dfs
print(ans)

๋๋์
๊ทธ๋ํ ๋ฌธ์ ๋ dfs, bfs๋ก ์ ๊ทผํด์ผ ํจ์ ์๊ฒ ๋๋ฐ ์ ์ ํ๊ฒ ์ธ์ ๋ฆฌ์คํธ, ์ธ์ ํ๋ ฌ์ ์ ํํด ํธ๋ ๊ฒ์ ์ด๋ ค์ด ๊ฒ ๊ฐ๋ค.
๋ฌธ์ ๋ถ์
์ฒซ ๋ฒ์งธ ๋จ๊ณ(๋ฌธ์ ์์ฝ ๋ฐ ์กฐ๊ฑด ํ์ )
๋ฐฉํฅ ์๋ ๊ทธ๋ํ๊ฐ ์ฃผ์ด์ก์๋, ์ฐ๊ฒฐ ์์์ ๊ฐ์๋ฅผ ๊ตฌํ๊ธฐ.
์ ๋ ฅ
์ถ๋ ฅ
๋ ๋ฒ์งธ ๋จ๊ณ (๋ฌธ์ ํต์ฌ ํ์ )
๋ฐฉํฅ ์๋ ๊ทธ๋ํ๋ ์ฆ, ์ํ์ฑ ๊ทธ๋ํ์ด๋ค.
์ฐ๊ฒฐ ์์๋ ๊ทธ๋ํ ๋ณ๋ก ๋ฉ์ด๋ฆฌ๋ก ๋์ด์๊ธฐ ๋๋ฌธ์, ๋ชจ๋ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํด์ฃผ์ด์ผ ํจ(์ด๋ ํ์ ์์๋ ์๊ด์ด ์์.)
๊ทธ๋ํ ํํ์โ ์ธ์ ํ๋ ฌ or ์ธ์ ๋ฆฌ์คํธ(์ธ์ ๋ฆฌ์คํธ(ํฌ์), ์ธ์ ํ๋ ฌ(๋ฐ์ง))
์ด๋ ์ต๋ ๊ฐ์ ์ ๊ฐ์๊ฐ Nร(N-1)/2์ธ๋ฐ, ์ด ๊ฐ์ ํฐ ๊ฐ(๋ฐ์ง)์ธ๊ฐ ์์ ๊ฐ(ํฌ์)์ธ๊ฐ?
u โ v์ด๋ฏ๋ก nC2์. nC2๋ ์์์ผ๋ก Nร(N-1)/2์ด๋ค. ์ด๋ N์ด 1000์ผ๋ ํฐ ๊ฐ์ด๋ฏ๋ก,
์ธ์ ํ๋ ฌ์ ์ฌ์ฉํ๋ค.์ฝ๋ ์์ฑ
์ต์ข ์ฝ๋
์๋ ์ฝ๋๋ก ์ ์ถ ํ๋ฉด
RecursionError๊ฐ ๋ฐ์ํ๋ค.ํ์ด์ฌ ๊ธฐ๋ณธ ์ฌ๊ท depth๋ฅผ ์ด๊ณผ(10*3)ํ๊ธฐ ๋๋ฌธ์ด๋ค.
๋ฐ๋ผ์, ์ต์ข ์ฝ๋์ธ ์์๋ depth๋ฅผ ๋๋ ค์ฃผ์๋ค.
RecursionError ๋ฐ์ ์ฝ๋
๋๋์
๊ทธ๋ํ ๋ฌธ์ ๋ dfs, bfs๋ก ์ ๊ทผํด์ผ ํจ์ ์๊ฒ ๋๋ฐ ์ ์ ํ๊ฒ ์ธ์ ๋ฆฌ์คํธ, ์ธ์ ํ๋ ฌ์ ์ ํํด ํธ๋ ๊ฒ์ ์ด๋ ค์ด ๊ฒ ๊ฐ๋ค.