출처 : https://www.youtube.com/watch?v=7C9RgOcvkvo&list=PLRx0vPvlEmdAghTr5mXQxGpHjWqSz0dgC&index=3

🔎 그래프 탐색 알고리즘 : DFS/BFS

• 탐색(Search)이란 많은 양의 데이터 중에서 원하는 데이터를 찾는 과정
• 대표적인 그래프 탐색 알고리즘으로는 DFS와 BFS가 있습니다.
• DFS/BFS는 코딩 테스트에서 매우 자주 등장하는 유형이므로 반드시 숙지해야 합니다
  
  

✏️ 스택 자료구조

• 먼저 들어 온 데이터가 나중에 나가는 형식인 선입후출의 자료구조
• 입구와 출구가 동일한 형태로 스택을 시각화할 수 있다.

프링글스 통에 프링글스 넣기 🍪 같은 느낌

python

stack = []	# 리스트 자료형으로 사용

# 삽입(5) - 삽입(2) - 삽입(3) - 삽입(7) - 삭제() - 삽입(1) - 삽입(4) - 삭제()

# append(), pop()의 시간복잡도는 O(1)
stack.append(5)
stack.append(2)
stack.append(3)
stack.append(7)
stack.pop()
stack.append(1)
stack.append(4)
stack.pop()

print(stackl::-1])	# 최상단 원소부터 출력
print(stack)	# 최하단 원소부터 출력

Java

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Stack<Integer> s = new Stack<>();
		//삽입(5) - 삽입(2) - 삽입(3) - 삽입(7) - 삭제() - 삽입(1) - 삽입(4) - 삭제()
		s.push(5); 
        s.push(2); 
        s.push(3); 
        s.push(7); 		
        s.pop();
		s.push(1); 
        s.push(4);
		s.pop();

		//스택의 최상단 원소부터 출력
		while(!s.empty()) {
			System.out.print(s.peek() + " ");
			s.pop ();
        }
    }
}

✏️ 큐 자료구조

• 먼저 들어 온 데이터가 먼저 나가는 형식인 선입선출의 자료구조
  

입구와 출구가 모두 뚫려 있는 터널과 같은 형태 💨
예시 ) 은행창구에서 번호표 뽑고 기다리기


python

# 리스트로 큐를 구현할 수 있지만 시간복잡도가 높아 비효율적
from collections import deque

# 큐(Queue) 구현을 위해 deque 라이브러리 사용
queue = deque()

# 삽입(5) - 삽입(2) - 삽입(3) - 삽입(7) - 삭제() - 삽입(1) - 삽입(4) - 삭제()
queue.append(5)
queue.append(2)
queue.append(3)
queue.append(7)
queue.popleft()
queue.append(1)
queue.append(4)
queue.popleft()

print(queue) # 먼저 들어온 순서대로 출력

queue.reverse() # 역순으로 바꾸기 
print(queue) # 나중에 들어온 원소부터 출력

Java

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Queue<Integer> q = new LinkedList<>();

		// 삽입(5) - 삽입(2) - 삽입(3) - 삽입(7) - 삭제() - 삽입(1) - 삽입(4) - 삭제 ()
		q.offer(5); 
        q.offer(2); 
        q.offer(3); 
        q.offer(7);
		q.poll();
		q.offer(1); 
        q.offer(4); 
        q.poll();

        // 먼저 들어온 원소부터 추출
		while (!q.isEmpty()) {
			System.out.print(q.poll() + " ");
		}
	}
}

✏️ 재귀함수

• 재귀 함수(Recursive Function)란 자기 자신을 다시 호출하는 함수
• 모든 재귀 함수는 반복문을 이용하여 동일한 기능을 구현할 수 있다.

1️⃣ 단순한 형태의 재귀 함수 예제

• '재귀 함수를 호출합니다.' 라는 문자열을 무한히 출력

def recursive function():
	print('재귀 함수를 호출합니다.')
	recursive_function ()
