SMALL

https://www.acmicpc.net/problem/24444

 

24444번: 알고리즘 수업 - 너비 우선 탐색 1

첫째 줄에 정점의 수 N (5 ≤ N ≤ 100,000), 간선의 수 M (1 ≤ M ≤ 200,000), 시작 정점 R (1 ≤ R ≤ N)이 주어진다. 다음 M개 줄에 간선 정보 u v가 주어지며 정점 u와 정점 v의 가중치 1인 양방

www.acmicpc.net


  • 문제


  • 문제풀이

먼저, 입력 값을 받아와서 그래프를 초기화한다. 각 정점마다 인접한 정점을 리스트에 추가한다.

그리고, 방문 여부 배열과 정점 방문 순서 배열을 초기화한다. 방문 여부 배열은 모두 false로, 정점 방문 순서 배열은 모두 0자동 설정된다.

다만 내림차순으로 정렬하기 때문에 그래프를 내림차순으로 정렬해준다.

BFS 함수를 호출합니다. BFS 함수는 Queue를 사용하며, 현재 정점을 방문하고 방문 순서를 기록한 뒤 인접한 정점들에 대해서 BFS를 순차적으로 사용한다.

마지막으로, 정점 방문 순서 배열을 출력한다. 만약 해당 정점이 시작 정점에서 방문할 수 없는 경우 0을 출력한다.

 


  • 코드 1
namespace YONGYONG2
{
    using System;
    using System.Collections.Generic;
    using System.Text;

    public class Program
    {
        static bool[] BFSbool;
        static int[] BFSlist;
        static int count = 1;
        static List<int>[] graph;
        
        public static void BFS(int V)
        {
            Queue<int> queue = new Queue<int>();
            queue.Enqueue(V);
            BFSbool[V] = true;
            BFSlist[V] = count;
            count++;
            while (queue.Count != 0)
            {
                int temp = queue.Dequeue();
                foreach(int next in graph[temp])
                {
                    if (!BFSbool[next])
                    {
                        BFSbool[next] = true;
                        queue.Enqueue(next);
                        BFSlist[next] = count;
                        count++;
                    }
                   
                }
                
            }
        }
        public static void Main(string[] args)
        {
            using StreamReader sr = new StreamReader(new BufferedStream(Console.OpenStandardInput()));
            using StreamWriter sw = new StreamWriter(new BufferedStream(Console.OpenStandardOutput()));
            string[] input = sr.ReadLine().Split(' ');
            int N = int.Parse(input[0]);
            int M = int.Parse(input[1]);
            int V = int.Parse(input[2]);
            graph = new List<int>[N + 1];
            for (int i = 1; i <= N; i++)
            {
                graph[i] = new List<int>();
            }


            BFSbool = new bool[N + 1];
            for (int i = 0; i < M; i++)
            {
                string[] line = sr.ReadLine().Split();
                int a = int.Parse(line[0]);
                int b = int.Parse(line[1]);
                graph[b].Add(a);
                graph[a].Add(b);
            }
            for (int i = 1; i <= N; i++)
            {
                graph[i].Sort();
                graph[i].Reverse();
            }



            BFSlist=new int[N+1];
            BFS(V);
            for (int i = 1; i <= N; i++)
            {
               sw.WriteLine(BFSlist[i]);
            }

        }
    }

}

 


  • 후기

한문제에서 조금만 고치니간 금방 풀린다.

LIST
SMALL

https://www.acmicpc.net/problem/24480

 

24480번: 알고리즘 수업 - 깊이 우선 탐색 2

첫째 줄에 정점의 수 N (5 ≤ N ≤ 100,000), 간선의 수 M (1 ≤ M ≤ 200,000), 시작 정점 R (1 ≤ R ≤ N)이 주어진다. 다음 M개 줄에 간선 정보 u v가 주어지며 정점 u와 정점 v의 가중치 1인 양

www.acmicpc.net


  • 문제


  • 문제풀이

먼저, 입력 값을 받아와서 그래프를 초기화한다. 각 정점마다 인접한 정점을 리스트에 추가한다.

