DFS์ BFS
ํ์ ์๊ณ ๋ฆฌ์ฆ์ ๋ํด์ ์์๋ณผ ๊ฒ์ด๋ค. ๊ทธ๋ํ์ ํ์์ ๋ชฉ์ ์ ๋ชจ๋ ์ ์ ์ 1๋ฒ์ฉ ๋ฐฉ๋ฌธ ํ๋ ๊ฒ์ด๋ค.
DFS (๊น์ด ์ฐ์ ํ์)
๊น์ด ์ฐ์ ํ์์ ํ ๋ฐฉํฅ์ผ๋ก ๊ฐ ์ ์๋ ๋งํผ ๊น์ด๊ฐ๊ธฐ๋๋ฌธ์ ๊น์ด ์ฐ์ ํ์์ด๋ค. ์ผ๋ฐ์ ์ผ๋ก DFS ํ์๋ฐฉ๋ฒ์์๋ ์คํ(stack)์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ๋ค.
๋ฐฑํธ๋ํน(Backtracking)
ํ์ ๊ณผ์ ์์ ๋ฌดํํ ๊น์ด๊ฐ๋ ๊ฒ์ ๋ฐฉ์งํ๊ธฐ ์ํด์ ๊น์ด์ ํ(depth bound)์ ๋๋ค. depth bound์ ๋๋ฌํ ๋๊น์ง ๋ชฉํ(๋ ธ๋)๊ฐ ๋ฐ๊ฒฌ๋์ง ์์ผ๋ฉด ๊ทธ ์ ์ ํ์ํ ๋ ธ๋์ ๋ถ๋ชจ ๋ ธ๋๋ก ๋๋์์จ๋ค. ์ด๋ ๊ฒ ๋๋์ ์ค๋ ๊ณผ์ ์ ๋ฐฑํธ๋ํน(Backtracking)์ด๋ผ ํ๋ค.
ํ์๊ณผ์

