ULISIA's Developer Life

[Backjoon] 1697 숨바꼭질 Python 문제 풀이

ULISIA — Tue, 25 Jul 2023 15:01:12 +0900

출처 : 숨바꼭질

문제해석

BFS를 탐색을 통해서 큐에 들어갈 분기를 세가지로 나눈다.

현재좌표+1, 현재좌표-1, 현재좌표*2

다음좌표가 경계체크를 벗어나지 않고 한번도 방문한적이 없다면 이전좌표까지의 방문시간+1을 다음좌표까지의 방문시간에 갱신한다.

현재좌표가 K가 될때까지 걸리는 시간의 최적해를 구한다.

해답코드

#숨바꼭질
from collections import deque

n, k = map(int, input().split())
MAX = 10 ** 5
isVisited = [0] * (MAX+1)

def bfs(startX):
    q = deque()
    q.append(startX)
    while q:
        x = q.popleft()
        if x==k:
            return isVisited[x]
        for nx in (x-1, x+1, x*2):
            if 0 <= nx <= MAX and not isVisited[nx]:
                isVisited[nx] = isVisited[x]+1
                q.append(nx)
print(bfs(n))

[Backjoon] 1520 내리막 길 Python 문제 풀이

ULISIA — Mon, 24 Jul 2023 22:11:16 +0900

출처 : 내리막 길

문제해석

입력받은 맵을 (0,0)좌표에서 DFS탐색을 시작한다.
4방탐색을 통해 다음에 이동할 좌표의 인덱스가 경계를 벗어나지 않으면서 현재좌표값보다 높이가 더 낮을때만 dfs 함수를 재귀 호출한다.
최종적으로 (n-1,m-1)좌표에 도달했을때마다 ans값을 1씩 더해준다.
모든 dfs 탐색이 끝난 이후 최종적으로 나온 ans값을 출력한다.

처음엔 여기까지 해서 풀어본 결과 시간초과가 나왔다.

(0,0)에서 시작해 dfs로 가능한 곳을 모두 탐색하였기에 너무 많은 경우의 수가 있기때문에 시간초과라는 결과가 나왔다.

따라서 시간초과를 줄이기 위한 핵심은 DFS에 DP 방식을 결합하는 것이다.

isVisited 리스트에 -1, 0, n으로 구분하여 각각 미방문,방문한경우,경로완성수로 구분해준다.

미방문(-1)에 대하여 조건을 만족하는 좌표(현재좌표보다 작은 값)으로 이동하며 이동(방문)하였다는 의미로 0으로 초기화해준다.
목표지점(n-1,m-1)에 도달하면 시작점에서 도착점까지 성공적으로 방문한 한 가지 경로가 되므로 1을 반환해주고, 해당 값을 지금까지 이동해온 경로 내의 모든 리스트 값에 더해준다.
만약에 현재 방문중인 경로를 이미 다른 경로에서 방문하여 -1이 아닌 다른 값으로 갱신되어져 있다면(0 or n) 더 이상의 탐색은 진행하지 않고 해당 값을 반환해준다.(만약 현재 방문한 좌표가 0이라고 한다면, 해당 좌표를 경로로 그 어떤 경우에도 목표지점으로 도달할 수 없다는 뜻이고, n이라면 해당 좌표를 통해 목표지점으로 가는 경우의 수를 지금까지 n개를 찾았다는 것이다.)

이런식으로 이미 완성된 경로의 수를 방문한 좌표에서 총 몇개인지를 굳이 탐색을 끝까지 하지 않고 바로 반환해주므로써 수행시간을 줄일 수 있다.

해답코드

실패한 코드(시간초과)

#내리막 길
import sys
sys.setrecursionlimit(10 ** 9)

input = sys.stdin.readline

n,m = map(int,input().split())
maps = [[0] * m for _ in range(n)]
isVisited = [[False]*m for _ in range(n)]
for y in range(n):
    maps[y] = list(map(int,input().split()))

ans=0

dy = [-1,1,0,0]
dx = [0,0,-1,1]


def dfs(startY,startX):
    global ans
    if startY==n-1 and startX==m-1:
        ans += 1
    for d in range(4):
        ny, nx = startY+dy[d], startX+dx[d]
        if 0<=ny<n and 0<=nx<m and maps[startY][startX]>maps[ny][nx] and not isVisited[ny][nx]:
            isVisited[ny][nx]=True
            dfs(ny,nx)
            isVisited[ny][nx]=False