그리고, 방문 여부 배열과 정점 방문 순서 배열을 초기화한다. 방문 여부 배열은 모두 false로, 정점 방문 순서 배열은 모두 0자동 설정된다.

다만 여기서는 내림차순으로 방문하기 때문에 배열의 순서를 뒤집어준다.

DFS 함수를 호출합니다. DFS 함수는 재귀적으로 호출되며, 현재 정점을 방문하고 방문 순서를 기록한 뒤 인접한 정점들에 대해서 DFS를 재귀적으로 호출한다.

마지막으로, 정점 방문 순서 배열을 출력한다. 만약 해당 정점이 시작 정점에서 방문할 수 없는 경우 0을 출력한다.

 


  • 코드 1
namespace YONGYONG2
{
    using System;
    using System.Collections.Generic;
    using System.Text;

    public class Program
    {
        static int N;
        static bool[] DFSbool;
        static bool[] BFSbool;
        static int[] DFSlist;
        static int count = 1;
        static List<int>[] graph;
        public static void DFS(int V)
        {
            if (DFSbool[V])
            {
                return;
            }
            DFSbool[V] = true;
            DFSlist[V] = count;
            count++;
            foreach (int next in graph[V])
            {
                if (!DFSbool[next])
                {
                    DFS(next);
                }
            }
        }
      
        public static void Main(string[] args)
        {
          
            using StreamWriter sw = new StreamWriter(new BufferedStream(Console.OpenStandardOutput()));
            string[] input = Console.ReadLine().Split(' ');
            N = int.Parse(input[0]);
            int M = int.Parse(input[1]);
            int V = int.Parse(input[2]);
            graph = new List<int>[N + 1];
            for (int i = 1; i <= N; i++)
            {
                graph[i] = new List<int>();
            }

            DFSbool = new bool[N + 1];

            for (int i = 0; i < M; i++)
            {
                string[] line = Console.ReadLine().Split(' ');
                int a = int.Parse(line[0]);
                int b = int.Parse(line[1]);
                graph[b].Add(a);
                graph[a].Add(b);
            }
            for (int i = 1; i <= N; i++)
            {
                graph[i].Sort();
                graph[i].Reverse();
            }


            DFSlist = new int[N + 1];
            
            DFS(V);
            for (int i = 1; i <= N; i++)
            {
               sw.WriteLine(DFSlist[i]);
            }

        }
    }

}

 


  • 후기

비슷비슷한 문제가 많아서 조금만 고치면 된다.

LIST
SMALL

넓우선탐색(Breadth-First Search, BFS)란?

  • 넓이 우선 탐색(Breadth-First Search, BFS)은 그래프 탐색 알고리즘 중 하나로, 루트 노드에서 시작해서 인접한 노드를 먼저 모두 탐색한 후에, 그 인접한 노드들을 시작점으로 다시 인접한 노드를 모두 방문하는 방법이다.

 

BFS의 원리

BFS는 큐(Queue) 자료구조를 이용하여 구현할 수 있다. 큐에 먼저 시작 노드를 넣고, 해당 노드와 인접한 모든 노드들을 큐에 추가한다. 그리고 큐에서 하나씩 노드를 빼서 그 노드와 인접한 노드들을 다시 큐에 추가한다. 이 과정을 큐가 빌 때까지 반복하면 된다. 큐를 이용하기 때문에 먼저 들어온 것이 먼저 처리되기 때문에 넓이 우선 탐색이라고 부른다.

 

BFS는 최단 경로 탐색 등에 자주 사용됩니다. 또한, 미로 찾기와 같은 문제에서도 사용할 수 있습니다. 단점으로는 BFS는 깊이 우선 탐색(DFS)에 비해 탐색하는 노드의 수가 많아지기 때문에, 탐색 속도가 느리다는 점이 있습니다.

 

넓이 우선 탐색(BFS)

  • C언어
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
typedef int ElementType;

typedef struct tagNode
{
    ElementType Data;
} Node;

typedef struct tagCircularQueue
{
    int   Capacity;
    int   Front;
    int   Rear;

    Node* Nodes;
} CircularQueue;