recursive function()

• 어느 정도 출력하다가 최대 재귀 깊이 초과 메시지가 출력된다.
  

2️⃣ 팩토리얼로 구현한 재귀함수 예제

• n! = 1 x 2 x 3 x ... x (n-1) x n
• 0!과 1!은 1이다

# 반복적으로 구현한 n!
def factorial_iterative(n):
	result = 1
	# 1부터 n까지의 수를 차례대로 곱하기
	for i in range (1, n + 1):
		result *= i 
    return result

# 재귀적으로 구현한 n!
def factorial_recursive(n):
	if n <= 1:	# n이 1 이하인 경우 1을 반환
		return 1
	# n! = n * (n - 1)!를 그대로 코드로 작성하기
	return n * factorial_recursive(n - 1)
   
# 각각의 방식으로 구현한 n! 출력(n = 5)
print('반복적으로 구현:', factorial_iterative(5))
print('재귀적으로 구현:', factorial_recursive(5))

3️⃣ 최대공약수 계산(유클리드 호제법) 예제

두개의 자연수에 대한 최대공약수를 구하는 대표적인 알고리즘으로 유클리드 호제법이 있다.

유클리드 호제법

• 두 자연수 A, B에 대하여 (A > B) A를 B로 나눈 나머지를 R이라고 하자.
• 이때 A와 B의 최대공약수는 B와 R의 최대공약수와 같다.
  

👇🏻 유클리드 호제법의 아이디어를 그대로 재귀 함수로 작성할 수 있다. 따라서 최대공약수는 6이다.

👇🏻 위의 로직을 코드로 구현하면? 👀 꼭 A > B 아니어도 동작한다

def gcd(a, b):
    # a가 b의 배수라면 b 반환
	if a % b == 0:	
		return b   
    # a가 b의 배수가 아니라면 b가 a로 가고
    # a % b가 b로 가면서 재귀함수 호출
    else:	
		return gcd(b, a % b)    

print(gcd(192, 162))

✏️ 재귀함수의 종료 조건

• 재귀 함수를 문제 풀이에서 사용할 때는 재귀 함수의 종료 조건을 반드시 명시해야 한다.
  종료 조건을 제대로 명시하지 않으면 함수가 무한히 호출

종료 조건을 포함한 재귀 함수 예제

def recursive function(i):
	# 100번째 호출을 했을 때 종료되도록 종료 조건 명시
	if 1 == 100:
		return
	print(i, '번째 재귀함수에서', i + 1, ' 번째 재귀함수를 호출합니다.')
	recursive function(i + 1)
	print(i, '번째 재귀함수를 종료합니다.')
recursive function(1)

결과 : 제일 처음 호출한 함수가 제일 마지막에 호출됨 👉🏻 스택과 비슷하다!

🚨 재귀함수 사용의 유의 사항

재귀 함수가 반복문보다 유리한 경우도 있고 불리한 경우도 있다.

컴퓨터가 함수를 연속적으로 호출하면 컴퓨터 메모리 내부의 스택 프레임에 쌓이므로 스택을 사용해야 할 때 구현상 스택 라이브러리 대신에 재귀 함수를 이용하는 경우가 많다. 재귀 함수를 잘 활용하면 복잡한 알고리즘을 간결하게 작성할 수 있지만 오히려 다른 사람이 이해하기 어려운 형태의 코드가 될 수도 있으므로 신중하게 사용한다.

📌 DFS : Depth-First Search

• DFS는 깊이 우선 탐색이라고도 부르며 그래프에서 깊은 부분을 우선적으로 탐색하는 알고리즘이다.
• 스택 자료구조(or 재귀 함수)를 이용하며, 구체적인 동작 과정은 아래와 같다.

  1. 탐색 시작 노드를 스택에 삽입하고 방문 처리

  2. 스택의 최상단 노드에 방문하지 않은 인접한 노드가 하나라도 있으면 그 노드를 스택에 넣고 방문처리. 방문하지 않은 인접 노드가 없으면 스택에서 최상단 노드를 꺼낸다.

  3. 더 이상 2번의 과정을 수행할 수 없을 때까지 반복

