๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ

์•Œ๊ณ ๋ฆฌ์ฆ˜/ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค

[ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค ์Šคํ„ฐ๋”” 6์ฃผ์ฐจ] ๊ทธ๋ž˜ํ”„ ๊ฐ€์žฅ ๋จผ ๋…ธ๋“œ Lv.3 - ํŒŒ์ด์ฌ(Python)

๐Ÿ“‘ ๋ฌธ์ œ

 

๋”๋ณด๊ธฐ

๋ฌธ์ œ ์„ค๋ช…

n๊ฐœ์˜ ๋…ธ๋“œ๊ฐ€ ์žˆ๋Š” ๊ทธ๋ž˜ํ”„๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ฐ ๋…ธ๋“œ๋Š” 1๋ถ€ํ„ฐ n๊นŒ์ง€ ๋ฒˆํ˜ธ๊ฐ€ ์ ํ˜€์žˆ์Šต๋‹ˆ๋‹ค. 1๋ฒˆ ๋…ธ๋“œ์—์„œ ๊ฐ€์žฅ ๋ฉ€๋ฆฌ ๋–จ์–ด์ง„ ๋…ธ๋“œ์˜ ๊ฐฏ์ˆ˜๋ฅผ ๊ตฌํ•˜๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ๊ฐ€์žฅ ๋ฉ€๋ฆฌ ๋–จ์–ด์ง„ ๋…ธ๋“œ๋ž€ ์ตœ๋‹จ๊ฒฝ๋กœ๋กœ ์ด๋™ํ–ˆ์„ ๋•Œ ๊ฐ„์„ ์˜ ๊ฐœ์ˆ˜๊ฐ€ ๊ฐ€์žฅ ๋งŽ์€ ๋…ธ๋“œ๋“ค์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.

๋…ธ๋“œ์˜ ๊ฐœ์ˆ˜ n, ๊ฐ„์„ ์— ๋Œ€ํ•œ ์ •๋ณด๊ฐ€ ๋‹ด๊ธด 2์ฐจ์› ๋ฐฐ์—ด vertex๊ฐ€ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, 1๋ฒˆ ๋…ธ๋“œ๋กœ๋ถ€ํ„ฐ ๊ฐ€์žฅ ๋ฉ€๋ฆฌ ๋–จ์–ด์ง„ ๋…ธ๋“œ๊ฐ€ ๋ช‡ ๊ฐœ์ธ์ง€๋ฅผ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์ž‘์„ฑํ•ด์ฃผ์„ธ์š”.

์ œํ•œ์‚ฌํ•ญ

  • ๋…ธ๋“œ์˜ ๊ฐœ์ˆ˜ n์€ 2 ์ด์ƒ 20,000 ์ดํ•˜์ž…๋‹ˆ๋‹ค.
  • ๊ฐ„์„ ์€ ์–‘๋ฐฉํ–ฅ์ด๋ฉฐ ์ด 1๊ฐœ ์ด์ƒ 50,000๊ฐœ ์ดํ•˜์˜ ๊ฐ„์„ ์ด ์žˆ์Šต๋‹ˆ๋‹ค.
  • vertex ๋ฐฐ์—ด ๊ฐ ํ–‰ [a, b]๋Š” a๋ฒˆ ๋…ธ๋“œ์™€ b๋ฒˆ ๋…ธ๋“œ ์‚ฌ์ด์— ๊ฐ„์„ ์ด ์žˆ๋‹ค๋Š” ์˜๋ฏธ์ž…๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ

n/ vertex/ return

6 [[3, 6], [4, 3], [3, 2], [1, 3], [1, 2], [2, 4], [5, 2]] 3

์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

์˜ˆ์ œ์˜ ๊ทธ๋ž˜ํ”„๋ฅผ ํ‘œํ˜„ํ•˜๋ฉด ์•„๋ž˜ ๊ทธ๋ฆผ๊ณผ ๊ฐ™๊ณ , 1๋ฒˆ ๋…ธ๋“œ์—์„œ ๊ฐ€์žฅ ๋ฉ€๋ฆฌ ๋–จ์–ด์ง„ ๋…ธ๋“œ๋Š” 4,5,6๋ฒˆ ๋…ธ๋“œ์ž…๋‹ˆ๋‹ค.

 

 

 

 

 

 

 

 

 

โœ’๏ธ ํ’€์ด

 

โ— ๋…ธ๋“œ ๊ฐœ์ˆ˜๋งŒํผ ๋ฐฐ์—ด์„ ๋งŒ๋“ค๋ ค๋‹ค๊ฐ€ ๋ณต์‚ฌ ์‹ค์ˆ˜๋ฅผ ํ•ด์„œ ์“ธ๋ฐ์—†๋Š” ์• ๋ฅผ ๋จน์—ˆ๋˜ ๋ฌธ์ œ์˜€๋‹ค.

 [[0]]์„ ๊ณฑํ•˜๊ธฐ๋กœ N๊ฐœ๋ฅผ ๋งŒ๋“ค๋ฉด, [[0], [0] ... ] ์›ํ•˜๋Š” ๋ชจ์–‘์€ ๋‚˜์˜ค์ง€๋งŒ, ๊ฒฐ๊ณผ์ ์œผ๋กœ ๋˜‘๊ฐ™์€ ์ฃผ์†Œ๊ฐ’์ด ๋Š˜์–ด๋‚œ ๊ฒƒ์ด๊ธฐ ๋•Œ๋ฌธ์— ์ž…์ถœ๋ ฅ์ด ๋ชจ๋“  ๋‚ด๋ถ€ ๋ฐฐ์—ด์— ๋˜‘๊ฐ™์ด ์ผ์–ด๋‚˜๋Š” ์ฐธ์‚ฌ๊ฐ€ ๋‚œ๋‹ค.

 ๊ทธ๋ ‡๊ธฐ ๋•Œ๋ฌธ์— ์ด์ฐจ์› ๋ฐฐ์—ด์„ ๋งŒ๋“ค ๋•Œ์—๋Š” for๋ฌธ์„ ์ด์šฉํ•ด์„œ ์ถ”๊ฐ€ํ•ด์ฃผ๋Š” ์ฝ”๋“œ๋ฅผ ์‚ฌ์šฉํ•ด์•ผ ํ•œ๋‹ค.