void        CQ_CreateQueue(CircularQueue** Queue, int Capacity);
void        CQ_DestroyQueue(CircularQueue* Queue);
void        CQ_Enqueue(CircularQueue* Queue, ElementType Data);
ElementType CQ_Dequeue(CircularQueue* Queue);
int         CQ_GetSize(CircularQueue* Queue);
int         CQ_IsEmpty(CircularQueue* Queue);
int         CQ_IsFull(CircularQueue* Queue);
int         CQ_Front(CircularQueue* Queue);
int         CQ_Back(CircularQueue* Queue);


void  CQ_CreateQueue(CircularQueue** Queue, int Capacity)
{
    //  큐를 자유 저장소에 생성 
    (*Queue) = (CircularQueue*)malloc(sizeof(CircularQueue));

    //  입력된 Capacity+1 만큼의 노드를 자유 저장소에 생성 
    (*Queue)->Nodes = (Node*)malloc(sizeof(Node) * (Capacity + 1));

    (*Queue)->Capacity = Capacity;
    (*Queue)->Front = 0;
    (*Queue)->Rear = 0;
}

void CQ_DestroyQueue(CircularQueue* Queue)
{
    free(Queue->Nodes);
    free(Queue);
}

void CQ_Enqueue(CircularQueue* Queue, ElementType Data)
{
    int Position = 0;

    if (Queue->Rear == Queue->Capacity)
    {
        Position = Queue->Rear;
        Queue->Rear = 0;
    }
    else
        Position = Queue->Rear++;

    Queue->Nodes[Position].Data = Data;
}

ElementType CQ_Dequeue(CircularQueue* Queue)
{
    int Position = Queue->Front;

    if (Queue->Front == Queue->Capacity)
        Queue->Front = 0;
    else
        Queue->Front++;

    return Queue->Nodes[Position].Data;
}

int CQ_GetSize(CircularQueue* Queue)
{
    if (Queue->Front <= Queue->Rear)
        return Queue->Rear - Queue->Front;
    else
        return Queue->Rear + (Queue->Capacity - Queue->Front) + 1;
}

int CQ_IsEmpty(CircularQueue* Queue)
{
    return (Queue->Front == Queue->Rear);
}
int CQ_IsFull(CircularQueue* Queue)
{
    if (Queue->Front < Queue->Rear)
        return (Queue->Rear - Queue->Front) == Queue->Capacity;
    else
        return (Queue->Rear + 1) == Queue->Front;
}
int CQ_Front(CircularQueue* Queue)
{
    return Queue->Nodes[Queue->Front].Data;
}
int CQ_Back(CircularQueue* Queue)
{
    return Queue->Nodes[Queue->Rear - 1].Data;
}
int n = 5;
int visited[100];
int list[100][100];

void bfs(int v) {
    CircularQueue* queue = NULL;
    CQ_CreateQueue(&queue, 5);
    CQ_Enqueue(queue,v);
    visited[v] = true;
    printf("%d\n", v);
    while (CQ_IsEmpty(queue)) {
        int temp = CQ_Dequeue(queue);
        for (int i = n-1; i >= 0; i--) {
            if (list[temp][i] && !visited[i]) {
                CQ_Enqueue(queue, i);
                printf("%d\n", i);
            }
        }
    }
}
int main(void) {
    n = 5;
    list[0][1] = 1;
    list[0][2] = 1;
    list[1][0] = 1;
    list[1][2] = 1;
    list[1][3] = 1;
    list[1][4] = 1;
    list[2][0] = 1;
    list[2][1] = 1;
    list[3][1] = 1;
    list[4][1] = 1;

    //노드 방문
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            bfs(i);
        }
    }
}
  • C#
using System;
using System.Collections.Generic;

namespace yongyong2
{
    internal class Program
    {
        static int N;
        static int[,] Map;
        static bool[] dfsbool;
        static bool[] bfsbool;