DFS 동작 예시

• 1️⃣ 그래프 준비
  ✔️ 시작 노드는 1
  ✔️ 방문 기준은 번호가 낮은 인접 노드부터
  ✔️ 무방향 간선
  
  
• 2️⃣ 시작노드인 1을 스택에 삽입하고 방문처리를 한다.
  
  
• 3️⃣ 스택의 최상단 노드인 1에 방문하지 않은 인접 노드 2, 3, 8 이 있다. 이 중에서 가장 작은 노드인 2를 스택에 삽입하고 방문처리를 한다. 이제 스택의 최상단 노드는 2로 변경되었다!
  
  
• 4️⃣ 스택의 최상단 노드인 2에 방문하지 않은 인접 노드 7이 있다. 따라서 7번 노드를 스택에 삽입하고 방문처리를 한다. 인접 노드 중 7보다 번호가 더 낮은 1이 있지만, 이미 방문했으므로 PASS 다시 스택의 최상단 노드는 7로 변경되었다!
  
  
• 5️⃣ 스택의 최상단 노드인 7에 방문하지 않은 인접 노드 6, 8이 있다. 이 중에서 가장 작은 노드인 6을 스택에 넣고 방문 처리를 한다.
  
  
• 6️⃣ 스택의 최상단 노드인 6에 방문하지 않은 인접 노드가 없다. 따라서 스택에서 노드 6을 꺼낸다. 6을 꺼냈으면 다시 최상단 노드는 7이 된다.
  
  
• 7️⃣ 스택의 최상단 노드인 7에 방문하지 않은 인접 노드 8이 있으므로 노드 8을 스택에 넣고 방문 처리한다.
  
  
• 8️⃣ 이러한 과정을 반복하였을 때 전체 노드의 탐색 순서(스택에 들어간 순서)는 아래와 같다. 👇🏻
  

DFS 소스코드 예제

python

# 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 = [
	[],  # 노드의 번호가 1부터 시작하는 경우가 많기에 0은 비워둠
	[2, 3, 8],  # 노드 1
    [1, 7],  # 노드 2
	[1, 4, 5],  # 노드 3
	[3, 5],  # 노드 4
	[3, 4],  # 노드 5
    [7],  # 노드 6
	[2, 6, 8],  # 노드 7
	[1, 7]  # 노드 8
]

# 각 노드가 방문된 정보를 표현 (1차원 리스트)
visited = [False] * 9  # 인덱스 0은 사용하지 않기 위해 1 더 크게 생성

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

Java

import java.util.*;

public class Main {

    public static boolean[] visited = new boolean[9];
    public static ArrayList<ArrayList<Integer>> graph = new ArrayList<ArrayList<Integer>>();

    // DFS 함수 정의
    public static void dfs(int x) {
        // 현재 노드를 방문 처리
        visited[x] = true;
        System.out.print(x + " ");
        // 현재 노드와 연결된 다른 노드를 재귀적으로 방문
        for (int i = 0; i < graph.get(x).size(); i++) {
            int y = graph.get(x).get(i);
            if (!visited[y]) dfs(y);
        }
    }

