๐๊ทธ๋ํ: ์ ์ (vertex)๋ค์ ์งํฉ V์ ์ด๋ค์ ์ฐ๊ฒฐ ํ๋ ๊ฐ์ (edge)๋ค์ ์งํฉ E๋ก ๊ตฌ์ฑ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋งํ๋ฉฐ, ๋ก ํํํ๋ค.
๐ข์ฌ๊ธฐ์ ์ ๊น! ๊ทธ๋ํ์ ์ข ๋ฅ๋ฅผ ํ์ตํ๊ธฐ ์ ์, ์ด์ ์๊ฐ์ ๋ฐฐ์ด ํธ๋ฆฌ์ ๊ทธ๋ํ์ ์ฐจ์ด์ ์ ์์๋ณด์.
ํธ๋ฆฌ๋ ๊ทธ๋ํ์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ ์ (Node)์ ๊ฐ์ (Edge)๊ฐ ์์ง๋ง, ๊น์ด(depth)๊ฐ ์์ด ๊ณ์ธต ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋ค๋ ์ ์์ ๊ทธ๋ํ์ ์ฐจ์ด๊ฐ ์๋ค.
base condition์ ์ญํ : ํธ๋ฆฌ๋ ๊ตฌ์กฐ์ ์ผ๋ก ์ฌ์ดํด์ด ์๊ธฐ ๋๋ฌธ์if (root == null) return null;๊ณผ ๊ฐ์ ์ฒดํฌ๋ง์ผ๋ก ์ถฉ๋ถํ์ง๋ง, ๊ทธ๋ํ๋ ๋ณดํต ๋ฌดํฅ ๊ทธ๋ํ(undirected graph)๋ก ์ฃผ์ด์ ธ ์ฌ์ดํด์ด ์กด์ฌํ ์ ์๊ธฐ ๋๋ฌธ์ ๋ฐฉ๋ฌธ ์ฌ๋ถ ํ์ธ์ด base condition์ ์ญํ ์ ํ๋ค.
๐๋ฐฉํฅ ๊ทธ๋ํ(Directed graph): ๋ค์ด์ค๋ edge์ ๋๊ฐ๋ edge๊ฐ ๋ฐ๋ก ์ ํด์ ธ์๋ ๊ทธ๋ํ๋ฅผ ์๋ฏธํจ
๐indegree: ํ๋์ ์ ์ ์ ๋ค์ด์ค๋ edge
๐outdegree: ํ๋์ ์ ์ ์์ ๋๊ฐ๋ edge
๐๋ฌดํฅ ๊ทธ๋ํ(Undirected graph): ๋ฐฉํฅ์ด ์ ์ ํด์ ธ ์์ด ๋ ์ ์ ๊ฐ์ edge๋ก ์ฐ๊ฒฐ์ด ๋์ด์์ผ๋ฉด V -> W ๋๋ W -> V๋ก ๊ฐ ์ ์๋ ๊ทธ๋ํ๋ฅผ ์๋ฏธํจ
๐simple graph: ๋ ์ ์ ๊ฐ์ edge๊ฐ 1๊ฐ๋ก๋ง ์ด๋ฃจ์ด์ ธ ์๋ ๊ทธ๋ํ
๐๋ค์ค๊ทธ๋ํ: ์ธ์ ํด์๋ ๋ ์ ์ ์ฌ์ด์ outdegree์ indegree๊ฐ 2๊ฐ ์ด์์ธ ๊ทธ๋ํ
๐ข์ฝํ ์์๋ Undirected graph์ simple graph๋ฅผ ์ฃผ๋ก ๋ค๋ฃธ!
๐๊ฐ์ค์น ๊ทธ๋ํ: ๊ฐ ๊ฒฝ๋ก(edge)๋ง๋ค ๊ฐ์ค์น(๋น์ฉ ๋๋ ์๊ฐ)๊ฐ ๋ค๋ฅธ ๊ทธ๋ํ
๐ข๊ฐ์ค์น ๊ทธ๋ํ๋ ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์์ ์ฃผ๋ก ์ฐ์ด๊ธฐ ๋๋ฌธ์ ์ถํ ์ฌํํธ์์ ๋ค๋ฃฐ ์์ ์
๊ทธ๋ํ๋ฅผ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ผ๋ก๋ ์ธ์ ํ๋ ฌ, ์ธ์ ๋ฆฌ์คํธ, ๊ทธ๋ฆฌ๊ณ ์์์ ๊ทธ๋ํ๋ก ์ด 3๊ฐ์ง๊ฐ ์๋ค.
row์ column์ ๋ฐ๋ผ, ์ฆ 2์ฐจ์ ๋ฐฐ์ด๋ก ๊ทธ๋ํ๋ฅผ ๊ตฌํํ ๊ฒ์ ๋งํ๋ค.