        static void Main(string[] args)
        {
            string[] input1 = Console.ReadLine().Split();
            N = int.Parse(input1[0]);
            int M = int.Parse(input1[1]);
            int V = int.Parse(input1[2]);

            Map = new int[N + 1, N + 1];
            bfsbool = new bool[N + 1];

            for (int i = 0; i < M; i++)
            {
                string[] input2 = Console.ReadLine().Split();
                int temps = int.Parse(input2[0]);
                int tempe = int.Parse(input2[1]);
                Map[temps, tempe] = 1;
                Map[tempe, temps] = 1;
            }


            BFS(N, V);
        }

        public static void BFS(int N, int V)
        {
            Queue<int> queue = new Queue<int>();
            queue.Enqueue(V);
            bfsbool[V] = true;
            Console.Write(V + " ");

            while (queue.Count > 0)
            {
                int temp = queue.Dequeue();

                for (int i = 1; i < N + 1; i++)
                {
                    if (Map[temp, i] == 1 && bfsbool[i] == false)
                    {
                        queue.Enqueue(i);
                        Console.Write(i + " ");
                        bfsbool[i] = true;
                    }
                }
            }
        }
    }
}

예제 문제

 

[C#]백준 1260번: DFS와 BFS

https://www.acmicpc.net/problem/1260 1260번: DFS와 BFS 첫째 줄에 정점의 개수 N(1 ≤ N ≤ 1,000), 간선의 개수 M(1 ≤ M ≤ 10,000), 탐색을 시작할 정점의 번호 V가 주어진다. 다음 M개의 줄에는 간선이 연결하는

yongyongyee.tistory.com

 

 

 

[C#]백준 24444번: 알고리즘 수업 - 넓이 우선 탐색 1

https://www.acmicpc.net/problem/24444 24444번: 알고리즘 수업 - 너비 우선 탐색 1 첫째 줄에 정점의 수 N (5 ≤ N ≤ 100,000), 간선의 수 M (1 ≤ M ≤ 200,000), 시작 정점 R (1 ≤ R ≤ N)이 주어진다. 다음 M개 줄에 간

yongyongyee.tistory.com

 

LIST

'공부 > 알고리즘' 카테고리의 다른 글

[알고리즘]KMP 알고리즘  (0) 2023.03.11
[알고리즘] 깊이 우선 탐색(DFS)  (0) 2023.03.05
[알고리즘] 에라토스테네스의 체  (0) 2023.02.02
SMALL

https://www.acmicpc.net/problem/24444

 

24444번: 알고리즘 수업 - 너비 우선 탐색 1

첫째 줄에 정점의 수 N (5 ≤ N ≤ 100,000), 간선의 수 M (1 ≤ M ≤ 200,000), 시작 정점 R (1 ≤ R ≤ N)이 주어진다. 다음 M개 줄에 간선 정보 u v가 주어지며 정점 u와 정점 v의 가중치 1인 양방

www.acmicpc.net


  • 문제


  • 문제풀이

먼저, 입력 값을 받아와서 그래프를 초기화한다. 각 정점마다 인접한 정점을 리스트에 추가한다.

그리고, 방문 여부 배열과 정점 방문 순서 배열을 초기화한다. 방문 여부 배열은 모두 false로, 정점 방문 순서 배열은 모두 0자동 설정된다.

BFS 함수를 호출합니다. BFS 함수는 Queue를 사용하며, 현재 정점을 방문하고 방문 순서를 기록한 뒤 인접한 정점들에 대해서 BFS를 순차적으로 사용한다.

마지막으로, 정점 방문 순서 배열을 출력한다. 만약 해당 정점이 시작 정점에서 방문할 수 없는 경우 0을 출력한다.

 


  • 코드 1
namespace YONGYONG2
{
    using System;
    using System.Collections.Generic;
    using System.Text;

    public class Program
    {
        static int N;
        static bool[] BFSbool;
        static int[] BFSlist;
        static int count = 1;
        static List<int>[] graph;
        
        public static void BFS(int V)
        {
            Queue<int> queue = new Queue<int>();
            queue.Enqueue(V);
            BFSbool[V] = true;
            BFSlist[V] = count;
            count++;
            while (queue.Count != 0)
            {
                int temp = queue.Dequeue();
                foreach(int next in graph[temp])
                {
                    if (!BFSbool[next])
                    {
                        BFSbool[next] = true;
                        queue.Enqueue(next);
                        BFSlist[next] = count;
                        count++;
                    }
                   
                }
                
            }
        }
        public static void Main(string[] args)
        {
            using StreamReader sr = new StreamReader(new BufferedStream(Console.OpenStandardInput()));
            using StreamWriter sw = new StreamWriter(new BufferedStream(Console.OpenStandardOutput()));
            string[] input = sr.ReadLine().Split(' ');
            N = int.Parse(input[0]);
            int M = int.Parse(input[1]);
            int V = int.Parse(input[2]);
            graph = new List<int>[N + 1];
            for (int i = 1; i <= N; i++)
            {
                graph[i] = new List<int>();
            }

            BFSbool = new bool[N + 1];
            for (int i = 0; i < M; i++)
            {
                string[] line = sr.ReadLine().Split();
                int a = int.Parse(line[0]);
                int b = int.Parse(line[1]);
                graph[b].Add(a);
                graph[a].Add(b);
            }
            for (int i = 1; i <= N; i++)
            {
                graph[i].Sort();
            }
            BFSlist=new int[N+1];
            BFS(V);
            for (int i = 1; i <= N; i++)
            {
               sw.WriteLine(BFSlist[i]);
            }

        }
    }

}

 


  • 후기

처음에 방문하지 못하는곳을 0으로 만드는것이 너무 어려웠다.

LIST
SMALL

https://www.acmicpc.net/problem/24479

 

24479번: 알고리즘 수업 - 깊이 우선 탐색 1

첫째 줄에 정점의 수 N (5 ≤ N ≤ 100,000), 간선의 수 M (1 ≤ M ≤ 200,000), 시작 정점 R (1 ≤ R ≤ N)이 주어진다. 다음 M개 줄에 간선 정보 u v가 주어지며 정점 u와 정점 v의 가중치 1인 양

www.acmicpc.net


  • 문제


  • 문제풀이

먼저, 입력 값을 받아와서 그래프를 초기화한다. 각 정점마다 인접한 정점을 리스트에 추가한다.

그리고, 방문 여부 배열과 정점 방문 순서 배열을 초기화한다. 방문 여부 배열은 모두 false로, 정점 방문 순서 배열은 모두 0자동 설정된다.

DFS 함수를 호출합니다. DFS 함수는 재귀적으로 호출되며, 현재 정점을 방문하고 방문 순서를 기록한 뒤 인접한 정점들에 대해서 DFS를 재귀적으로 호출한다.

마지막으로, 정점 방문 순서 배열을 출력한다. 만약 해당 정점이 시작 정점에서 방문할 수 없는 경우 0을 출력한다.

 


  • 코드 1
namespace YONGYONG2
{
    using System;
    using System.Collections.Generic;
    using System.Text;

    public class Program
    {
        static int N;
        static bool[] DFSbool;
        static int[] DFSlist;
        static int count = 1;
        static List<int>[] graph;
        public static void DFS(int V)
        {
            if (DFSbool[V])
            {
                return;
            }
            DFSbool[V] = true;
            DFSlist[V] = count;
            count++;
            foreach(int next in graph[V])
            {
                if (!DFSbool[next])
                {
                    DFS(next);
                }
            }
        }
       
        public static void Main(string[] args)
        {
       
            using StreamWriter sw = new StreamWriter(new BufferedStream(Console.OpenStandardOutput()));
            string[] input = Console.ReadLine().Split(' ');
            N = int.Parse(input[0]);
            int M = int.Parse(input[1]);
            int V = int.Parse(input[2]);
            graph = new List<int>[N+1];
            for(int i = 1; i <= N; i++)
            {
                graph[i] = new List<int>();
            }
            
            DFSbool = new bool[N + 1];
           
            for (int i = 0; i < M; i++)
            {
                string[] line = Console.ReadLine().Split();
                int a = int.Parse(line[0]);
                int b = int.Parse(line[1]);
                graph[b].Add(a);
                graph[a].Add(b);
            }
            for (int i = 1; i <= N; i++)
            {
                graph[i].Sort();
            }
            DFSlist = new int[N + 1];
            DFS(V);
            for(int i=1;i<=N;i++)
            {
                sw.WriteLine(DFSlist[i]);
            }

        }
    }

}

 


  • 후기

처음에 방문하지 못하는곳을 0으로 만드는것이 너무 어려웠다.

LIST
SMALL

깊이우선탐색(Depth-First Search, DFS)란?

  • 깊이 우선 탐색(Depth-First Search, DFS)은 그래프를 탐색하는 알고리즘 중 하나이다. 이 알고리즘은 한 경로를 따라 최대한 깊이 내려가면서 그래프를 탐색하는 방식이다.

 

DFS의 원리

이 알고리즘은 스택(Stack) 자료구조를 사용하여 구현할 수 있습니다. 구체적으로는, 시작 노드를 스택에 넣고, 스택이 비어있지 않은 동안 아래의 과정을 반복합니다.

  1. 스택에서 노드를 꺼냅니다.
  2. 해당 노드가 방문한 적이 없다면, 방문 처리를 합니다.
  3. 해당 노드에서 인접한 노드들 중에서 방문하지 않은 노드가 있다면, 스택에 넣습니다.

위 과정을 반복하면서 모든 노드를 방문할 수 있다. 만약, 탐색 도중 목표 노드를 찾으면 탐색을 종료하거나, 모든 노드를 방문해도 목표 노드를 찾지 못하면 탐색을 종료한다.

 

 

DFS는 모든 경로를 탐색하기 때문에 최적의 해를 보장하지 않는다. 하지만, 그래프가 깊은 경우 BFS에 비해 적은 메모리를 사용하여 구현할 수 있기 때문에 유용하게 사용된다. 또한, DFS는 백트래킹(Backtracking)과 같은 알고리즘에서 사용되기도 한다.

 

깊이 우선 탐색(DFS)

  • C언어
#ifndef ARRAYSTACK_H
#define ARRAYSTACK_H
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h> 
typedef int ElementType;

typedef struct tagNode
{
    ElementType Data;
} Node;

typedef struct tagArrayStack
{
    int   Capacity;
    int   Top;
    Node* Nodes;
} ArrayStack;

void        AS_CreateStack(ArrayStack** Stack, int Capacity);
void        AS_DestroyStack(ArrayStack* Stack);
void        AS_Push(ArrayStack* Stack, ElementType Data);
ElementType AS_Pop(ArrayStack* Stack);
ElementType AS_Top(ArrayStack* Stack);
int         AS_GetSize(ArrayStack* Stack);
int         AS_IsEmpty(ArrayStack* Stack);
int         AS_IsFull(ArrayStack* Stack);

#endif


void  AS_CreateStack(ArrayStack** Stack, int Capacity)
{
    //  스택을 자유 저장소에 생성 
    (*Stack) = (ArrayStack*)malloc(sizeof(ArrayStack));

    //  입력된 Capacity만큼의 노드를 자유 저장소에 생성 
    (*Stack)->Nodes = (Node*)malloc(sizeof(Node) * Capacity);

    //  Capacity 및 Top 초기화 
    (*Stack)->Capacity = Capacity;
    (*Stack)->Top = -1;
}

void AS_DestroyStack(ArrayStack* Stack)
{
    //  노드를 자유 저장소에서 해제 
    free(Stack->Nodes);

    //  스택을 자유 저장소에서 해제 
    free(Stack);
}

void AS_Push(ArrayStack* Stack, ElementType Data)
{
    Stack->Top++;
    Stack->Nodes[Stack->Top].Data = Data;
}

ElementType AS_Pop(ArrayStack* Stack)
{
    int Position = Stack->Top--;
    return Stack->Nodes[Position].Data;
}

ElementType AS_Top(ArrayStack* Stack)
{
    return Stack->Nodes[Stack->Top].Data;
}

int AS_GetSize(ArrayStack* Stack)
{
    return Stack->Top + 1;
}

int AS_IsEmpty(ArrayStack* Stack)
{
    return (Stack->Top == -1);
}
int AS_IsFull(ArrayStack* Stack)
{
    return (Stack->Top + 1 == Stack->Capacity);

}

int visited[100];
int list[100][100];
int n;

void dfs(int v) {
    ArrayStack* stack = NULL;
    AS_CreateStack(&stack, 5);
    AS_Push(stack, v);
    while (!AS_IsEmpty(stack)) {
        int temp = AS_Pop(stack);
        if (!visited[temp]) {
            visited[temp] = 1;
            printf("%d\n", temp);
            for (int i = n - 1; i >= 0; i--) {
                if (list[temp][i] && !visited[i]) {
                    AS_Push(stack, i);
                }
            }
        }
    }
}

int main(void)
{
    //그래프 입력
    n = 5;
    list[0][1] = 1;
    list[0][2] = 1;
    list[1][0] = 1;
    list[1][2] = 1;
    list[1][3] = 1;
    list[1][4] = 1;
    list[2][0] = 1;
    list[2][1] = 1;
    list[3][1] = 1;
    list[4][1] = 1;

    //노드 방문
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            dfs(i);
        }
    }
}
  • C#