    public static void main(String[] args) {
        // 그래프 초기화
        for (int i = 0; i < 9; i++) {
            graph.add(new ArrayList<Integer>());
        }

        // 노드 1에 연결된 노드 정보 저장 
        graph.get(1).add(2);
        graph.get(1).add(3);
        graph.get(1).add(8);
     
        // 노드 2에 연결된 노드 정보 저장 
        graph.get(2).add(1);
        graph.get(2).add(7);

        // 노드 3에 연결된 노드 정보 저장 
        graph.get(3).add(1);
        graph.get(3).add(4);
        graph.get(3).add(5);

        // 노드 4에 연결된 노드 정보 저장 
        graph.get(4).add(3);
        graph.get(4).add(5);

        // 노드 5에 연결된 노드 정보 저장 
        graph.get(5).add(3);
        graph.get(5).add(4);

        // 노드 6에 연결된 노드 정보 저장 
        graph.get(6).add(7);

        // 노드 7에 연결된 노드 정보 저장 
        graph.get(7).add(2);
        graph.get(7).add(6);
        graph.get(7).add(8);

        // 노드 8에 연결된 노드 정보 저장 
        graph.get(8).add(1);
        graph.get(8).add(7);

        dfs(1);
    }
}

📌 BFS : Breadth-First Search

• BFS는 너비 우선 탐색이라고도 부르며, 그래프에서 가까운 노드부터 우선적으로 탐색하는 알고리즘이다.
• 특정 조건에서의 최단경로 알고리즘 문제로 많이 출제
• BFS는 큐 자료구조를 이용하며, 구체적인 동작 과정은 아래와 같다.

  1. 탐색 시작 노드를 큐에 삽입하고 방문 처리

  2. 큐에서 노드를 꺼낸 뒤에 해당 노드의 인접 노드 중에서 방문하지 않은 노드를 모두 큐에 삽입하고 방문처리

  3. 더 이상 2번의 과정을 수행할 수 없을 때까지 반복

BFS 동작 예시

• 1️⃣ 그래프 준비
  ✔️ 시작 노드는 1
  ✔️ 방문 기준은 번호가 낮은 인접 노드부터
  ✔️ 무방향 간선
  
  
• 2️⃣ 시작노드인 1을 큐에 삽입하고 방문처리를 한다.
  
  
• 3️⃣ 큐에서 노드 1을 꺼내 방문하지 않은 인접노드 2, 3, 8을 큐에 삽입하고 방문처리를 한다. 이때, 큐에 넣는 순서는 방문한 순서대로이므로 번호가 낮은 인접 노드부터이다.
  
  
• 4️⃣ 큐에서 노드 2를 꺼내 방문하지 않은 인접노드 7을 큐에 삽입하고 방문처리를 한다.
  
  
• 5️⃣ 큐에서 노드 3를 꺼내 방문하지 않은 인접노드 4, 5를 큐에 삽입하고 방문처리를 한다.
  
  
• 6️⃣ 큐에서 노드 8를 꺼냈지만 방문하지 않은 인접노드가 없으므로 PASS
  
  
• 7️⃣ 이러한 과정을 반복하였을 때 전체 노드의 탐색 순서(큐에 들어간 순서)는 아래와 같다. 👇🏻
  
  노드 1을 기준으로 2, 3, 8의 거리는 1   7, 4, 5의 거리는 2   6의 거리는 3이다.

BFS 소스코드 예제

python

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 = [
	[],  # 노드의 번호가 1부터 시작하는 경우가 많기에 0은 비워둠
	[2, 3, 8],  # 노드 1
    [1, 7],  # 노드 2
	[1, 4, 5],  # 노드 3
	[3, 5],  # 노드 4
	[3, 4],  # 노드 5
    [7],  # 노드 6
	[2, 6, 8],  # 노드 7
	[1, 7]  # 노드 8
]

# 각 노드가 방문된 정보를 표현 (1차원 리스트)
visited = [False] * 9  # 인덱스 0은 사용하지 않기 위해 1 더 크게 생성

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

Java

import java.util.*;

public class Main {

    public static boolean[] visited = new boolean[9];
    public static ArrayList<ArrayList<Integer>> graph = new ArrayList<ArrayList<Integer>>();