dfs(0,0)
print(ans)

DFS+DP(정답코드)

#내리막 길
import sys
sys.setrecursionlimit(10 ** 9)

input = sys.stdin.readline

n,m = map(int,input().split())
maps = [list(map(int,input().split())) for _ in range(n)]
isVisited = [[-1]*m for _ in range(n)]

ans=0

dy = [-1,1,0,0]
dx = [0,0,-1,1]

def dfs(startY,startX):
    #목적지 도착시 해당경로 내 모든 배열값 추가
    if startY==n-1 and startX==m-1:
        return 1
    #이미 방문한 곳이면 해당 좌표에서 도착 가능한 모든 경로의 수 추가
    if isVisited[startY][startX] != -1:
        return isVisited[startY][startX]

    #방문하지 않은 곳이면 방문했지만 아직 경로완성을 찾지 못했다는 의미로 0으로 초기화
    isVisited[startY][startX]=0

    #4방탐색
    for d in range(4):
        ny, nx = startY+dy[d], startX+dx[d]
        if 0<=ny<n and 0<=nx<m and maps[startY][startX]>maps[ny][nx]:
            isVisited[startY][startX] += dfs(ny,nx)

    return isVisited[startY][startX]
print(dfs(0,0))

[Backjoon] 2583 영역 구하기 Python 문제 풀이

ULISIA — Mon, 24 Jul 2023 13:38:31 +0900

출처 : 영역 구하기

문제해석

모눈종이 전체 눈금을 0으로 초기화 한 뒤 사각형을 이루고 있는 부분을 1로 초기화해준다.
모눈종이 전체 눈금 한칸한칸을 탐색하는 기준으로 (0,0)부터 시작해서 흰색(0)을 이루고 있는 부분을 만나면 BFS/DFS 탐색을 시작함과 동시에 영역개수를 증가시킨다.
해당영역내에서 흰칸을 이루고 있는 부분만큼 영역넓이를 구해서 반환해준뒤 해당 넓이를 저장하는 리스트에 추가해준다.
최종적으로 구해진 영역 개수와 영역 넓이 리스트의 값들을 출력한다.

해답코드

import sys
from collections import deque

input = sys.stdin.readline

n, m, k = map(int, input().split())

maps = [[0]*m for _ in range(n)]

for _ in range(k):
    x1,y1,x2,y2 = map(int,input().split())
    for y in range(y1,y2):
        for x in range(x1,x2):
            maps[y][x] = 1

dy = [-1,1,0,0]
dx = [0,0,-1,1]

ans=1
area=[]

def bfs(startY,startX):
    global ans
    q = deque()
    q.append([startY,startX])
    maps[startY][startX]=2
    while q:
        y,x = q.popleft()
        for d in range(4):
            ny,nx = y+dy[d], x+dx[d]
            if 0<=ny<n and 0<=nx<m and maps[ny][nx]==0:
                ans+=1
                maps[ny][nx]=2
                q.append([ny,nx])
    return ans

for y in range(n):
    for x in range(m):
        if maps[y][x]==0:
            ans=bfs(y,x)
            area.append(ans)
            ans=1

area.sort()
print(len(area))
for result in area:
    print(result, end=" ")

[Backjoon] 2178 미로 탐색 Python 문제 풀이

ULISIA — Sun, 23 Jul 2023 19:55:49 +0900

출처 : 미로 탐색

문제해석

대표적인 미로 탐색 유형의 쉬운 난이도 문제

미로 문제는 기본적으로 이동방향을 제어할 수 있는 배열이 자주 쓰인다.
(2차원 기준 2방,4방,8방 등)

y와 x좌표에 대한 변화량을 나타내는 dy,dx를 선언하여 각 방향별 인접배열 값을 탐색할 수 있다.

dy = [-1,1,0,0]
dx = [0,0,-1,1]

주의할 점은 이동조건이 있는 미로탐색 등의 문제에서 항상 경계체크와 이동조건을 잊지 말아야 한다.

다음으로 탐색할 인덱스가 전체 맵 배열의 최소와 최대 인덱스 범위를 벗어나지 않는지,
해당 문제에서는 배열값이 1로 되어 있는곳에서만 이동이 가능하므로 해당 조건 또한 동시에 만족해야 한다.

