๐ Graph ์ด๋ก
๐ Graph ์ด๋ก
- ๋ ธ๋(์ ์ )์ ๊ฐ์ (์ฃ์ง)๋ก ๊ตฌ์ฑ๋ ๊ตฌ์กฐ๋ฅผ ๋ค๋ฃฌ๋ค.
๐ ๊ทธ๋ํ์ ๊ธฐ๋ณธ ๊ฐ๋
- ์ ์ (Vertex) : ๊ทธ๋ํ์์ ๋ฐ์ดํฐ๋ฅผ ๋ํ๋ด๋ ์์. ์๋ฅผ ๋ค์ด ์์ , ๋์, ์ปดํจํฐ๊ฐ ๋๋ค.
- ๊ฐ์ (Edge) : ์ ์ ๋ค ์ฌ์ด์ ๊ด๊ณ๋ฅผ ๋ํ๋ด๋ ์ฐ๊ฒฐ์ . ์๋ฅผ ๋ค์ด ๋์ A์ ๋์ B๊ฐ ๋๋ก๋ก ์ฐ๊ฒฐ๋์ด ์์์ ํํ
- ๊ทธ๋ํ๋ ๋ฐฉํฅ ๊ทธ๋ํ ์ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ๋ก ๋๋ ์ ์๋ค.
- ๋ฐฉํฅ ๊ทธ๋ํ : ๊ฐ์ ์ ๋ฐฉํฅ์ด ์์ด์ ํ์ชฝ ๋ฐฉํฅ์ผ๋ก๋ง ์ด๋ ๊ฐ๋ฅ
- ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ : ๊ฐ์ ์ ๋ฐฉํฅ์ด ์์ด์, ๋ ์ ์ ์ฌ์ด๋ฅผ ์๋ฐฉํฅ์ผ๋ก ์ด๋ ๊ฐ๋ฅ
๐ ๊ทธ๋ํ ํํ ๋ฐฉ๋ฒ
- ์ธ์ ํ๋ ฌ
- ๋ฐฐ์ด์ ์ฌ์ฉํ์ฌ ๊ทธ๋ํ ํํ
- ๊ทธ๋ํ ํฌ๊ธฐ๊ฐ ์ปค์ง๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๊ฐ ๋ฐ์ํ ์ ์์.
- ์ธ์ ๋ฆฌ์คํธ
- ๋ฒกํฐ๋ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํ์ฌ ๊ทธ๋ํ ํํ
- ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ด ์ข์ ๊ฐ์ ์ด ์ ์ ๊ทธ๋ํ์์ ์ฌ์ฉํ๋ค.
๐ ๊ทธ๋ํ ์ข ๋ฅ
- ๋จ๋ฐฉํฅ ๊ทธ๋ํ : ๊ฐ ๊ฐ์ ์ ๋ฐฉํฅ์ด ์๋ ๊ทธ๋ํ
- ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ : ๊ฐ ๊ฐ์ ์ ๋ฐฉํฅ์ด ์๋ ๊ทธ๋ํ
- ๊ฐ์ค์น ๊ทธ๋ํ : ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ๋ถ์ฌ๋ ๊ทธ๋ํ
- ๋น๊ฐ์ค์น ๊ทธ๋ํ โ : ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ์๋ ๊ทธ๋ํ
- ์ฌ์ดํด์ด ์๋ ๊ทธ๋ํ : ๊ฐ์ ์ ์ํด ์ํ์ด ์๋ ๊ทธ๋ํ
- ์ฐ๊ฒฐ ๊ทธ๋ํ : ๋ชจ๋ ์ ์ ์ด ์๋ก ์ฐ๊ฒฐ๋์ด ์๋ ๊ทธ๋ํ
- ๋น์ฐ๊ฒฐ ๊ทธ๋ํ : ์ผ๋ถ ์ ์ ๋ค์ด ์ฐ๊ฒฐ๋์ด ์์ง ์์ ๊ทธ๋ํ
๐ป ๊ทธ๋ํ ํ์ ์๊ณ ๋ฆฌ์ฆ
๊ธฐ๋ณธ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ ๋๋น ์ฐ์ ํ์(BFS) ๊ณผ ๊น์ด ์ฐ์ ํ์(DFS) ์ด๋ค.
- ๋๋น ์ฐ์ ํ์(BFS)
- ํ์ ๋ฐฉ๋ฒ : ํ ์ ์ ์์ ์์ํ์ฌ, ๊ทธ ์ ์ ์ ์ธ์ ํ ๋ชจ๋ ์ ์ ๋ค์ ์ฐจ๋ก๋๋ก ํ์
- ํน์ง : ํ๋ฅผ ์ฌ์ฉํ์ฌ ํ์ ์งํ, ๊ฐ ๋ ๋ฒจ์ ์ฐจ๋ก๋๋ก ํ์
- ์ฃผ์ฉ๋ : ์ต๋จ ๊ฒฝ๋ก ์ฐพ๊ธฐ, ์ฐ๊ฒฐ์์ ์ฐพ๊ธฐ, ๊ทธ๋ํ ๋๋น ๊ณ์ฐ ๋ฑ๋ฑโฆ
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
void bfs(int start, vector<vector<int>>& graph, vector<bool>& visited) {
queue<int> q;
visited[start] = true;
q.push(start);
while (!q.empty()) {
int node = q.front();
q.pop();
cout << node << " "; // ํ์ฌ ๋
ธ๋๋ฅผ ์ถ๋ ฅ
for (int neighbor : graph[node]) {
if (!visited[neighbor]) {
visited[neighbor] = true;
q.push(neighbor);
}
}
}
}
int main() {
int n = 5; // ๋
ธ๋ ๊ฐ์
vector<vector<int>> graph(n); // ๊ทธ๋ํ (์ธ์ ๋ฆฌ์คํธ)
// ๊ทธ๋ํ ์ฐ๊ฒฐ
graph[0].push_back(1);
graph[0].push_back(4);
graph[1].push_back(2);
graph[2].push_back(3);
graph[3].push_back(4);
vector<bool> visited(n, false); // ๋ฐฉ๋ฌธ ์ฌ๋ถ ์ถ์
bfs(0, graph, visited); // ๋
ธ๋ 0๋ถํฐ BFS ์์
return 0;
}
- ๊น์ด ์ฐ์ ํ์(DFS)
- ํ์ ๋ฐฉ๋ฒ : ํ ์ ์ ์์ ์์ํ์ฌ , ๊ทธ ์ ์ ์ ์ธ์ ํ ์ ์ ๋ค์ ๊ฐ๋ฅํ ๊น์ด๊น์ง ํ์ ํ ๋ค์ ๋์ด์ ํ์ํ ๊ณณ์ด ์์ผ๋ฉด ๋ค์ ๋์์์ ๋ค๋ฅธ ๊ฒฝ๋ก๋ฅผ ํ์ํ๋ค.
- ํน์ง : ์คํ์ ์ฌ์ฉํ๊ฑฐ๋ ์ฌ๊ท๋ฅผ ์ด์ฉํ์ฌ ํ์์ ์งํ
- ์ฃผ์ฉ๋ : ๊ทธ๋ํ ์ฌ์ดํด ๊ฒ์ฌ, ๊ฒฝ๋ก ์ฐพ๊ธฐ ๋ฑ๋ฑโฆ
#include <iostream>
#include <vector>
using namespace std;
void dfs(int node, vector<vector<int>>& graph, vector<bool>& visited) {
visited[node] = true;
cout << node << " "; // ํ์ฌ ๋
ธ๋๋ฅผ ์ถ๋ ฅ
for (int neighbor : graph[node]) {
if (!visited[neighbor]) {
dfs(neighbor, graph, visited);
}
}
}
int main() {
int n = 5; // ๋
ธ๋ ๊ฐ์
vector<vector<int>> graph(n); // ๊ทธ๋ํ (์ธ์ ๋ฆฌ์คํธ)
// ๊ทธ๋ํ ์ฐ๊ฒฐ
graph[0].push_back(1);
graph[0].push_back(4);
graph[1].push_back(2);
graph[2].push_back(3);
graph[3].push_back(4);
vector<bool> visited(n, false); // ๋ฐฉ๋ฌธ ์ฌ๋ถ ์ถ์
dfs(0, graph, visited); // ๋
ธ๋ 0๋ถํฐ DFS ์์
return 0;
}
๐ ๊ทธ๋ํ ๊ด๋ จ ์๊ณ ๋ฆฌ์ฆ
- ์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ
- ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ : ๊ฐ์ค์น๊ฐ ์๋ ๊ทธ๋ํ์์ ํ ๋ ธ๋์์ ๋ค๋ฅธ ๋ชจ๋ ๋ ธ๋๋ก์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ
- ๋ฒจ๋ง-ํฌ๋ ์๊ณ ๋ฆฌ์ฆ : ๋ค์ต์คํธ๋ผ๋ณด๋ค ์ผ๋ฐํ๋ ํํ๋ก, ์์ ๊ฐ์ค์น๊ฐ ์์ ๋ ์ฌ์ฉ
- ํ๋ก์ด๋-์์ ์๊ณ ๋ฆฌ์ฆ : ๋ชจ๋ ์์ ๋ ธ๋์ ๋ํด ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ
- ์์ ์ ๋ ฌ(Topological Sort)
- ๋ชฉ์ : ์ฌ์ดํด์ด ์๋ ๋ฐฉํฅ ๊ทธ๋ํ์์ ๋ ธ๋๋ฅผ ์ ํ์ ์ธ ์์๋ก ๋ฐฐ์นํ๋ ์๊ณ ๋ฆฌ์ฆ. ์๋ฅผ ๋ค์ด, ์์ ์ค์ผ์ฅด๋ง ๋ฌธ์ ์ ์ฌ์ฉ๋จ
- ์๊ณ ๋ฆฌ์ฆ : DFS ๋๋ ํ๋ฅผ ์ด์ฉํ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๊ตฌํ๋จ
ํด๋น ์๊ณ ๋ฆฌ์ฆ์ ์์๋ฅผ ์ฌ๊ธฐ์ ์ ๋ถ ์๊ฐํ๋ ๊ฒ๋ณด๋ค Graph ๊ด๋ จ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ๋ค๋ณด๋ฉด ํด๋น ์๊ณ ๋ฆฌ์ฆ์ ์ ํ๊ฒ ๋๋ค.
๐ ๊ทธ๋ํ์ ์ฌ์ดํด ๊ฒ์ฌ
- ๋ฐฉํฅ ๊ทธ๋ํ์ ์ฌ์ดํด : DFS๋ฅผ ์ด์ฉํด ํ์ํ๋ฉด์ ์ญ์ถ์ (Back Tracking) ์ ํตํด ์ฌ์ดํด์ ๊ฒ์ฌ
- ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์ ์ฌ์ดํด : DFS๋ฅผ ์ด์ฉํด ๋ถ๋ชจ ๋ ธ๋๋ฅผ ์ถ์ ํ๋ฉฐ ์ฌ์ดํด์ ๊ฒ์ฌ
๐ก ๊ทธ๋ํ ๋ฌธ์ ํด๊ฒฐ์ C++ ์๋ฃ๊ตฌ์กฐ ์ฌ์ฉ
- ํ(queue) : BFS ๊ตฌํ์ ์ฌ์ฉ๋๋ค. ํ๋ ๋จผ์ ๋ค์ด์จ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ๋๊ฐ๋ FIFO ๊ตฌ์กฐ
- ์คํ(stack) : DFS ๋ฐ๋ณต ๊ตฌํ์ ์ฌ์ฉ๋๋ค. ์คํ์ ๋์ค์ ๋ค์ด์จ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ๋๊ฐ๋ LIFO ๊ตฌ์กฐ
- ๋งต(map) : ๊ฐ์ ์ ๋ณด๋ฅผ ํจ์จ์ ์ผ๋ก ์ ์ฅํ๊ฑฐ๋(์ค๋ณต ํ์ธ ๋ฑ), ๋ฐฉ๋ฌธ ์ฌ๋ถ ์ถ์ ์ ์์ฉ
- ์ (set) : ๊ทธ๋ํ์์ ์ค๋ณต๋ ๊ฐ์ ์ด๋ ๋ ธ๋๋ฅผ ์ฒ๋ฆฌํ ๋ ์ ์ฉ