    // BFS 함수 정의
    public static void bfs(int start) {
        Queue<Integer> q = new LinkedList<>();
        q.offer(start);
        // 현재 노드를 방문 처리
        visited[start] = true;
        // 큐가 빌 때까지 반복
        while(!q.isEmpty()) {
            // 큐에서 하나의 원소를 뽑아 출력
            int x = q.poll();
            System.out.print(x + " ");
            // 해당 원소와 연결된, 아직 방문하지 않은 원소들을 큐에 삽입
            for(int i = 0; i < graph.get(x).size(); i++) {
                int y = graph.get(x).get(i);
                if(!visited[y]) {
                    q.offer(y);
                    visited[y] = true;
                }
            }
        }
    }

    public static void main(String[] args) {
        // 그래프 초기화
        for (int i = 0; i < 9; i++) {
            graph.add(new ArrayList<Integer>());
        }

        // 노드 1에 연결된 노드 정보 저장 
        graph.get(1).add(2);
        graph.get(1).add(3);
        graph.get(1).add(8);

        // 노드 2에 연결된 노드 정보 저장 
        graph.get(2).add(1);
        graph.get(2).add(7);

        // 노드 3에 연결된 노드 정보 저장 
        graph.get(3).add(1);
        graph.get(3).add(4);
        graph.get(3).add(5);

        // 노드 4에 연결된 노드 정보 저장 
        graph.get(4).add(3);
        graph.get(4).add(5);

        // 노드 5에 연결된 노드 정보 저장 
        graph.get(5).add(3);
        graph.get(5).add(4);

        // 노드 6에 연결된 노드 정보 저장 
        graph.get(6).add(7);

        // 노드 7에 연결된 노드 정보 저장 
        graph.get(7).add(2);
        graph.get(7).add(6);
        graph.get(7).add(8);

        // 노드 8에 연결된 노드 정보 저장 
        graph.get(8).add(1);
        graph.get(8).add(7);

        bfs(1);
    }
}

✔️ [실습] 음료수 얼려먹기 🧊

소스코드

python

# N, M을 공백을 기준으로 구분하여 입력 받기
n, m = map(int, input().split())

# 2차원 리스트의 맵 정보 입력 받기
graph = []
for i in range(n):
    graph.append(list(map(int, input())))

# DFS로 특정한 노드를 방문한 뒤에 연결된 모든 노드들도 방문
def dfs(x, y):
    # 주어진 범위를 벗어나는 경우에는 즉시 종료
    if x <= -1 or x >= n or y <= -1 or y >= m:
        return False
    # 현재 노드를 아직 방문하지 않았다면
    if graph[x][y] == 0:
        # 해당 노드 방문 처리
        graph[x][y] = 1
        # 상, 하, 좌, 우의 위치들도 모두 재귀적으로 호출
        dfs(x - 1, y)
        dfs(x, y - 1)
        dfs(x + 1, y)
        dfs(x, y + 1)
        return True
    return False


# 모든 노드(위치)에 대하여 음료수 채우기
result = 0
for i in range(n):
    for j in range(m):
        # 현재 위치에서 DFS 수행
        if dfs(i, j) == True:
            result += 1

print(result) # 정답 출력

Java

import java.util.*;

public class Main {

    public static int n, m;
    public static int[][] graph = new int[1000][1000];

    // DFS로 특정 노드를 방문하고 연결된 모든 노드들도 방문
    public static boolean dfs(int x, int y) {
        // 주어진 범위를 벗어나는 경우에는 즉시 종료
        if (x <= -1 || x >=n || y <= -1 || y >= m) {
            return false;
        }
        // 현재 노드를 아직 방문하지 않았다면
        if (graph[x][y] == 0) {
            // 해당 노드 방문 처리
            graph[x][y] = 1;
            // 상, 하, 좌, 우의 위치들도 모두 재귀적으로 호출
            dfs(x - 1, y);
            dfs(x, y - 1);
            dfs(x + 1, y);
            dfs(x, y + 1);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // N, M을 공백을 기준으로 구분하여 입력 받기
        n = sc.nextInt();
        m = sc.nextInt();
        sc.nextLine(); // 버퍼 지우기

        // 2차원 리스트의 맵 정보 입력 받기
        for (int i = 0; i < n; i++) {
            String str = sc.nextLine();
            for (int j = 0; j < m; j++) {
                graph[i][j] = str.charAt(j) - '0';
            }
        }

        // 모든 노드(위치)에 대하여 음료수 채우기
        int result = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 현재 위치에서 DFS 수행
                if (dfs(i, j)) {
                    result += 1;
                }
            }
        }
        System.out.println(result); // 정답 출력 
    }
}