for d in range(4):
    ny, nx = y+dy[d], x+dx[d]
    if 0 <= ny < y좌표최대범위 and 0 <= nx < x좌표최대범위 and mapping[ny][nx]==1:
    경계체크 및 이동조건 만족시 수행

이 문제는 미로를 탐색하면서 목적지까지의 최단 경로를 구하는 문제이다.

최단 경로를 구하기 위해서 DFS와 BFS 중 어떤 탐색방식이 더 유리한가의 예시는 다음처럼 들 수 있다.

DFS
- 재귀적 특징과 백트래킹을 이용한 모든 경우를 하나씩 전부 탐색하는 경우
- 그래프(맵)의 크기가 클 경우
- 최적의 답을 찾는 것이 아닌 경우
- 경로의 특징을 저장해야 하는 경우 ex)가중치, 이동과정 제약 등

BFS
- 최단 거리 or 최단 횟수
- 최적의 답을 찾는 경우, BFS는 가장 처음 발견되는 해답이 최적해
- 탐색의 횟수를 구해야 하는 경우

1. 그래프의 모든 정점을 방문하는 것이 주요한 문제

단순히 모든 정점을 방문하는 것이 중요한 문제는 DFS,BFS 어느 것을 사용해도 무관.

2. 경로의 특징을 저장해둬야 하는 문제.

각 정점마다 숫자가 주어지고 a~b까지의 경로중 같은 숫자가 있으면 안된다는 식의 이동과정 제약 등의 문제 등, 각각의 경로마다 특징, 가중치 등을 저장해둬야 할 때는 DFS를 사용한다.(BFS는 경로의 특징을 가지지 못한다)

3. 최단거리

미로 찾기 등 최단거리 문제에서 BFS가 유리.
DFS로 경로를 탐색할 경우 최초의 해답이 최적해(최단거리)가 아닐 수 있지만, BFS는 현재 노드부터 가장 가까운 곳부터 찾기 때문에 경로 탐색 시 가장 먼저 찾아지는 해답이 곧 최적해(최단거리)이기 때문.
따라서 최단 거리를 구하는 해당 문제는 BFS로 풀고자 한다.

입력값으로 주어진 맵을 저장.
(1,1)좌표를 기준으로 bfs 시작.
4방탐색으로 이동 가능한 인접노드 탐색.
(y,x)좌표가 n,m이 될때까지 인접노드 값을 증가하며 bfs 탐색.
(n,m)좌표에서 완성된 배열값 출력

해답코드

#미로 탐색
import sys
from collections import deque
input = sys.stdin.readline
n, m = map(int,input().split())
mapping = []

for _ in range(n):
    #readline 맨 뒤 '\n'까지 입력받으므로 제거해줘야함
    mapping.append(list(map(int,input().rstrip())))

dy = [-1,1,0,0]
dx = [0,0,-1,1]

def bfs(startY,startX):
    q = deque()
    q.append((startY,startX))
    while q:
        y,x = q.popleft()
        for d in range(4):
            ny = y+dy[d]
            nx = x+dx[d]
            if 0<=ny<n and 0<=nx<m and mapping[ny][nx]==1:
                q.append((ny,nx))
                mapping[ny][nx]=mapping[y][x]+1
    return mapping[n-1][m-1]

print(bfs(0,0))

[Backjoon] 1068 트리 Python 문제 풀이

ULISIA — Sat, 22 Jul 2023 15:49:32 +0900

출처 : 트리

문제해석

제거하고자 하는 입력값을 dfs 함수에 넘겨준다.
넘겨준 입력값을 인덱스로 하는 배열값을 제거한다는 의미로 -2로 변경한다.(-1은 루트 노드이므로)
제거한 인덱스를 부모노드로 가지고 있는 노드를 찾아 제거하기 위해 dfs함수를 재귀 호출한다.
재귀가 종료되고 삭제될 노드들은 전부 -2를 배열값으로 지니고 있다.
-2가 아니면서, 다른 노드의 부모노드도 아닌 원소(초기 배열 초기화 단계에서 포함되지 않은)를 찾을 때마다 ans를 1씩 늘린다.

해답코드

#트리
import sys
input = sys.stdin.readline

n=int(input())
vList = list(map(int,input().split()))
delete = int(input())

