๐ค๋ฌธ์ ํด๊ฒฐ
D5 | ๊ทธ๋ํ
์ด์ง ํธ๋ฆฌ๋ฅผ ๋ง๋ค์ด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์.
์ด๋ฐ์์ผ๋ก 2์ฐจ์ ๋ฐฐ์ด์ ๋ง๋ ๋ค. ๊ธธ์ด๊ฐ 3์ธ ๋ฆฌ์คํธ๊ฐ V๊ฐ์ธ 2์ฐจ์๋ฆฌ์คํธ
๋ถ๋ชจ ๋ ธ๋๋ค ์ฐพ๊ธฐ์ฒซ ๋ ธ๋ (์ฌ๊ธฐ์๋ 8 ๊ณผ 13) ์์ ์์ํด์ ๋ถ๋ชจ ๋ ธ๋๋ฅผ ํ๊ณ ์ญ ์ฌ๋ผ๊ฐ๋ค. ( DFS )
- 8 ์ ๋ถ๋ชจ ๋ ธ๋๋ [5, 3, 1]
- 13์ ๋ถ๋ชจ ๋ ธ๋๋ [11, 6, 3, 1]
๊ณตํต ๋ถ๋ชจ ๋ ธ๋ ์ฐพ๊ธฐ
์์์๋ถํฐ for๋ฌธ์ ๋๋ฉฐ ๊ฒน์น๋ ์น๊ตฌ ์ฐพ๊ณ ๋ฐ๋ก ๋์ค๊ธฐ (์ฌ๊ธฐ์๋ 3)
๊ณตํต ๋ถ๋ชจ ๋ ธ๋ ํฌ๊ธฐ ์ฐพ๊ธฐ
๋ ธ๋(์ฌ๊ธฐ์๋ 3)์์ ์์ ๋ ธ๋๋ฅผ ํ๊ณ ์ญ ๋ด๋ ค๊ฐ๋ฉด์ ๊ฐ์๋ฅผ ์ธ์ด์ค๋ค(DFS)
๐จ
๐ป์์ค ์ฝ๋
def find_parent(n, parent_list):
if tree[n][2]:
parent_list.append(tree[n][2])
find_parent(tree[n][2], parent_list)
def find_common_parent(parent1, parent2):
for p1 in parent1:
for p2 in parent2:
if p1 == p2:
return p1
def find_subtree(n):
global subtree_size
for k in range(2):
if tree[n][k]:
subtree_size += 1
find_subtree(tree[n][k])
if __name__ == "__main__":
T = int(input())
for tc in range(1, 1 + T):
# ์ ์ ์ V, ๊ฐ์ ์ E, ๊ณตํต์กฐ์์ ์ฐพ๋ ๋๊ฐ์ ์ ์ ๋ฒํธ N1,N2
V, E, N1, N2 = map(int, input().split())
adj_list = list(map(int, input().split()))
# ์์ ๋
ธ๋, ์์ ๋
ธ๋, ๋ถ๋ชจ ๋
ธ๋
tree = [[0] * 3 for _ in range(V + 1)]
for i in range(E):
s, e = adj_list[i * 2], adj_list[i * 2 + 1]
if tree[s][0]:
tree[s][1] = e
else:
tree[s][0] = e
tree[e][2] = s
# ๊ฐ๊ฐ์ ๋ถ๋ชจ ๋
ธ๋
N1_parent, N2_parent = [], []
find_parent(N1, N1_parent)
find_parent(N2, N2_parent)
# ๊ณตํต ๋ถ๋ชจ ๋
ธ๋
common_parent = find_common_parent(N1_parent, N2_parent)
# ๊ณตํต ๋ถ๋ชจ ๋
ธ๋ ์ฌ์ด์ฆ
subtree_size = 1
find_subtree(common_parent)
print(f'#{tc} {common_parent} {subtree_size}')
๐๋ฌธ์ ํ์ธ
์ถ์ฒ: SW Expert Academy
๋งํฌ: https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV15PTkqAPYCFAYD
[๋ฌธ์ ]
์ด์ง ํธ๋ฆฌ์์ ์์์ ๋ ์ ์ ์ ๊ณตํต ์กฐ์ ์ค ๊ฐ์ฅ ๊ฐ๊น์ด ๊ฒ์ ์ฐพ์ผ๋ ค ํ๋ค.
์๋ฅผ ๋ค์ด, ์๋์ ์ด์ง ํธ๋ฆฌ์์ ์ ์ 8๊ณผ 13์ ๊ณตํต ์กฐ์์ ์ ์ 3์ 1 ๋ ๊ฐ๊ฐ ์๋ค.
์ด ์ค 8, 13์ ๊ฐ์ฅ ๊ฐ๊น์ด ๊ฒ์ ์ ์ 3์ด๋ค.
์ ์ 3์ ๋ฃจํธ๋ก ํ๋ ์๋ธ ํธ๋ฆฌ์ ํฌ๊ธฐ(์๋ธ ํธ๋ฆฌ์ ํฌํจ๋ ์ ์ ์ ์)๋ 8์ด๋ค.
์์์ ์ด์ง ํธ๋ฆฌ๊ฐ ์ฃผ์ด์ง๊ณ , ๋ ์ ์ ์ด ๋ช
์๋ ๋ ์ด๋ค์ ๊ณตํต ์กฐ์ ์ค ์ด๋ค์ ๊ฐ์ฅ ๊ฐ๊น์ด ์ ์ ์ ์ฐพ๊ณ , ๊ทธ ์ ์ ์ ๋ฃจํธ๋ก ํ๋ ์๋ธ ํธ๋ฆฌ์ ํฌ๊ธฐ๋ฅผ ์์๋ด๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ.
์
๋ ฅ์์ ์ฃผ์ด์ง๋ ๋ ์ ์ ์ด ์๋ก ์กฐ์๊ณผ ์์ ๊ด๊ณ์ธ ๊ฒฝ์ฐ๋ ์๋ค.
์์ ํธ๋ฆฌ์์ ์๋ฅผ ๋ ๋ค๋ฉด ๋ ์ ์ ์ด “11๊ณผ 3”๊ณผ ๊ฐ์ด ์ฃผ์ด์ง๋ ๊ฒฝ์ฐ๋ ์๋ค.
[์
๋ ฅ]
๊ฐ์ฅ ์ฒซ์ค์ ์ ์ฒด ํ
์คํธ์ผ์ด์ค์ ์์ด๋ค.
10๊ฐ์ ํ
์คํธ ์ผ์ด์ค๊ฐ ์ฃผ์ด์ง๋ค.
๋ ์ค์ด ํ๋์ ํ
์คํธ ์ผ์ด์ค๊ฐ ๋๋ฉฐ, ๋ฐ๋ผ์ ์ ์ฒด ์
๋ ฅ์ 20์ค๋ก ์ด๋ฃจ์ด์ง๋ค.
๊ฐ ์ผ์ด์ค์ ์ฒซ์ค์๋ ํธ๋ฆฌ์ ์ ์ ์ ์ด ์ V์ ๊ฐ์ ์ ์ด ์ E, ๊ณตํต ์กฐ์์ ์ฐพ๋ ๋ ๊ฐ์ ์ ์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค (์ ์ ์ ์ V๋ 10 ≤ V ≤ 10000 ์ด๋ค).
๊ทธ ๋ค์ ์ค์๋ E๊ฐ ๊ฐ์ ์ด ๋์ด๋๋ค. ๊ฐ์ ์ ๊ฐ์ ์ ์ด๋ฃจ๋ ๋ ์ ์ ์ผ๋ก, ํญ์ “๋ถ๋ชจ ์์” ์์๋ก ํ๊ธฐ๋๋ค.
์์์ ์๋ก ๋ ํธ๋ฆฌ์์ ์ ์ 5์ 8์ ์๋ ๊ฐ์ ์ “5 8”๋ก ํ๊ธฐ๋๊ณ , ์ ๋๋ก “8 5”์ ๊ฐ์ด ํ๊ธฐ๋์ง๋ ์๋๋ค.
๊ฐ์ ์ด ์
๋ ฅ๋๋ ์์๋ ์ ํด์ ธ ์์ง ์๋ค. ์
๋ ฅ์์ ์ด์ํ ์๋ ๋ชจ๋ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋๋ค.
์ ์ ์ ๋ฒํธ๋ 1๋ถํฐ V๊น์ง์ ์ ์์ด๋ฉฐ, ์ ์ฒด ํธ๋ฆฌ์์ ๋ฃจํธ๊ฐ ๋๋ ์ ์ ์ ํญ์ 1๋ฒ์ผ๋ก ํ๊ธฐ๋๋ค.
๋ถ๋ชจ ์ ์ ์ด ์์ ์ ์ ๋ณด๋ค ํญ์ ๋ฒํธ๊ฐ ์์ ๊ฒ์ ์๋๋ค. ์ฆ, 40๋ฒ ์ ์ ์ด 20๋ฒ ์ ์ ์ ๋ถ๋ชจ๊ฐ ๋ ์๋ ์๋ค.
์ด ๋ฌธ์ ์์ ์์ ์ ์ ์ด ๋ถ๋ชจ ์ ์ ์ ์ผ์ชฝ ์์์ธ์ง ์ค๋ฅธ์ชฝ ์์์ธ์ง๋ ์ค์ํ์ง ์๋ค.
[์ถ๋ ฅ]
์ด 10์ค์ 10๊ฐ์ ํ
์คํธ ์ผ์ด์ค ๊ฐ๊ฐ์ ๋ํ ๋ต์ ์ถ๋ ฅํ๋ค.
๊ฐ ์ค์ ํ
์คํธ ์ผ์ด์ค์ ๋ฒํธ๋ฅผ ์๋ฏธํ๋ ‘#x’๋ก ์์ํ๊ณ ๊ณต๋ฐฑ์ ํ๋ ๋ ๋ค์ ๋ต์ ๊ธฐ๋กํ๋ค.
๋ต์ ๊ณตํต์กฐ์ ์ค ๊ฐ์ฅ ๊ฐ๊น์ด ๊ฒ์ ๋ฒํธ, ๊ทธ๊ฒ์ ๋ฃจํธ๋ก ํ๋ ์๋ธ ํธ๋ฆฌ์ ํฌ๊ธฐ๋ฅผ ๋ปํ๋ 2๊ฐ์ ์ ์๋ก ๊ตฌ์ฑ๋๋ค. ์ด ๋ ์ ์๋ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ๋ค.
'Algorithm Problem > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[python] SWEA - 6019. ๊ธฐ์ฐจ ์ฌ์ด์ ํ๋ฆฌ (2) | 2020.09.18 |
---|---|
[python] ๋ฐฑ์ค - 16953. A โ B (0) | 2020.09.18 |
[python] ํ๋ก๊ทธ๋๋จธ์ค - 3 x n ํ์ผ๋ง (0) | 2020.09.17 |
[python] ๋ฐฑ์ค - 9658. ๋ ๊ฒ์4 (0) | 2020.09.16 |
[python] ํ๋ก๊ทธ๋๋จธ์ค - ์งํ ํธ์ง (2) | 2020.09.16 |