โ๊ณต๋ถํ๊ฒ ๋ ๊ณ๊ธฐ
โก๏ธ ๋ค์ ์๊ณ ๋ฆฌ์ฆ ์คํฐ๋ ์ฃผ์ ์ธ Graph ์ ๋ํด์ ์์ต
โ๏ธ๊ณต๋ถํ ๋ด์ฉ
1๏ธโฃ ๊ทธ๋ํ๋?
โ ์ ์
โก๏ธ ์ ์ (Vertex) ์ ๊ทธ ์ฌ์ด๋ฅผ ์๋ ๊ฐ์ (Edge) ๋ก ์ด๋ฃจ์ด์ง ์๋ฃ๊ตฌ์กฐ.
โ๏ธ ์ ์
G = (V,E) : ์ ์ ์ ์งํฉ V ์ ๊ฐ์ ์ ์งํฉ E ๋ก ์ด๋ฃจ์ด์ง ๊ตฌ์กฐ๋ฅผ ์๋ฏธ
V(G) : ๊ทธ๋ํ G ์์์์ ์ ์ ์ ์งํฉ
E(G) : ๊ทธ๋ํ G ์์์์ ๊ฐ์ ์ ์งํฉ
โก ์์ (๋ฌด๋ฐฉํฅ ๊ทธ๋ํ ๊ธฐ์ค)

โก๏ธ V(G) = {1, 2, 3, 4, 5}
โก๏ธ E(G) = {(1, 2), (3, 1), (3, 2), (4, 1), (5, 2), (5, 4)}
2๏ธโฃ ๊ทธ๋ํ ์ข ๋ฅ
โ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ (Undirected Graph)
โก๏ธ ๊ฐ์ ์ ๋ฐฉํฅ์ ์์ฑ์ด ์๋ ๊ทธ๋ํ์ด๋ค. ๋ ์ ์ V, W ๋ฅผ ์๋ ๊ฐ์ ์ (V, W) ๋ผ๊ณ ํ ๋, (V, W) == (W, V) ์ด๋ค.

โก ๋ฐฉํฅ ๊ทธ๋ํ (Directed Graph)
โก๏ธ ๊ฐ์ ์ ๋ฐฉํฅ์ ์์ฑ์ด ์๋ ๊ทธ๋ํ์ด๋ค. ๋ ์ ์ V, W ๋ฅผ ์๋ ๊ฐ์ ์ (V, W) ๋ผ๊ณ ํ ๋, (V, W) != (W, V) ์ด๋ค.

โข ์์ ๊ทธ๋ํ (Complete Graph)
โก๏ธ ํ ์ ์ ์์ ๋ค๋ฅธ ์ ์ ๋ชจ๋์ ์ฐ๊ฒฐ๋์ด์๋ ๊ทธ๋ํ์ด๋ค.

โฃ ๊ฐ์ค์น ๊ทธ๋ํ (Weighted Graph)
โก๏ธ ๊ฐ์ ๋ง๋ค ๊ฐ์ค์น๊ฐ ๋ถ์ฌ๋์ด์๋ ๊ทธ๋ํ์ด๋ค.

3๏ธโฃ ๊ทธ๋ํ ๊ตฌํ (Java) (1๏ธโฃ ์ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ ์์ ๊ธฐ์ค)
โ ์ธ์ ํ๋ ฌ
โก๏ธ ์๋ก์ ์ฐ๊ฒฐ ์ฌ๋ถ๋ฅผ ๊ธฐ๋กํ boolean ํ์ 2์ฐจ์ ๋ฐฐ์ด ์์ฑ (์ฐ๊ฒฐ : 1 / ๋น์ฐ๊ฒฐ : 0)
โก๏ธ ๋ฌด์กฐ๊ฑด n * n ์ ํํ ์ด๋ฏ๋ก ๋ฌด์กฐ๊ฑด O(n2) ์ ๊ณต๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง
// ์ธ์ ํ๋ ฌ ์ ์ธ
int[][] matrix = new int[n + 1][n + 1];
// ๋ฐฐ์ด์ ๋ด๋ ๊ณผ์
for(int[] edge : edges) {
matrix[edge[0]][edge[1]] = 1;
matrix[edge[1]][edge[0]] = 1;
}