✔️ [실습] 미로 탈출 💫

소스코드

python

from collections import deque

# N, M을 공백을 기준으로 구분하여 입력 받기
n, m = map(int, input().split())
# 2차원 리스트의 맵 정보 입력 받기
graph = []
for i in range(n):
    graph.append(list(map(int, input())))

# 이동할 네 가지 방향 정의 (상, 하, 좌, 우)
dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]

# BFS 소스코드 구현
def bfs(x, y):
    # 큐(Queue) 구현을 위해 deque 라이브러리 사용
    queue = deque()
    queue.append((x, y))
    # 큐가 빌 때까지 반복하기
    while queue:
        x, y = queue.popleft()
        # 현재 위치에서 4가지 방향으로의 위치 확인
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            # 미로 찾기 공간을 벗어난 경우 무시
            if nx < 0 or nx >= n or ny < 0 or ny >= m:
                continue
            # 벽인 경우 무시
            if graph[nx][ny] == 0:
                continue
            # 해당 노드를 처음 방문하는 경우에만 최단 거리 기록
            if graph[nx][ny] == 1:
                graph[nx][ny] = graph[x][y] + 1
                queue.append((nx, ny))
    # 가장 오른쪽 아래까지의 최단 거리 반환
    return graph[n - 1][m - 1]

# BFS를 수행한 결과 출력
print(bfs(0, 0))

Java

import java.util.*;

class Node {

    private int x;
    private int y;

    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return this.x;
    }

    public int getY() {
        return this.y;
    }
}

public class Main {

    public static int n, m;
    public static int[][] graph = new int[201][201];

    // 이동할 네 가지 방향 정의 (상, 하, 좌, 우) 
    public static int dx[] = {-1, 1, 0, 0};
    public static int dy[] = {0, 0, -1, 1};

    public static int bfs(int x, int y) {
        // 큐(Queue) 구현을 위해 queue 라이브러리 사용 
        Queue<Node> q = new LinkedList<>();
        q.offer(new Node(x, y));
        // 큐가 빌 때까지 반복하기 
        while(!q.isEmpty()) {
            Node node = q.poll();
            x = node.getX();
            y = node.getY();
            // 현재 위치에서 4가지 방향으로의 위치 확인
            for (int i = 0; i < 4; i++) {
                int nx = x + dx[i];
                int ny = y + dy[i];
                // 미로 찾기 공간을 벗어난 경우 무시
                if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
                // 벽인 경우 무시
                if (graph[nx][ny] == 0) continue;
                // 해당 노드를 처음 방문하는 경우에만 최단 거리 기록
                if (graph[nx][ny] == 1) {
                    graph[nx][ny] = graph[x][y] + 1;
                    q.offer(new Node(nx, ny));
                } 
            } 
        }
        // 가장 오른쪽 아래까지의 최단 거리 반환
        return graph[n - 1][m - 1];
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // N, M을 공백을 기준으로 구분하여 입력 받기
        n = sc.nextInt();
        m = sc.nextInt();
        sc.nextLine(); // 버퍼 지우기

        // 2차원 리스트의 맵 정보 입력 받기
        for (int i = 0; i < n; i++) {
            String str = sc.nextLine();
            for (int j = 0; j < m; j++) {
                graph[i][j] = str.charAt(j) - '0';
            }
        }

        // BFS를 수행한 결과 출력
        System.out.println(bfs(0, 0));
    }
}