using System;
using System.Collections.Generic;

using System;
using System.Collections.Generic;

class DFS
{

    static int[,] list = new int[100, 100];
    static bool[] visited = new bool[100];
    static int n;

    static void dfs(int v)
    {
        Stack<int> stack = new Stack<int>();
        stack.Push(v); // 시작 노드 스택에 삽입

        while (stack.Count > 0)
        {
            int temp = stack.Pop(); // 스택에서 노드 꺼내기
            if (!visited[temp]) // 해당 노드를 방문하지 않았다면
            {
                visited[temp] = true; // 방문 처리
                Console.Write(temp + "\n");

                for (int i = n - 1; i >= 0; i--) // 해당 노드의 인접 노드들을 역순으로 스택에 삽입
                {
                    if (list[temp, i] == 1 && !visited[i]) // 인접 노드 중 방문하지 않은 노드가 있다면
                    {
                        stack.Push(i);
                    }
                }
            }
        }
    }

    static void Main()
    {
        n = 5;
        list[0, 1] = 1;
        list[0, 2] = 1;
        list[1, 0] = 1;
        list[1, 2] = 1;
        list[1, 3] = 1;
        list[1, 4] = 1;
        list[2, 0] = 1;
        list[2, 1] = 1;
        list[3, 1] = 1;
        list[4, 1] = 1;


        for (int i = 0; i < n; i++)
        {
            if (!visited[i])
            {
                dfs(i);
            }
        }
    }
}