ans=0

def dfs(num):
    vList[num] = -2
    for i in range(n):
        if num == vList[i]:
            dfs(i)

dfs(delete)

for i in range(n):
    if vList[i] != -2 and i not in vList:
        ans += 1

print(ans)

[Backjoon] 5639 이진 검색 트리 Python 문제 풀이

ULISIA — Fri, 21 Jul 2023 16:26:54 +0900

출처 : 5639번 이진 검색 트리

문제해석

전위 순회 결과

50 30 24 5 28 45 98 52 60

첫 원소가 루트 노드(전위 순회)
왼쪽 서브 트리는 루트 노드보다 작은 원소
오른쪽 서브 트리는 루트 노드보다 큰 원소

전위 순회이므로 루트 노드보다 큰 원소가 나오는 지점이 왼쪽 서브 트리와 오른쪽 서브 트리를 나누는 지점과 같다.

50 /30 24 5 28 45/ 98 52 60

50=루트 노드, 30~~45=왼쪽 서브트리, 98~~60= 오른쪽 서브트리

위 결과를 활용하여 후위 순회를 해주면 된다.

해답코드

#이진 검색 트리
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline

pre = []
while True:
    try:
        pre.append(int(input()))
    except:
        break

def post(start,end):
    if start> end:
        return
    mid = end+1
    for i in range(start+1,end+1):
        if pre[i] > pre[start]:
            mid = i
            break
    post(start+1,mid-1) #왼쪽 트리
    post(mid,end) #오른쪽 트리
    print(pre[start]) #루트 노드

post(0, len(pre)-1)

mid를 end + 1로 초기화하는 이유

만약 모든 원소가 루트 노드보다 작은 경우

post(start + 1, mid - 1) : start + 1, end 가 삽입, 즉 루트 노드를 제외한 트리

post(mid, end) : end + 1, end 가 삽입되어 if start > end: return에 의해 리턴됨 이는 오른쪽 노드가 없음을 의미

[Backjoon] 13549 숨바꼭질 3 Python 문제 풀이

ULISIA — Thu, 20 Jul 2023 13:17:33 +0900

출처 : 링크텍스트

문제해석

시간 가중치가 0과 1 둘로 나누어진다.
걷기 : x+1, x-1은 1초가 걸리고
순간이동 : 2*x는 0초가 걸린다.

단계가 이루어진다는 점으로 큐를 2개로 나눠 구현하는 방법이나

양방향 큐인 deque를 활용하여 2개를 별도로 만들지 않고, 순간이동할 경우 맨 앞에 추가, 걷기를 할 경우엔 뒤에 추가한다.

해답코드

#숨바꼭질 3
import sys
from collections import deque

MAX = 100001
isVisited = [False] * MAX
time = [-1] * MAX

input = sys.stdin.readline

n, k = map(int,input().split())
q = deque()
q.append(n)
isVisited[n] = True
time[n]=0

while q:
    now = q.popleft()
    if now == k:
        print(time[k])
        break
    if now-1>=0 and isVisited[now-1]==False: #x-1
        q.append(now-1)
        isVisited[now-1]=True
        time[now-1]=time[now]+1
    if now * 2 < MAX and isVisited[now*2]==False: #순간이동
        q.appendleft(now*2) #순간이동은 0초이므로 최우선순위
        isVisited[now*2] = True
        time[now*2]=time[now] #순간이동은 시간변동 x
    if now+1 < MAX and isVisited[now+1]==False: # x+1 이동
        q.append(now+1)
        isVisited[now+1]=True
        time[now+1] = time[now]+1

주의할 점

분명 제대로 풀었다고 생각했는데 계속 99%에서 틀림이 나오길래 내가 대체 어디서 잘못한 걸까 헤매는 시간이 길었다.
99%에서 틀린 이유는 처음에 if 조건문의 순서를 +1이 -1보다 앞에 있었다. 해당 경우의 반례로서는 이러한 경우가 있었다.
input 4 6 output 1
(4-3-6) 1초
만약 +1이 앞에 있으면 2초로 나온다.

[Backjoon] 1916 최소비용 구하기 Python 문제 풀이

ULISIA — Wed, 19 Jul 2023 17:47:58 +0900

출처 : 링크텍스트

문제해석

