https://www.acmicpc.net/problem/1260
1260๋ฒ: DFS์ BFS
์ฒซ์งธ ์ค์ ์ ์ ์ ๊ฐ์ N(1 ≤ N ≤ 1,000), ๊ฐ์ ์ ๊ฐ์ M(1 ≤ M ≤ 10,000), ํ์์ ์์ํ ์ ์ ์ ๋ฒํธ V๊ฐ ์ฃผ์ด์ง๋ค. ๋ค์ M๊ฐ์ ์ค์๋ ๊ฐ์ ์ด ์ฐ๊ฒฐํ๋ ๋ ์ ์ ์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค. ์ด๋ค ๋ ์ ์ ์ฌ
www.acmicpc.net
๋ฐฑ์ค 1260๋ฒ DFS์ BFS๋ฅผ ๊ตฌํํ๋ ๋ฌธ์ ๋ค. OutOfBounds๊ฐ ๋ด๋๋ฐ, ์ด์ ๋ํ ์ด์ ๋ ๋ฐ์์ ์ค๋ช ํ ์์ ์ด๋ค.
A. B. C. D. E์ ์ฐ๋ฌผ์ด ์๋ค๊ณ ๊ฐ์ ํ์. ์ด ์ฐ๋ฌผ์ ํ๋ ๋ฐฉ๋ฒ์ 2๊ฐ์ง๊ฐ ์๋ค. ์ฒซ ๋ฒ์งธ๋ A ์ฐ๋ฌผ์ ๋๊น์ง ๋ค ํ ํ์ B๋ก ๋์ด๊ฐ์ B๋ฅผ ์ ๋ถ ํ๊ณ , C, D, E๋ ๊ฐ์ ๋ฐฉ์์ผ๋ก ํ๋ ๊ฒ์ด๋ค.
๋ ๋ฒ์งธ๋ A ์ฐ๋ฌผ์ 2m ํ๊ณ , B ์ฐ๋ฌผ์ 2m ํ๊ณ , C, D, E๋ ๊ฐ์ ๋ฐฉ์์ผ๋ก ํ๋ ๊ฒ์ด๋ค. E๋ฅผ 2m ํ ๋ค๋ฉด, ๋ค์ A๋ฅผ 2m ํ๋ ๊ฒ์ฒ๋ผ ๋์์ 5๊ฐ ์ฐ๋ฌผ์ ํ๋ ๋ฐฉ์์ด๋ค.
์ฒซ ๋ฒ์งธ๋ DFS์ ์ ์ฌํ ํ์๋ฐฉ๋ฒ์ด๊ณ , ๋ ๋ฒ์งธ๋ BFS์ ์ ์ฌํ๋ค.
DFS(Depth First Search)
๊น์ด ์ฐ์ ํ์์, ๋ฃจํธ ๋ ธ๋์์ ์์ํ์ฌ ํด๋น ๋ถ๊ธฐ๋ฅผ ๋ชจ๋ ํ์ํ ํ, ๋ค์ ๋ถ๊ธฐ๋ก ๋์ด๊ฐ๋ ํ์ ๋ฐฉ๋ฒ์ ์๋ฏธํ๋ค. ์ด๋ ์คํ์ด๋, ์ฌ๊ทํจ์๋ฅผ ํตํด ๊ตฌํํ ์ ์๋ค.
BFS(Breadth First Search)
๋๋น ์ฐ์ ํ์์, ๋ฃจํธ ๋ ธ๋์์ ์์ํ์ฌ ์ธ์ ํ ๋ ธ๋๋ฅผ ๋จผ์ ํ์ํ๋ ๋ฐฉ๋ฒ์ ์๋ฏธํ๋ค. ์ด๋ ํ๋ก ๊ตฌํํ ์ ์๋ค.
1260๋ฒ ํ ์คํธ ์ผ์ด์ค ์ดํด, ํด์

ํด๋น ๋ฌธ์ ์์๋ ๋ ธ๋, ๊ฐ์ ์ ๊ธธ์ด, ์์ ๋ ธ๋๊ฐ ์ฃผ์ด์ง๊ณ , ์ฐ๊ฒฐ๋ ๋ ธ๋๊ฐ ํ ์ค์ฉ ์ ์๋๋ค.