์ต๋ํ ๊น์ํ ๋ง์๊ฒ์ ํ์ํ ๋ ์ฌ์ฉํ๋ฉฐ, ์คํ์ ์ฌ์ฉํ๋ค.
์คํ์ ์ด์ฉํด ๊ฐ ์ ์๋ ๋งํผ ์ต๋ํ ๋ง์ด๊ฐ๊ณ , ๊ฐ ์ ์์ผ๋ฉด ์ด์ ์ ์ ์ผ๋ก ๋์์จ๋ค.(๋ฐฑํธ๋ํน)
๋ฐฉ๋ฌธํ ๊ณณ์ ํ์๋ฅผ ํด๋๋ค.(check[i] )
์ด๋ฏธ ๋ฐฉ๋ฌธํ ๊ณณ์ ๊ฑด๋๋๊ณ , ๊ฐ ์ ์๋ ๊ณณ์ผ๋ก ๊ฐ๋ค. ์คํ์ด ๋น์์ง ๋๊น์ง ๊ณ์ pop์ ํ๋ค. ์คํ์ด ๋น์ด์์ผ๋ฉด DFSํ์์ด ์ข ๋ฃ๋๋ค.
์ฅ๋จ์
์ฅ์
ํ์ฌ ๊ฒฝ๋ก์์ ๋ ธ๋๋ค๋ง ๊ธฐ์ตํ๋ฉด ๋๋ฏ๋ก ์ ์ฅ๊ณต๊ฐ์ ์์๊ฐ ๋น๊ต์ ์ ๋ค.
๋ชฉํ๋ ธ๋๊ฐ ๊น์ ๋จ๊ณ์ ์์ ๊ฒฝ์ฐ์ ํด๋ฅผ ๋นจ๋ฆฌ ๊ตฌํ ์ ์๋ค.
๋จ์
ํด๊ฐ ์๋ ๊ฒฝ๋ก์ ๋๋ฌด ๊น์ด ๋น ์ง๊ฒ ๋ ๊ฐ๋ฅ์ฑ์ด ์๋ค. ๋ฐ๋ผ์ ์ค์ ๊ฒฝ์ฐ์๋ ๋ฏธ๋ฆฌ ์ง์ ํ ์์์ ๊น์ด(depth bound)๊น์ง๋ง ํ์ํ๊ณ ๋ชฉํ๋ ธ๋๋ฅผ ๋ฐ๊ฒฌํ์ง ๋ชปํ๋ฉด ๋ค์ ๊ฒฝ๋ก๋ฅผ ๋ฐ๋ผ ํ์ํ๋ ๊ฒ์ด ์ ์ฉํ ์ ์๋ค.
์ป์ด์ง ๊ฒฝ๋ก๊ฐ ์ต๋จ ๊ฒฝ๋ก๊ฐ ์๋ ์ ์๋ค. ๋ชฉํ๊น์ง์ ๊ฒฝ๋ก๊ฐ ์ฌ๋ฌ๊ฐ์ธ ๋ฌธ์ ์ ๋ํด์ DFS๋ ๋ชฉํ์ ๋๋ฌํ๋ฉด ํ์์ ์ข ๋ฃํ๋ฏ๋ก, ์ด๋ ์ฐพ์ ๊ฒฝ๋ก๋ ์ต์ ์ ๊ฒฝ๋ก๊ฐ ์๋ ์ ์๋ค.
๊ตฌํ
๊ทธ๋ํ๊ฐ disconnected์ด๊ฑฐ๋ ํน์ ๋ฐฉํฅ ๊ทธ๋ํ๋ผ๋ฉด DFS์ ์ํด์ ๋ชจ๋ ๋ ธ๋๊ฐ ๋ฐฉ๋ฌธ๋์ง ์์ ์ ์๋ค.
์๋์ฝ๋
DFS(G, v)
visited[v] <- yes
for each node adjacent to x do
if visited[v] = NO then
DFS(G, u);
end
end
์ธ์ ํ๋ ฌ ๊ตฌํ
dfs(x)๋ x๋ฅผ ๋ฐฉ๋ฌธํ๋ค๋ ์๋ฏธ์ด๋ค. ์ฌ๊ท ํธ์ถ์ ์ด์ฉํด์ ๊ตฌํํ ์ ์๋ค.
void dfs(int x){
check[x] = true; //๋ฐฉ๋ฌธํ ๊ฒ ํ์
printf("%d ",x);
//๋ค์ ์ ์ ๋ฐฉ๋ฌธ
for(int i=1;i<=n;i++){
//๊ฐ์ ์ด ์๊ณ , ๋ฐฉ๋ฌธ์ ํ์ง ์์์ ๊ฒฝ์ฐ
if(a[x][i]==1 && check[i]==false) dfs(i);
}
}
//์ธ์ ํ๋ ฌ ๋ฐฑํธ๋ฆญํน ๊ธฐ๋ฒ
//๋ฐ๋ณต๋ฌธ n^2๋ฒ ์คํ
bool visited[101];
void dfs(int k)
{
for(int i=0;i<=n;i++)
if(G[k][i] && !visited[G[k][i]])
{
visited[G[k][i]]=true;
dfs(G[k][i]);
}
return;
}
์๊ฐ๋ณต์ก๋ : V*O(V) = O(V^2)
์ธ์ ๋ฆฌ์คํธ ์ฌ์ฉ
ํญ์ ์๋ ๊ฐ์ ๋ง ์ ์ฅํ๋ค.
void dfs(int x){
check[x] = true; //๋ฐฉ๋ฌธํ ๊ฒ ํ์
printf("%d ",x);
//๋ค์ ์ ์ ๋ฐฉ๋ฌธ
// a[x]๋ x์ ์ฐ๊ฒฐ๋ ์ ์ ์ด๋ค.
for(int i=1;i<a[x].size();i++){
int y = a[x][i];
if(check[y]==false)dfs(y);
}
}
//์ธ์ ๋ฆฌ์คํธ ๋ฐฑํธ๋ํน ๊ธฐ๋ฒ
//๋ฐ๋ณต๋ฌธ m๋ฒ์คํ
bool visited[101];
void dfs(int k)
{
for(int i=0;i<G[i].size();i++)
if(!visited[G[k][i].to])
{
visited[G[k][i].to]=true;
dfs(G[k][i]);
}
return;
}
๋ชจ๋ ์ ์ ์ ํ๋ฒ์ฉ ๊ฑฐ์น๊ณ ๋ชจ๋ ๊ฐ์ ์ ํ๋ฒ์ฉ ๊ฒ์ฌํ๊ฒ ๋๋ค.
์๊ฐ๋ณต์ก๋ O(V+E)
BFS (๋๋น ์ฐ์ ํ์)
ํ์ฌ ์ ์ ์์ ๊น์ด๊ฐ 1์ธ ์ ์ ์ ๋ชจ๋ ํ์ํ ๋ค ๊น์ด๋ฅผ ๋๋ ค๊ฐ๋ ๋ฐฉ์์ด๋ค. ๋๋น์ฐ์ ํ์์ ๋ฐฑํธ๋์ ํ์ง ์๋๋ค. ๋์ ์ ํ์ฌ ์ ์ ์์ ๊น์ด๊ฐ 1์ธ ์ ์ ์ ๋ชจ๋ ๋ฐฉ๋ฌธํด์ผํ๋ฏ๋ก ํ(queue)๋ผ๋ FIFO(First In First Out)์๋ฃ๊ตฌ์กฐ๋ฅผ ํ์ฉํด ํ์ฌ ์ ์ ์์ ๊น์ด๊ฐ 1 ๋ ๊น์ ๋ชจ๋ ์ ์ ์ ์์ฐจ์ ์ผ๋ก ํ์ ์ ์ฅํด ํ์์ ํ์ฉํ๋ค.
std::queue()
๋ฅผ ํ์ฉํ๋ ๋ฐฉ๋ฒ์ ์ตํ ํ์๊ฐ ์๋ค.
BFS๋ฅผ ํ๋ฉด์ ๊ฐ ๋ ธ๋์ ๋ํด์ ์ต๋จ ๊ฒฝ๋ก์ ๊ธธ์ด๋ฅผ ๊ตฌํ ์ ์๋ค.
ํ์๊ณผ์