โก ์ธ์ ๋ฆฌ์คํธ
โก๏ธ ๊ฐ ๋ ธ๋๋ณ๋ก ์ฐ๊ฒฐ๋ ๋ ธ๋๋ฅผ ๋ฐฐ์ดํํ๋ก ๋ด์ ๋ฆฌ์คํธ๋ฅผ ์์ฑ
โก๏ธ ํ์ํ๋งํผ๋ง ์ถ๊ฐ๋๋ ๋ฐฉ์์ด๊ธฐ ๋๋ฌธ์ ์ํฉ์ ๋ฐ๋ผ ๊ณต๊ฐ๋ณต์ก๋ ๋ญ๋น๊ฐ ๋ํด์ง
// ์ธ์ ๋ฆฌ์คํธ ์ ์ธ (1) : ๋ฐฐ์ด + ๋ฆฌ์คํธ
// โก๏ธ ๋ฆฌ์คํธ๋ฅผ ๋ด๊ณ ์๋ ๋ฐฐ์ด์ ์ ์ธํ๋ ๋ฐฉ์ (์ ์ )
ArrayList<Integer>[] list = new ArrayList[n + 1]; // ๋ฐฐ์ด ์์ฑ
for (int i = 0; i <= n; i++) list[i] = new ArrayList<>(); // ๋ฐฐ์ด ์ ๋ฆฌ์คํธ ์์ฑ
// ์ธ์ ๋ฆฌ์คํธ ์ ์ธ (2) : ๋ฆฌ์คํธ + ๋ฆฌ์คํธ
// โก๏ธ ๋ฆฌ์คํธ๋ฅผ ๋ด๊ณ ์๋ ๋ฆฌ์คํธ๋ฅผ ์ ์ธํ๋ ๋ฐฉ์ (๋์ )
ArrayList<ArrayList<Integer>> list = new ArrayList<>(); // ๋ฆฌ์คํธ ์์ฑ
for(int i = 0 ; i <= n ; i++) list.add(new ArrayList<>()); // ๋ฆฌ์คํธ ์ ๋ฆฌ์คํธ ์์ฑ
// ๋ฆฌ์คํธ์ ๋ด๋ ๊ณผ์ : ๋ฐฐ์ด + ๋ฆฌ์คํธ
for(int[] edge : edges) {
list[edge[0]].add(edge[1]);
list[edge[1]].add(edge[0]);
}
// ๋ฆฌ์คํธ์ ๋ด๋ ๊ณผ์ : ๋ฆฌ์คํธ + ๋ฆฌ์คํธ
for(int[] edge : edges) {
list.get(edge[0]).add(edge[1]);
list.get(edge[1]).add(edge[0]);
}

4๏ธโฃ ๊ทธ๋ํ ์ํ
โ DFS & BFS
โก๏ธ DFS ์ BFS ๋ฅผ ํตํด ๊ทธ๋ํ๋ฅผ ์ํ (์ด์ ์ ๊ด๋ จ ๋ด์ฉ์ ์ ๋ฆฌํ ๊ธ์ด ์์ผ๋ฏ๋ก ๋งํฌ๋ก ๋์ฒดํ๋ค.)
(Java) ๊น์ด ์ฐ์ ํ์ (DFS) & ๋๋น ์ฐ์ ํ์ (BFS )
โ๊ณต๋ถํ๊ฒ ๋ ๊ณ๊ธฐ โก๏ธ ๋ค์์ฃผ ์๊ณ ๋ฆฌ์ฆ ์คํฐ๋ ์ฃผ์ ์ธ DFS & BFS ์ ๋ํด์ ์์ต โ๏ธ๊ณต๋ถํ ๋ด์ฉ 1๏ธโฃ ๊ด๋ จ ์๋ฃ๊ตฌ์กฐ โก๏ธ DFS ์ BFS ์ ๋ํด ๊ณต๋ถํ๊ธฐ์ ์์๋์ด์ผํ ์๋ฃ๊ตฌ์กฐ๊ฐ ์๋ค. โ Stac
like099.tistory.com
โก ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ + ๋ฐธ๋จผ-ํฌ๋ + ์ฌ์ดํด
โก๏ธ ๊ทธ๋ํ ์ข ๋ฅ ์ค ๊ฐ์ค์น ๊ทธ๋ํ (Weighted Graph) ์ ๊ฒฝ์ฐ ์์ ๊ฐ์ค์น๊ฐ ์๋ค๋ ์ ์ ํ์ ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ ์ฃผ๋ก ์ฌ์ฉํ๋ค๊ณ ํ๋ค. ํด๋น ๋ด์ฉ์ ๋ฐ๋ก ์ ๋ฆฌํด ๋ณผ ์์ ์ด๋ค.
โ๏ธ ์ ์ฉ ์์ผ๋ณธ ์์
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
๐ง ์ถ๊ฐ๋ก ๊ถ๊ธํ ์
'Algorithm ๐ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| (์๊ณ ๋ฆฌ์ฆ ์คํฐ๋) (Programmers) ํ๋ ธ์ด์ ํ ๐ฐ (0) | 2023.05.23 |
|---|---|
| ์ด๋ถ ํ์ ๐ (Binary Search) (0) | 2023.04.17 |
| ๋์ ๊ณํ๋ฒ๐๏ธ (Dynamic Programming) (0) | 2023.03.13 |
| ๊น์ด ์ฐ์ ํ์ (DFS) & ๋๋น ์ฐ์ ํ์ (BFS ) (0) | 2023.01.15 |
| [๐จ ์ปค๋ฎค๋ฌ๋/7๊ธฐ/Java] ] ๊ฐ์ฅ ํฐ ์ (Bubble Sort) (0) | 2022.11.02 |