์ด๋ฅผ ๊ทธ๋ฆผ์ผ๋ก ๊ตฌํํ๋ฉด ์์ ๊ฐ๋ค. DFS(๊น์ด ์ฐ์ ํ์)์ ๊ฒฝ์ฐ ์์ ๋ ธ๋์ธ 1๋ถํฐ ํ์์ ํ ๋ค, ์ธ์ ํ ๋ ธ๋์ด๋ฉด์ ๊ฐ์ฅ ์์ ์ซ์์ธ 2๋ฅผ ๋ฐฉ๋ฌธํ ๊ฒ์ด๊ณ , ๊ทธ ๋ค์์ 2์ ์ฐ๊ฒฐ๋ 4๋ฅผ ๋จผ์ ๋ฐฉ๋ฌธํ ๊ฒ์ด๋ค. ๊ทธ ์ดํ 1๊ณผ ์ฐ๊ฒฐ๋์ด ์์๋ 3์ ๋ฐฉ๋ฌธํ ๊ฒ์ด๋ค.
BFS(๋๋น ์ฐ์ ํ์)์ ๊ฒฝ์ฐ 1 ํ์ ํ, ์ธ์ ํ 2๋ฅผ ํ์, ๊ทธ๋ฆฌ๊ณ ์ธ์ ํ 3, 4๋ฅผ ์์๋๋ก ํ์ํ ๊ฒ์ด๋ค.
์ด ๋ ์ค์ํ ๊ฒ์,