버스 비용을 '거리'(dist)라고 생각하면, 최단 경로를 구하는 문제로 환원된다. 즐 최단경로를 구하는 문제이다.

특정 지점으로부터의 최단 거리 계산은 다익스트라 알고리즘으로 구할 수 있다.

해답코드

#최소비용
import sys
#우선순위 큐 구현을 위함
import heapq

input = sys.stdin.readline

# 입력
n = int(input()) #정점 개수
m = int(input()) #간선 개수
graph = [[] for _ in range(n+1)]
for _ in range(m):
    parent, child, gain = map(int, input().split())
    graph[parent].append((child,gain)) #도착지, 가중치

start, end = map(int, input().split()) #출발지, 목적지

# 다익스트라 최적경로 탐색
def dijkstra(graph, start):
    distances = [int(1e9)]*(n+1) #처음 초기값은 무한대
    distances[start] = 0 #시작 노드까지의 거리는 0
    q = []
    heapq.heappush(q, [distances[start],start]) #시작노드부터 탐색 시작

    while q:
        dist, node = heapq.heappop(q) #탐색할 노드거리, 노드

        #기존 최단거리보다 멀다면 무시
        if distances[node] < dist:
            continue

        #노드와 연결된 인접노드 탐색
        for child, gain in graph[node]:
            distance = dist + gain #인접노드까지의 거리
            if distance < distances[child]: #기존 거리보다 짧으면 갱신
                distances[child] = distance
                heapq.heappush(q,[distance,child]) #다음 인접 거리를 계산하기 위해 큐에 삽입

    return distances

dist_start = dijkstra(graph,start)
print(dist_start[end])

[Backjoon] 1197 최소 스패닝 트리 Python 문제 풀이

ULISIA — Tue, 18 Jul 2023 16:45:29 +0900

출처:1197번 최소 스패닝 트리

문제해석

최소 신장 트리 (minimum spanning tree)

전체 요소들을 연결할때 사용한다. Kruskal 알고리즘, Prim 알고리즘이 있다.

Kruskal

간선들을 정렬
간선이 잇는 두 정점의 root를 찾는다.
다르다면 하나의 root를 바꾸어 연결 시켜준다.

Prim

임의의 정점을 선택
해당 정점에서 갈 수 있는 간선을 minheap(최소힙)에 넣는다.
최소값을 뽑아 해당 정점을 방문하지 않았다면 선택한다.

Kruskal 알고리즘은 간선들을 정렬해야하기 때문에 간선이 적다면 Kruskal, 많다면 Prim을 선택한다.

비슷한 알고리즘으로 다익스트라 알고리즘이 있다.
다익스트라는 전체 요소를 연결하는 것이 아닌 한 정점에서 다른 정점으로 가는 가장 짧은 방법을 구할 때 사용한다.

다익스트라

최단 거리 배열을 무한대로 초기화한다. 방문여부 배열은 False로 초기화 한다.
출발 노드는 방문했다고 체크 후 heap에 넣는다.
아직 방문하지 않은 노드들 중, 최단 거리 테이블 값이 가장 작은 노드를 선택한다.
저장된 최단거리 값과 현재노드에 가중치를 더한 거리 값 중 더 작은 값으로 update한다.

해답코드

1. Kruskal

root를 저장하는 vRoot 배열 생성. (여기서 root는 연결요소 중 가장 작은 값, 처음에는 자기 자신을 저장)
간선들(eList)를 가중치(gain) 기준으로 정렬.
간선들이 이은 두 정점을 find 함수를 통해 두 root(sRoot, eRoot)를 찾는다.
두 root가 다르다면 큰 root값을 작은 root값으로 만들어 연결되게 해준다.
가중치를 더한다.

# 최소 스패닝 트리

#1. Kruskal
import sys
input = sys.stdin.readline

v, e = map(int, input().split())
vRoot = [i for i in range(v+1)]
eList = []
for _ in range(e):
    eList.append(list(map(int,input().split())))

eList.sort(key=lambda x: x[2])

def find(x):
    if x != vRoot[x]:
        vRoot[x] = find(vRoot[x])
    return vRoot[x]

ans=0

for start, end, gain in eList:
    startRoot = find(start)
    endRoot = find(end)
    if startRoot != endRoot:
        if startRoot>endRoot:
            vRoot[startRoot] = endRoot
        else:
            vRoot[endRoot] = startRoot
        ans += gain

