1. Problem 📃

📚 출처 - 1260 - DFS와 BFS

문제 설명
그래프를 DFS로 탐색한 결과와 BFS로 탐색한 결과를 출력하는 프로그램을 작성하시오. 단, 방문할 수 있는 정점이 여러 개인 경우에는 정점 번호가 작은 것을 먼저 방문하고, 더 이상 방문할 수 있는 점이 없는 경우 종료한다. 정점 번호는 1번부터 N번까지이다.

입력
첫째 줄에 정점의 개수 N(1 ≤ N ≤ 1,000), 간선의 개수 M(1 ≤ M ≤ 10,000), 탐색을 시작할 정점의 번호 V가 주어진다. 다음 M개의 줄에는 간선이 연결하는 두 정점의 번호가 주어진다. 어떤 두 정점 사이에 여러 개의 간선이 있을 수 있다. 입력으로 주어지는 간선은 양방향이다.

출력
첫째 줄에 DFS를 수행한 결과를, 그 다음 줄에는 BFS를 수행한 결과를 출력한다. V부터 방문된 점을 순서대로 출력하면 된다.

입출력 예

예제 입력	예제 출력
4 5 1 1 2 1 3 1 4 2 4 3 4	1 2 4 3 1 2 3 4
5 5 3 5 4 5 2 1 2 3 4 3 1	3 1 2 5 4 3 1 4 2 5
1000 1 1000 999 1000	1000 999 1000 999

2. Logic 👨‍🏫

Logic 1. DFS
1. 방문 노드 체킹
2. 방문 노드와 연결되어 있는 노드가 있고, 방문하지 않았다면 방문
3. 2번 반복

Logic 2. BFS
1. queue(deque) 생성
2. queue에 시작 노드를 담아주고, 방문 노드 체킹
3. queue가 빌 때 까지 반복
4. queue에서 하나의 원소를 꺼내고
5. 아직 방문하지 않은 인접한 노드가 있다면 queue에 삽입

3. Code 💻

1. 내가 푼 코드 😁

from collections import deque

def bfs(v):
    queue = deque()
    queue.append(v)
    visited2[v] = 1
    while queue:
        v = queue.popleft()
        print(v, end = ' ')
        for i in range(1, N+1):
            # 방문하지 않았고, 노드가 연결되어 있다면 인접 노드 모두 추가
            if visited2[i] == 0 and graph[v][i] == 1:
                queue.append(i)
                visited2[i] = 1

def dfs(graph, V, visited):
    # 현재 노드 방문처리
    visited[V] = True
    print(V, end = ' ')

    # 현재 노드와 연결된 다른 노드를 재귀적으로 방문
    for i in range(1, N+1):
        if not visited[i] and graph[V][i] == 1:
            dfs(graph, i, visited)


N, M, V = map(int, input().split())

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

# 간선 
for i in range(M):
    a, b = map(int, input().split())
    graph[a][b] = graph[b][a] = 1

# 각 노드가 방문된 정보 표현
visited = [False] * (N+1)
visited2 = [False] * (N+1)
dfs(graph, V, visited)
print()
bfs(V)

4. Feedback 📚

1. DFS (Depth-First Search)

깊이 우선 탐색이라고도 불리는 DFS는 최대한 깊이 내려간 뒤, 더이상 깊이 갈 곳이 없을 경우 옆으로 이동해 탐색하는 방식을 이야기합니다.

개념

루트 노드(혹은 다른 임의의 노드)에서 시작해 다음 분기(branch)로 넘어가기 전에 해당 분기를 완벽하게 탐색하는 방식을 이야기합니다.

1. 모든 노드를 방문하고자 하는 경우에 이 방법을 선택함
2. 깊이 우선 탐색(DFS)이 너비 우선 탐색(BFS)보다 좀 더 간단함
3. 검색 속도 자체는 너비 우선 탐색(BFS)에 비해서 느림

Code

