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๋ฐฉํ–ฅ์œผ๋กœ ๋ชจ๋‘ ๊ณต๊ฒฉํ•  ์ˆ˜ ์žˆ๋‹ค.

    1. ์ฒซ ๋ฒˆ์งธ ํ–‰, ์ฒซ ๋ฒˆ์งธ ์—ด์— ํ€ธ์„ ๋†“๋Š”๋‹ค.

    2. ๋‹ค์Œ ํ–‰์—์„œ ๊ฐ€๋Šฅํ•œ ๊ฐ€์žฅ ์™ผ์ชฝ ์—ด์— ํ€ธ์„ ๋†“๋Š”๋‹ค.

    3. n๋ฒˆ์งธ ์—ด์— ๋” ์ด์ƒ ํ€ธ์„ ๋†“์„ ์ˆ˜ ์—†๋‹ค๋ฉด ๋ฐฑํŠธ๋ž™ํ•œ๋‹ค.

    4. ๋งˆ์ง€๋ง‰ ํ–‰์— ํ€ธ์„ ๋†“์œผ๋ฉด ํ•˜๋‚˜์˜ ํ•ด๋ฅผ ๊ตฌํ•œ ๊ฒƒ์ด๋‹ค.

    5. ๋ชจ๋“  ๊ฒฝ์šฐ๋ฅผ ์กฐ์‚ฌํ•  ๋•Œ๊นŒ์ง€ ๋ฐฑํŠธ๋ž˜ํ‚นํ•ด๊ฐ€๋ฉฐ ํ•ด๋“ค์„ ๊ตฌํ•œ๋‹ค.

๊นŠ์ด์šฐ์„ ํƒ์ƒ‰์„ ํ•˜๋ฉฐ ํ•ด๋ฅผ ๊ตฌํ•  ๋•Œ๋งˆ๋‹ค ์นด์šดํŠธํ•ด ์›ํ•˜๋Š” ํ•ด๋ฅผ ๊ตฌํ•  ์ˆ˜ ์žˆ๋‹ค. ์—ด๊ณผ ๋Œ€๊ฐ์„ ๋งŒ ๊ฒ€์‚ฌํ•˜๋ฉด ๋œ๋‹ค. ๋Œ€๊ฐ์„ ์€ ํ–‰+์—ด ์œ„์น˜์— ์ฒดํฌํ•ด ๊ธฐ์šธ๊ธฐ๊ฐ€ ์ฆ๊ฐ€ํ•˜๋Š” ๋Œ€๊ฐ์„  ์ƒ์— ํ€ธ์„ ๋†“์„ ์ˆ˜ ์žˆ๋Š”์ง€ ์—†๋Š”์ง€ ํ™•์ธํ•œ๋‹ค. ๊ธฐ์šธ๊ธฐ๊ฐ€ ๊ฐ์†Œํ•˜๋Š” ๋Œ€๊ฐ์„ ์€ ํ–‰๊ณผ ์—ด์˜ ์ฐจ๊ฐ€ ์ผ์ •ํ•˜๋‹ค. n+(ํ–‰-์—ด)์˜ ์œ„์น˜์— ์ฒดํฌ. ๋ฐฑํŠธ๋ž™ ์‹œ์— ๊ฐ€์žฅ ์ค‘์š”ํ•œ ์ ์€ ์ฒดํฌ๋ฐฐ์—ด์— ๊ธฐ๋กํ•ด ๋‘์—ˆ๋˜ ์ฒดํฌ๋ฅผ ๋ชจ๋‘ ํ•ด์ œํ•ด์•ผํ•œ๋‹ค.

Last updated

Was this helpful?