L0 = {s}, s๋ ์ถ๋ฐ ๋ ธ๋
L1 = L0์ ๋ชจ๋ ์ด์ ๋ ธ๋๋ค
L2 = L1์์ ๋ชจ๋ ์ด์๋ค ์ค L0์ ์ํ์ง ์๋ ๋ ธ๋๋ค
...
LN = Ln์์ ๋ชจ๋ ์ด์๋ค ์ค Ln-1์ ์ํ์ง ์๋ ๋ ธ๋๋ค
๋ค์๊ณผ ๊ฐ์ ์์๋ก ๋ฐฉ๋ฌธํ๋ ๋ฐฉ๋ฒ์ด๋ค.
Queue
์ต๋ํ ๋๊ฒ ๊ฐ๋๊ธธ์ ํ์ํ ๋ ์ฌ์ฉํ๋ฉฐ, ํ๋ฅผ ์ฌ์ฉํ๋ค. ํ๋ฅผ ์ด์ฉํด์ ์ง๊ธ ์์น์์ ๊ฐ ์ ์๋ ๊ฒ์ ๋ชจ๋ ํ์ ๋ฃ๋ ๋ฐฉ์์ด๋ค.
BFS๋ ํ์ ๋ฃ์ ๋ ๋ฐฉ๋ฌธํ๋ค๊ณ ์ฒดํฌ(check[i])ํด์ผํ๋ค.
ํ์์ popํ ๋ ธ๋๋ค ์ค์์ ๋ฐฉ๋ฌธํ์ง ์์ ๋ชจ๋ ์ด์ ๋ ธ๋๋ฅผ ํ์ ๋ฃ์ผ๋ฉด์ ๋ฐฉ๋ฌธํ๋ค๊ณ ์ฒดํฌํด์ค๋ค.
Queue๊ฐ ๋น๋๊น์ง ์งํํด์ค๋ค.
๊ตฌํ
๊ทธ๋ํ๊ฐ disconnected์ด๊ฑฐ๋ ํน์ ๋ฐฉํฅ ๊ทธ๋ํ๋ผ๋ฉด BFS์ ์ํด์ ๋ชจ๋ ๋ ธ๋๊ฐ ๋ฐฉ๋ฌธ๋์ง ์์ ์ ์๋ค.
์๋์ฝ๋
BFS(G, s)// ๊ทธ๋ํ G์ ์ถ๋ฐ ๋
ธ๋ s
Q <- รธ; // ํ๋ฅผ ํ๋ ์์ฑ
Enqueue(Q,s);
while Q!=รธ do
u <- Dequeue(Q)
for each v adjacent to u do
if v is unvisited then
mark v is visited;
Enqueue(Q,v);
end;
end;
end;
์ธ์ ํ๋ ฌ
queue<int> q;
check[1]= true;
q.push(1);
while(!q.empty()){
int x = q.front;
q.pop();
printf("%d ",x);
//๋ค์ ์ ์ ์ ์ฐพ๊ธฐ
for(int i=1;i<=n;i++){
if(a[x][i]==1&&check[i]==false){
check[i]=true;
q.push(i);
}
}
}
//์ธ์ ํ๋ ฌ
bool visited[101];
void bfs(int k)
{
std::queue<int> Q;
Q.push(k), visited[k]=1;
while(!Q.empty())
{
int current = Q.front();Q.pop();
for(int i=0;i<G[current].size();i++)
if(G[current][i]&&!vistited[G[current][i]])
{
visited[G[current][i]]=1;
Q.push(G[current][i]);
}
}
}
์ ์ฒด ํ์ํ๋๋ฐ ์์ด์ ๋ฐ๋ณต๋ฌธ์ n^2๋ฒ ์คํํ๊ฒ๋๋ค.
์๊ฐ๋ณต์ก๋ O(V^2)
์ธ์ ๋ฆฌ์คํธ
queue<int> q;
check[1]= true;
q.push(1);
while(!q.empty()){
int x = q.front;
q.pop();
printf("%d ",x);
//๋ค์ ์ ์ ์ ์ฐพ๊ธฐ
for(int i=1;i<a[x].size;i++){
int y = a[x][i];
if(check[y]==false){
check[y]=true;
q.push(i);
}
}
}
//์ธ์ ๋ฆฌ์คํธ์ ์ ์ฅํ์ ๊ฒฝ์ฐ
#include <queue>
bool visited[101];
void bfs(int k)
{
std::queue<int> Q;
Q.push(k), visited[k]=1;
while(!Q.empty())
{
int current = Q.front();Q.pop();
for(int i=0;i<G[current].size();i++)
if(!vistited[G[current][i]])
{
visited[G[current][i]]=1;
Q.push(G[current][i]);
}
}
}
์ ์ฒด๋ฅผ ํ์ํ๋ ๋ฐ ์์ด์ ๋ฐ๋ณต๋ฌธ์ m๋ฒ ์คํํ๊ฒ ๋๋ค.
์ต๋จ ๊ฒฝ๋ก
์ ๋ ฅ : ๋ฐฉํฅ ํน์ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ G(V,E), ๊ทธ๋ฆฌ๊ณ ์ถ๋ฐ๋ ธ๋ s
์ถ๋ ฅ : ๋ชจ๋ ๋ ธ๋ v์ ๋ํด์
d[v] = s๋ก๋ถํฐ v๊น์ง์ ์ต๋จ ๊ฒฝ๋ก์ ๊ธธ์ด(์ฃ์ง์ ์)
ฯ[v] = s๋ก๋ถํฐ v๊น์ง์ ์ต๋จ ๊ฒฝ๋ก์์์ v์ ์ง์ ๋ ธ๋(predecessor)
BFS(G, s)// ๊ทธ๋ํ G์ ์ถ๋ฐ ๋
ธ๋ s
Q <- รธ;
d[v]<-0;
ฯ[v]<-null;
Enqueue(Q,s);
while Q!=รธ do
u <- Dequeue(Q)
for each v adjacent to u do
if v is unvisited then //์ผ๋ฐ์ ์ผ๋ก ๋ฐฉ๋ฌธํ์ง ์์ ๊ฒ์ -1๋ก ๋ฃ์ด๋๊ณ ๊ตฌํ๋ค.
mark v is visited;
d[v]<-d[u]+1;
ฯ[v]<-u;
Enqueue(Q,v);
end;
end;
end;
// ์ต๋จ๊ฒฝ๋ก ์ถ๋ ฅ
PRINT-PATH(G,s,v)
if v=s then
print s;
else if ฯ[v] = null then
print "no path from s to v exists";
else
PRINT-PATH(G,s,ฯ[v]);
print v;
end.
์๊ฐ๋ณต์ก๋
์๊ฐ๋ณต์ก๋ O(V+E)
DFS vs BFS
DFS
BFS
๋์ ์๋ฆฌ
์คํ
ํ
๊ตฌํ ๋ฐฉ๋ฒ
์ฌ๊ท
ํ ์๋ฃ๊ตฌ์กฐ ์ด์ฉ
๋ฌธ์ ํ์ด๋ณด๊ธฐ
๊ทธ๋ํ๋ฅผ DFS๋ก ํ์ํ ๊ฒฐ๊ณผ์ BFS๋ก ํ์ํ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๋จ, ๋ฐฉ๋ฌธํ ์ ์๋ ์ ์ ์ด ์ฌ๋ฌ ๊ฐ์ธ ๊ฒฝ์ฐ์๋ ์ ์ ๋ฒํธ๊ฐ ์์ ๊ฒ์ ๋จผ์ ๋ฐฉ๋ฌธํ๊ณ , ๋ ์ด์ ๋ฐฉ๋ฌธํ ์ ์๋ ์ ์ด ์๋ ๊ฒฝ์ฐ ์ข ๋ฃํ๋ค. ์ ์ ๋ฒํธ๋ 1๋ฒ๋ถํฐ N๋ฒ๊น์ง์ด๋ค.
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;
vector<int> a[1001];
bool check[1001];
void dfs(int node) {
check[node] = true;
printf("%d ",node);
for (int i=0; i<a[node].size(); i++) {
int next = a[node][i];
if (check[next] == false) {
dfs(next);
}
}
}
void bfs(int start) {
queue<int> q;
//memset์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ด๊ธฐํ ํ๋ ํจ์
//1๋ฒ ํ๋ผ๋ฏธํฐ๋ ๊ฐ์ ๋ณต์ฌํ ๊ณณ์ด๊ณ , 2๋ฒ ํ๋ผ๋ฏธํฐ๋ ์ด๊ธฐํํ ๊ฐ, ๋ง์ง๋ง์ ์ผ๋ง๋งํผ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ด๊ธฐํ ํ ๊ฒ์ธ์ง ํ๋ ํฌ๊ธฐ์ด๋ค.
memset(check,false,sizeof(check));
check[start] = true;
q.push(start);
while (!q.empty()) {
int node = q.front();
q.pop();
printf("%d ",node);
for (int i=0; i<a[node].size(); i++) {
int next = a[node][i];
if (check[next] == false) {
check[next] = true;
q.push(next);
}
}
}
}
int main() {
int n, m, start;
scanf("%d %d %d",&n,&m,&start);
for (int i=0; i<m; i++) {
int u,v;
scanf("%d %d",&u,&v);
a[u].push_back(v);
a[v].push_back(u);
}
for (int i=1; i<=n; i++) {
sort(a[i].begin(), a[i].end());
}
dfs(start);
puts("");
bfs(start);
puts("");
return 0;
}
DFS
flood_fill
์ง๋ขฐ์ฐพ๊ธฐ, ๋ฟ์๋ฟ์ ๋ฑ ๊ฒ์์์ ๋ง์ด ํ์ฉ๋๋ ์๊ณ ๋ฆฌ์ฆ. ์ฌ๊ทํจ์๋ฅผ ์ด์ฉํด ๊น์ด์ฐ์ ํ์์ ๊ตฌํํ๋ค. ํ์ง๋ง ์ฌ๊ท์ ๊น์ด๊ฐ ๋๋ฌด ์ปค์ง๋ฉด runtime error๊ฐ ๋ฐ์ํ ์ ์๋ค. ๊น์ด๊ฐ ๋๋ฌด ํฌ๋ค๊ณ ํ๋จ๋๋ฉด ๋๋น์ฐ์ ํ์์ผ๋ก ์ฒ๋ฆฌํ๊ฑฐ๋ ์ฌ๊ท๋์ ์คํ์ ์ด์ฉํ๋ค.
dfsํจ์ ๋ถ๋ถ์ 4๋ฐฉํฅ ํ์์ dx,dy๋ฅผ ์ด์ฉํด ์์ฑํ ์ ์๋ค.
int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
void dfs(int a, int b, int c)
{
A[a][b]=c;
for(int i=0;i<4;i++)
if(safe(a+dx[i],b+dy[i])&&A[a+dx[i]][b+dy[i]]==1)
dfs(a+dx[i],b+dy[i],c);
}
n-queen
n*n์ฒด์ค ๋ณด๋ํ์ n๊ฐ์ queen์ ์๋ก ๊ณต๊ฒฉํ์ง ๋ชปํ๋๋ก ๋ฐฐ์นํ๋ ๋ฐฉ๋ฒ์ ์ฐพ์๋ด๋ ๋ฌธ์ . ๋๊ฐ์ ๊ฒ์ฌํ๋ฉด์ ๊ฐ์ผํ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํ๋ค.
ํธ์ 8๋ฐฉํฅ์ผ๋ก ๋ชจ๋ ๊ณต๊ฒฉํ ์ ์๋ค.
์ฒซ ๋ฒ์งธ ํ, ์ฒซ ๋ฒ์งธ ์ด์ ํธ์ ๋๋๋ค.
๋ค์ ํ์์ ๊ฐ๋ฅํ ๊ฐ์ฅ ์ผ์ชฝ ์ด์ ํธ์ ๋๋๋ค.
n๋ฒ์งธ ์ด์ ๋ ์ด์ ํธ์ ๋์ ์ ์๋ค๋ฉด ๋ฐฑํธ๋ํ๋ค.
๋ง์ง๋ง ํ์ ํธ์ ๋์ผ๋ฉด ํ๋์ ํด๋ฅผ ๊ตฌํ ๊ฒ์ด๋ค.
๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ์กฐ์ฌํ ๋๊น์ง ๋ฐฑํธ๋ํนํด๊ฐ๋ฉฐ ํด๋ค์ ๊ตฌํ๋ค.
๊น์ด์ฐ์ ํ์์ ํ๋ฉฐ ํด๋ฅผ ๊ตฌํ ๋๋ง๋ค ์นด์ดํธํด ์ํ๋ ํด๋ฅผ ๊ตฌํ ์ ์๋ค. ์ด๊ณผ ๋๊ฐ์ ๋ง ๊ฒ์ฌํ๋ฉด ๋๋ค. ๋๊ฐ์ ์ ํ+์ด ์์น์ ์ฒดํฌํด ๊ธฐ์ธ๊ธฐ๊ฐ ์ฆ๊ฐํ๋ ๋๊ฐ์ ์์ ํธ์ ๋์ ์ ์๋์ง ์๋์ง ํ์ธํ๋ค. ๊ธฐ์ธ๊ธฐ๊ฐ ๊ฐ์ํ๋ ๋๊ฐ์ ์ ํ๊ณผ ์ด์ ์ฐจ๊ฐ ์ผ์ ํ๋ค. n+(ํ-์ด)
์ ์์น์ ์ฒดํฌ. ๋ฐฑํธ๋ ์์ ๊ฐ์ฅ ์ค์ํ ์ ์ ์ฒดํฌ๋ฐฐ์ด์ ๊ธฐ๋กํด ๋์๋ ์ฒดํฌ๋ฅผ ๋ชจ๋ ํด์ ํด์ผํ๋ค.
Last updated
Was this helpful?