ํ ์คํธ ์ผ์ด์ค 2์ฒ๋ผ, ์ซ์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฅํ์ง ์๋ ๊ฒฝ์ฐ๋ฅผ ์กฐ์ฌํด์ผ ํ๋ค.
์ด๋ฅผ ๊ฐ๊ณผํ ๊ฒฝ์ฐ ๊ฒฐ๊ณผ๊ฐ ๋ฌ๋ผ์ง๊ฒ ๋๋ ์ ์ํ์.
๋ํ, DFS ๊ฒฐ๊ณผ๊ฐ์ ์ถ๋ ฅํ๊ณ BFS๋ ์ถ๋ ฅํด์ผ ํ๋ฏ๋ก, ์ฌ์ฉํ ํจ์๋ ๊ผญ ์ด๊ธฐํ์์ผ์ฃผ๋๋ก ํ์.
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <string.h>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
bool visited[1001]; //๋ฐฉ๋ฌธ ์ฌ๋ถ ์ฒดํฌ
vector <int> adj[1001]; //์ธ์ ํ ๋
ธ๋ ์ ์ฅ
queue <int> q;
int node, line, s;
void dfs(int now) {
visited[now] = 1;
printf("%d ", now);
for (int i = 0; i < adj[now].size(); i++) { //์ธ์ ํ ๋
ธ๋์ ๊ฐฏ์๋งํผ ๋ฐ๋ณต
int next = adj[now][i];
if (!visited[next]) { //์ธ์ ๋
ธ๋๊ฐ ํ ๋ฒ๋ ๋ฐฉ๋ฌธํ์ง ์์ ๋
ธ๋์ผ ๊ฒฝ์ฐ,
dfs(next); //ํด๋น ์ธ์ ๋
ธ๋์ ๋ ์ธ์ ํ๋ ๋
ธ๋๋ฅผ ์ฐพ๋ ๊ฒ์ด DFS. ๊ทธ๋ฌํ ์ด์ ๋ก ์ฌ๊ท ์ฌ์ฉ
}
}
}
void bfs(int now) {
visited[now] = 1;
q.push(now); //ํ๋ฅผ ๋ง๋ค์ด ํ์ฌ ๋
ธ๋์์ ์ธ์ ํ๋ ๋
ธ๋๋ฅผ ๋ชจ๋ ์ ์ฅํ ์ ์๋๋ก ํจ
while (!q.empty()) { //ํ๊ฐ ๋น์๋ค๋ ๊ฒ์ ์ ๋ถ ํ์ํ๋ค๋ ์๋ฏธ
int st = q.front();
printf("%d ", st);
q.pop(); //ํ์์ด ๋๋ ๋
ธ๋๋ pop์ผ๋ก ์ ๊ฑฐ
for (int i = 0; i < adj[st].size(); i++) { //์ธ์ ํ ๋
ธ๋์ ๊ฐฏ์๋งํผ ๋ฐ๋ณต
int next = adj[st][i];
if (!visited[next]) { //์ธ์ ๋
ธ๋๊ฐ ํ ๋ฒ๋ ๋ฐฉ๋ฌธํ์ง ์์ ๋
ธ๋์ผ ๊ฒฝ์ฐ,
visited[next] = 1; //ํด๋น ์ธ์ ๋
ธ๋๋ฅผ ํ์ ๋ฃ์ = ๋ฐฉ๋ฌธํ๋ค๋ ์๋ฏธ
q.push(next);
}
}
}
}
int main() {
int a, b;
scanf("%d %d %d", &node, &line, &s);
for (int i = 0; i < line; i++) {
scanf("%d %d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 0; i <= node; i++) {
sort(adj[i].begin(), adj[i].end()); //์ค๋ฆ์ฐจ์ ์ ๋ ฌ
}
dfs(s);
printf("\n");
memset(visited, 0, sizeof(visited)); //ํจ์ ์ด๊ธฐํ
bfs(s);
return 0;
}
adj[i][k]์์ i๋ ํ์ฌ ๋ ธ๋์ ์ซ์ ์์ฒด๋ฅผ, k๋ ์ธ๋ฑ์ค๋ฅผ ์๋ฏธํ๋ค. ๋ง์ฝ i๊ฐ 1์ด๋ผ๋ฉด,
k ์๋ฆฌ์ 0๋ฒ๋ฐฉ์๋ 2๊ฐ, 1๋ฒ๋ฐฉ์๋ 3์ด, 2๋ฒ๋ฐฉ์๋ 4๊ฐ ๋ค์ด๊ฐ๋ค. ์ฆ k ์๋ฆฌ์๋ ์ธ์ ํ ๋ ธ๋๊ฐ 0๋ฒ ์ธ๋ฑ์ค๋ถํฐ ๋ค์ด์๋ค.
์ด์(OutOfBounds ๋ฐํ์ ์๋ฌ) : for ๋ฐ๋ณต๋ฌธ ์ข ๋ฃ ์กฐ๊ฑด ์ค์
์์ ์ฝ๋ ์ค "์ค๋ฆ์ฐจ์ ์ ๋ ฌ"์ด๋ผ๋ ์ฃผ์ ๋ถ๋ถ์ ์ฃผ๋ชฉํ์. adj๋ผ๋ ๋ฒกํฐ๋ ์ธ์ ํ ๋ ธ๋์ ๊ฐ๋ค์ ์ ์ฅํ๋ค. ๊ทธ ์ ์ฅํ ๊ฐ๋ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํด์ฃผ๊ณ ์ for ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ๊ณ ์๋ค. ์ด๋ฐ์๋ ์ด ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฃ ์กฐ๊ฑด์ "๊ฐ์ ์ ๊ฐ์"๋งํผ์ผ๋ก ์ค์ ํ์๋ค. ๊ทธ๋ ๊ฒ ์ค์ ํ๋ฉด, ๋ ธ๋๋ณด๋ค ๊ฐ์ ์ ๊ฐ์๊ฐ ๋ง์ ๋ ์ค๋ฅ๋ฅผ ์ผ์ผํจ๋ค. ๊ผญ ๋ ธ๋์ ๊ฐ์๋งํผ ๋ฐ๋ณตํ ์ ์๊ฒ ์ฝ๋๋ฅผ ์์ฑํ์.
์ด๋ฌํ ์ด์ ๊ฐ ์๋๋ผ๋ฉด, ๋ค๋ฅธ ์ฝ๋์์ for ๋ฐ๋ณต๋ฌธ ์ข ๋ฃ์กฐ๊ฑด์ ์๋ชป ์ค์ ํ ๊ฒ์ ์๋์ง, ๋ฒกํฐ๋ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์๋ง๊ฒ ์ค์ ํ๋์ง๋ ํ์ธํด๋ณด์.