print(ans)

2. Prim

isVisited : 방문여부 확인
eList : 간선 저장
heap : 현재 그래프에서 짧은 경로를 선택

현재 그래프에서 가장 짧은 간선을 골라 방문하지 않은 정점이라면 선택한다.

#2. Prim
import sys
import heapq
input = sys.stdin.readline

v, e = map(int, input().split())
isVisited = [False]*(v+1)
eList = [[] for _ in range(v+1)]
heap = [[0, 1]]

for _ in range(e):
    start, end, gain = map(int, input().split())
    eList[start].append([gain,end])
    eList[end].append([gain,start])

ans = 0
cnt = 0
while heap:
    if cnt == v:
        break
    gain, start = heapq.heappop(heap)
    if not isVisited[start]:
        isVisited[start] = True
        ans += gain
        cnt += 1
        for i in eList[start]:
            heapq.heappush(heap, i)

print(ans)

[Backjoon] 24479 알고리즘 수업 - 깊이 우선 탐색 1 Python 문제 풀이

ULISIA — Mon, 17 Jul 2023 12:23:34 +0900

출처:알고리즘 수업 - 깊이 우선 탐색 1

문제해석

1번 노드를 처음 시작하므로 첫번째 방문으로 visited 되었다고 표현하기 위해 isVisited[1]을 1로 바꿈
1번 노드와 연결된 2번, 4번 노드 중에서 2번 노드가 더 작으므로 2번 노드 방문 -> 2번 노드를 2번째로 방문하였으므로 isVisited[2]를 2로 변경
2번 노드와 연결된 1번, 3번, 4번 노드 중 방문하지 않은 노드 중에서 작은 값인 3번 노드 방문 -> 3번 노드를 3번째로 방문하였으므로 isVisited[3]을 3으로 변경
4번 노드와 연결된 1번, 3번, 4번 노드 중 방문하지 않은 노드들이 더 이상 없으므로 재귀 종료. 따라서 5번 노드는 시작 노드 1번으로부터 방문하지 못하는 노드이므로 0으로 명시
출력은 isVisited에 몇번째로 출력되는지를 구한다

주의할 점 방문하는 순서대로가 아니라 몇 번째로 출력되는지(dfs하면서 출력하면 안됨)

n(정점의 수), m(간선의 수), r(시작 정점 노드), graph(연결 노드 그래프), isVisited(방문 순서 입력 그래프)

n, m, r 입력 받기
m만큼 graph로 입력받은 후 graph의 배열마다 하나씩 오름차순 sort 정렬
dfs 함수 선언 및 재귀 반복, dfs 시작할 때 마다 isVisited에 ans 값 변경 + dfs 실행 후에는 ans 값 1 증가하여 순서대로 값 변경하기
isVisted 인덱스 값이 0인 값은 빼고 출력하기

해답코드

#알고리즘 수업 - 깊이 우선 탐색 1

import sys
sys.setrecursionlimit(10**6) #재귀 허용 깊이를 수동으로 늘려주는 코드

#정점의 수, 간선의 수, 시작 정점
n, m, r = map(int,sys.stdin.readline().split())
#연결노드 그래프 초기화(1번노드와 인덱스 값이 같게 하기 위해서 n+1)
#[[],[],[],[],[]]
graph = [[] for _ in range(n+1)]
#방문 순서 그래프 (위와 같이 인덱스 값과 노드의 값이 동일하게 만들기 위해서 n+1)
isVisited = [0]*(n+1)
#순서 입력
ans = 1

def dfs(graph,start,isVisited):
    #함수 밖의 ans 값을 사용하기 위해서 global 명시
    global ans
    #방문할 떄마다 순서 값 변경
    isVisited[start]=ans
    #연결노드 방문
    for i in graph[start]:
        #방문 안한 노드일 경우
        if not isVisited[i]:
            #순서 증가
            ans+=1
            #dfs 실행
            dfs(graph,i,isVisited)

#연결된 노드 입력 받기
for _ in range(m):
    start, end = map(int, sys.stdin.readline().split())
    graph[start].append(end)
    graph[end].append(start)

#오름차순 정리
for i in range(n+1):
    graph[i].sort()

dfs(graph,r,isVisited)

#순서 출력
for i in range(n+1):
    if i:
        print(isVisited[i])