# DFS 함수 정의
def dfs(graph, v, visited):
    # 현재 노드를 방문 처리
    visited[v] = True
    print(v, end=' ')
    # 현재 노드와 연결된 다른 노드를 재귀적으로 방문
    for i in graph[v]:
        if not visited[i]:
            dfs(graph, i, visited)

# 각 노드가 연결된 정보를 리스트 자료형으로 표현(2차원 리스트)
graph = [
  [],
  [2, 3, 8],
  [1, 7],
  [1, 4, 5],
  [3, 5],
  [3, 4],
  [7],
  [2, 6, 8],
  [1, 7]
]

# 각 노드가 방문된 정보를 리스트 자료형으로 표현(1차원 리스트)
visited = [False] * 9

# 정의된 DFS 함수 호출
dfs(graph, 1, visited)

2. BFS (Breadth-First Search)

너비 우선 탐색이라고도 불리는 BFS는 최대한 넓게 이동한 다음, 더 이상 갈 수 없을 때 아래로 이동해 탐색하는 방식을 이야기합니다.

개념

루트 노드(혹은 다른 임의의 노드)에서 시작해 인접한 노드를 먼저 탐색하는 방법으로, 시작 정점으로부터 가까운 정점을 먼저 방문하고 멀리 떨어져 있는 정점을 나중에 방문하는 순회하는 방법입니다.

주로 두 노드 사이의 최단 경로를 찾고 싶을 때 이 방법을 선택합니다.

ex) 지구 상에 존재하는 모든 친구 관계를 그래프로 표현한 후 Sam과 Eddie사이에 존재하는 경로를 찾는 경우

• 깊이 우선 탐색의 경우 - 모든 친구 관계를 다 살펴봐야 할지도 모름
• 너비 우선 탐색의 경우 - Sam과 가까운 관계부터 탐색

Code

from collections import deque

# BFS 함수 정의
def bfs(graph, start, visited):
    # 큐(Queue) 구현을 위해 deque 라이브러리 사용
    queue = deque([start])
    # 현재 노드를 방문 처리
    visited[start] = True
    # 큐가 빌 때까지 반복
    while queue:
        # 큐에서 하나의 원소를 뽑아 출력
        v = queue.popleft()
        print(v, end=' ')
        # 해당 원소와 연결된, 아직 방문하지 않은 원소들을 큐에 삽입
        for i in graph[v]:
            if not visited[i]:
                queue.append(i)
                visited[i] = True

# 각 노드가 연결된 정보를 리스트 자료형으로 표현(2차원 리스트)
graph = [
  [],
  [2, 3, 8],
  [1, 7],
  [1, 4, 5],
  [3, 5],
  [3, 4],
  [7],
  [2, 6, 8],
  [1, 7]
]

# 각 노드가 방문된 정보를 리스트 자료형으로 표현(1차원 리스트)
visited = [False] * 9

# 정의된 BFS 함수 호출
bfs(graph, 1, visited)

3. DFS와 BFS 비교

DFS(깊이 우선 탐색)	BFS(너비 우선 탐색)
현재 정점에서 갈 수 있는 점들까지 들어가면서 탐색	현재 정점에 연결된 가까운 점들부터 탐색
스택 또는 재귀함수로 구현	큐를 이용해서 구현

💡 DFS와 BFS의 시간복잡도

두 방식 모두 조건 내의 모든 노드를 검색한다는 점에서 시간 복잡도는 동일합니다.

DFS와 BFS 둘 다 다음 노드가 방문하였는지를 확인하는 시간과 각 노드를 방문하는 시간을 합하면 됩니다.

N은 노드, E는 간선일 때

인접 리스트 : O(N+E)
인접 행렬 : O(N²)

일반적으로 E(간선)의 크기가 N²에 비해 상대적으로 적기 때문에 인접 리스트 방식이 효율적이다.

---

참고 자료 📩

동빈나 DFS & BFS

튜나 개발일기 DFS & BFS