์์ ๊ฐ์ ๊ทธ๋ํ๋ฅผ ํ๋ ฌ๋ก ๋ํ๋ด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค๐

๐ฉ๊ทธ๋ฐ๋ฐ, ์ธ์ ํ๋ ฌ์ ์์ ๊ฐ์ด ์ ์ ์ ๋ง์๋ฐ ๊ฐ์ ์ ๊ฐ์๊ฐ ์ ์ ๋๋ 0์ ๊ฐ๊น์ง ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅํด์ผ ํ๊ธฐ ๋๋ฌธ์ ๋นํจ์จ์ ์ด๋ค.
๐จ๋ฐ๋ผ์ ์ธ์ ๋ฆฌ์คํธ๋ก ์์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
ํด์๋งต์ ํํ๋ก ์ ์๋๊ณ , Key๋ ์ ์ ๋ค์ด ๋ค์ด๊ฐ๊ณ , Value์๋ list ํํ๋ก ์ฐ๊ฒฐ ๊ด๊ณ๋ฅผ ํ์ํด์ค๋ค.
์์ ๊ทธ๋ํ๋ฅผ ์ธ์ ๋ฆฌ์คํธ๋ก ํํํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
public class GraphSort {
public static void main(String[] args) {
HashMap<String, List<String>> graph = new HashMap<>();
graph.put("A", List.of("B"));
graph.put("B", List.of("A", "C", "E"));
graph.put("C", List.of("B", "D"));
graph.put("D", List.of("C", "E", "F"));
graph.put("E", List.of("B", "D", "F"));
graph.put("F", List.of("D", "E"));
System.out.println(graph);
}
}
List.of()๋ ํ๋ ์ด์์ ์์๋ฅผ ํฌํจํ๋ ๋ถ๋ณ ๋ฆฌ์คํธ ๊ฐ์ฒด๋ฅผ ๋ฆฌํดํ๋ค.ImmutableCollections ํด๋์ค์ ์ธ์คํด์ค๋ฅผ ์ฃผ์
ํด์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ๋ถ๋ณ ๊ฐ์ฒด๋ฅผ ๋ฆฌํดํจ๋ณดํต, ๋ฏธ๋ก ๋ฌธ์ ๊ฐ ๋์ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๊ทธ๋ํ๋ฅผ ์์์ ์ผ๋ก ํํํ ์ ์๋ค.

๊ฒ์์์ด ๋ฒฝ์ด๊ณ ํฐ ์์ด ๊ธธ์ธ๋ฐ, ๋ฒฝ์ 1๋ก ๊ธธ์ 0์ผ๋ก ํํํจ์ผ๋ก์จ ๊ตฌ๋ถํ ์๊ฐ ์๋ค.
๋ฟ๋ง ์๋๋ผ, ๊ฐ ์์ญ์ ์ขํ ๊ฐ๋
์ ๋์
ํ์ฌ row์ col๋ก ์ธ์ ํ๋ ฌ๊ณผ ๋น์ทํ๊ฒ ํํํ ์๋ ์๋ค.

public class GraphSort {
public static void main(String[] args) {
int[][] maze = {
{1, 1, 1, 1, 1},
{0, 0, 0, 1, 1},
{1, 1, 0, 1, 1},
{1, 0, 0, 0, 0},
{1, 1, 1, 1, 1}
};
System.out.println(maze[2][1]);
}
}
๋ง์ฝ, (2, 1)์ ์ ๊ทผํ๊ณ ์ถ์ผ๋ฉด, maze[2][1]๋ฅผ ํตํด ๊ฐ์ ์์๋ผ ์ ์๋ค.