graph = [[0] for _ in range(n+1)]

 

๐Ÿ’ก1๋ฒˆ๋ถ€ํ„ฐ ์ถœ๋ฐœํ–ˆ์„ ๋•Œ, ๊นŠ์ด๊ฐ€ ๊ฐ€์žฅ ๋…ธ๋“œ ๊ฐœ์ˆ˜๋ฅผ ์ฐพ๋Š” ๋ฌธ์ œ์ด๋‹ค.

 ํ•˜๋‚˜์˜ ํ์— ์ธํ’‹/์•„์›ƒํ’‹์ด ์ผ์–ด๋‚˜๊ธฐ ๋•Œ๋ฌธ์—, ๊นŠ์ด๋ฅผ ๋‹ค๋ฃฐ ๋•Œ์—๋Š” ๋ชจ๋“  ๊นŠ์ด๋ฅผ ๋Œ๋ฉฐ ๊ฐ ๊นŠ์ด์— ์žˆ๋Š” ๋…ธ๋“œ ๊ฐœ์ˆ˜๋งŒํผ ์ธ์ ‘๋…ธ๋“œ๋ฅผ ํƒ์ƒ‰ํ•˜๊ณ  ์ถ”๊ฐ€ํ•ด์ฃผ๋Š” ์ž‘์—…์„ ํ•ด์•ผํ•œ๋‹ค.

 

 

 

 

 

 

๐Ÿ™‹‍โ™€๏ธ ์˜๊ฒฌ

 ๊ฐœ๋…์„ ์ฒ˜์Œ๋ถ€ํ„ฐ ๋‹ค์‹œ ์žก๊ณ ์ž ๊ณ ๋ฅธ ์ „ํ˜•์ ์ธ ๊ทธ๋ž˜ํ”„ ๋ฌธ์ œ์ด๋‹ค.

 ์ž๋ฐ”๋กœ๋Š” ๋งŽ์ด ํ•ด๋ด์„œ ์ผ๋ถ€๋Ÿฌ ํŒŒ์ด์ฌ์œผ๋กœ ํ’€์–ด๋ดค๋‹ค. ใ…Žใ…Ž ์ž˜ํ•œ ๊ฒƒ ๊ฐ™๋‹ค. ๋ฐฐ์—ด๋ณต์‚ฌ ์‹ค์ˆ˜๋„ ์žˆ์—ˆ์œผ๋‹ˆ....

 

 

 

 

 

 

 

 

๐Ÿ’ป ์†Œ์Šค์ฝ”๋“œ: ํŒŒ์ด์ฌ(Python)

from collections import deque
def solution(n, edge):
    # [[0]]* (n+1)๋กœ ํ•˜๋ฉด ์ฃผ์†Œ๊ฐ’์„ ๋ณต์‚ฌํ•ด์„œ 2์ฐจ์› ๋ฐฐ์—ด์„ ๋งŒ๋“ค๊ธฐ ๋•Œ๋ฌธ์— ๊ฐ’์ด ํ•œ๋ฒˆ์— ๋ฐ”๋€Œ์–ด๋ฒ„๋ฆฐ๋‹ค.
    # * ์“ฐ์ง€๋ง๊ธฐ
    graph = [[0] for _ in range(n+1)]
    visit = [0]*(n+1)
    queue = deque()

    for v1, v2 in edge:
        graph[v1].append(v2)
        graph[v2].append(v1)

    queue.append(1)
    visit[1] = 1
    while queue:
        answer = len(queue)
        for _ in range(depth):
            cur = queue.popleft()
            for v in graph[cur][1:]:
                if visit[v]==0:
                    queue.append(v)
                    visit[v]=1
    return answer


# ์˜ˆ์ œ
n = 6
vertex = [[3, 6], [4, 3], [3, 2], [1, 3], [1, 2], [2, 4], [5, 2]]

# ์ถœ๋ ฅ
print(solution(n, vertex))

 

 

 

 

 

 

 

 

 

๐Ÿ’Ž ๐Ÿ’Ž ๐Ÿ’Ž

 

 

๏ผฐ๏ฝ๏ฝ“๏ฝ”๏ฝ…๏ฝ„ ๏ผข๏ฝ™ ๏ผณ๏ผก๏ผน

๐˜›๐˜ฉ๐˜ข๐˜ฏ๐˜ฌ๐˜ด ๐˜ง๐˜ฐ๐˜ณ ๐˜ณ๐˜ฆ๐˜ข๐˜ฅ๐˜ช๐˜ฏ๐˜จ