예제 문제

 

[C#]백준 1260번: DFS와 BFS

https://www.acmicpc.net/problem/1260 1260번: DFS와 BFS 첫째 줄에 정점의 개수 N(1 ≤ N ≤ 1,000), 간선의 개수 M(1 ≤ M ≤ 10,000), 탐색을 시작할 정점의 번호 V가 주어진다. 다음 M개의 줄에는 간선이 연결하는

yongyongyee.tistory.com

 

 

[C#]백준 24479번: 알고리즘 수업-깊이 우선 탐색 1

https://www.acmicpc.net/problem/24479 24479번: 알고리즘 수업 - 깊이 우선 탐색 1 첫째 줄에 정점의 수 N (5 ≤ N ≤ 100,000), 간선의 수 M (1 ≤ M ≤ 200,000), 시작 정점 R (1 ≤ R ≤ N)이 주어진다. 다음 M개 줄에 간

yongyongyee.tistory.com

 

LIST

'공부 > 알고리즘' 카테고리의 다른 글

[알고리즘]KMP 알고리즘  (0) 2023.03.11
[알고리즘] 넓이 우선 탐색(BFS)  (0) 2023.03.05
[알고리즘] 에라토스테네스의 체  (0) 2023.02.02
SMALL

https://www.acmicpc.net/problem/1260

 

1260번: DFS와 BFS

첫째 줄에 정점의 개수 N(1 ≤ N ≤ 1,000), 간선의 개수 M(1 ≤ M ≤ 10,000), 탐색을 시작할 정점의 번호 V가 주어진다. 다음 M개의 줄에는 간선이 연결하는 두 정점의 번호가 주어진다. 어떤 두 정점 사

www.acmicpc.net


  • 문제


  • 문제풀이

정점의 수, 간선의 수, 시작 정점을 받아준 후 간선정보를 입력한 뒤 각각 BFS와 DFS를 시행해준다.

 


  • 코드 1
namespace YONGYONG2
{
    using System;
    using System.Collections.Generic;

    
    public class Program
    {
        static int N;
        static int[,] Graph;
        static bool[] DFSbool;
        static bool[] BFSbool;
        public static void DFS(int N,int V)
        {
            DFSbool[V] = true;
            Console.Write(V + " ");
            for(int i=1;i<=N;i++)
            {
                if (Graph[V, i] == 1 && !DFSbool[i])
                {
                    DFS(N,i);
                }
            }
        }
        public static void BFS(int N,int V)
        {
            Queue<int> queue = new Queue<int>();
            queue.Enqueue(V);
            BFSbool[V] = true;
            Console.Write(V + " ");
            while (queue.Count != 0)
            {
                int temp= queue.Dequeue();
                for(int i = 1; i <= N; i++)
                {
                    if (Graph[temp, i] == 1 && !BFSbool[i])
                    {
                        queue.Enqueue(i);
                        Console.Write(i+" ");
                        BFSbool[i] = true;
                    }
                }
            }
        }
        public static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(' ');
            N = int.Parse(input[0]);
            int M = int.Parse(input[1]);
            int V = int.Parse(input[2]);
            Graph= new int[N+1, N+1];
            DFSbool=new bool[N+1];
            BFSbool = new bool[N + 1];
            for(int i = 0; i < M; i++)
            {
                string[] line = Console.ReadLine().Split();
                int a = int.Parse(line[0]);
                int b = int.Parse(line[1]);
                Graph[a, b] = 1;
                Graph[b, a] = 1;
            }

            DFS(N, V);
            Console.WriteLine();
            BFS(N, V);

        }
    }

}

 


  • 후기

DFS와 BFS는 잊으면 안되겠다.

LIST
SMALL

https://www.acmicpc.net/problem/1920

 

1920번: 수 찾기

첫째 줄에 자연수 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 줄에는 N개의 정수 A[1], A[2], …, A[N]이 주어진다. 다음 줄에는 M(1 ≤ M ≤ 100,000)이 주어진다. 다음 줄에는 M개의 수들이 주어지는데, 이 수들

www.acmicpc.net


  • 문제


  • 문제풀이

리스트를 활용하지 않고 이분탐색을 이용해야 시간초과가 되지 않는다.

 


  • 코드 1
using System;
using System.Text;
class Program
    {

		private static char Compare(int x, int y)
		{
			if (x > y)
				return '>';
			else if (x < y)
				return '<';
			else
				return '=';
		}
		private static int BinarySearch(int[] datas,int iPoint)
        {
			int right = datas.Length - 1;
			for (int left = 0; left <= right;)
			{
				int middle = (left + right) / 2;

				switch (Compare(iPoint, datas[middle]))
				{
					case '>': left = middle + 1; break;//x>datas[middle] 
					case '<': right = middle - 1; break;//x<datas[middle]
					case '=': return 1;
				}
			}
			return 0;
        }
		static void Main(string[] args)
		{
			StringBuilder sb = new StringBuilder();
			int N = int.Parse(Console.ReadLine());
			string[] input = Console.ReadLine().Split();
			int[] arr = new int[N];
			for (int i = 0; i < N; i++)
			{
				arr[i] = int.Parse(input[i]);
			}
			Array.Sort(arr);
			int M = int.Parse(Console.ReadLine());
			string[] arr2 = Console.ReadLine().Split();
			for (int i = 0; i < M; i++)
			{
				int check = int.Parse(arr2[i]);
				sb.Append(BinarySearch(arr, check) + "\n");
				
			}
			Console.WriteLine(sb);
		}
	}

 


  • 후기

점점 포인터가 많아진다 어렵다

LIST

+ Recent posts