C# 코딩테스트 강좌, 선분을 그룹으로 나누기

코딩테스트에서 알고리즘 문제는 점점 더 중요해지고 있으며, 많은 기업들이 알고리즘 문제 해결 능력을 중요하게 평가합니다. 이번 강좌에서는 주어진 선분들을 그룹으로 나누는 문제를 다뤄보겠습니다. 이 문제는 효율적인 분류 및 정렬, 그리고 그루핑 로직을 통해 해결할 수 있습니다.

문제 설명

주어진 선분들이 맵상의 점으로 표현될 때, 이 선분들을 오버랩되는 선분 그룹으로 나누는 프로그램을 작성하세요. 선분은 시작점과 끝점을 가지며, 다음과 같은 입력 형식으로 주어집니다:

입력 예시:
5
1 3
2 5
6 8
7 9
10 12

위의 입력에서 첫 번째 줄은 선분의 개수를 나타내고, 다음 줄들은 각 선분의 시작점과 끝점을 의미합니다. 오버랩하는 선분들은 같은 그룹으로 묶여야 합니다. 예를 들어, 입력된 선분들은 다음과 같이 나뉠 수 있습니다:

출력 예시:
그룹 1: (1, 5)
그룹 2: (6, 9)
그룹 3: (10, 12)

문제 풀이 접근법

이 문제를 해결하기 위해 다음과 같은 접근법을 사용할 수 있습니다:

  1. 입력으로 주어진 선분들을 리스트에 저장합니다.
  2. 리스트를 시작점 기준으로 정렬합니다.
  3. 정렬된 리스트를 순회하며 오버랩하는 선분들을 그룹화합니다.
  4. 최종적으로 그룹별로 연속된 선분의 범위를 출력합니다.

1단계: 입력 처리

먼저 사용자가 입력한 선분을 받을 수 있는 구조체를 정의하고, 입력을 처리하겠습니다. 구조체를 통해 선분의 시작점과 끝점을 저장하고, 리스트 형태로 관리합니다.

using System;
using System.Collections.Generic;

public class Segment{
    public int Start { get; set; }
    public int End { get; set; }
    
    public Segment(int start, int end){
        Start = start;
        End = end;
    }
}

2단계: 정렬

선분 리스트를 시작점 기준으로 정렬하는 코드입니다. 이를 통해 비슷한 선분들이 가까이 위치하게 되어 우리를 그룹 지을 준비를 할 것입니다.

public List<Segment> SortSegments(List<Segment> segments){
    segments.Sort((a, b) => a.Start.CompareTo(b.Start));
    return segments;
}

3단계: 그룹화 로직

그룹화 로직은 각 선분을 순회하면서 현재 그룹에 추가할 수 있는지 여부를 판단합니다. 현재 선분의 시작점이 마지막 선분의 끝점보다 작거나 같으면 같은 그룹에 포함됩니다. 반대로 새로운 그룹을 시작합니다.

public List<List<Segment>> GroupSegments(List<Segment> segments){
    List<List<Segment>> groups = new List<List<Segment>>();
    groups.Add(new List<Segment>());
    
    foreach(var segment in segments){
        var lastSegment = groups[groups.Count - 1];
        if(lastSegment.Count == 0 || segment.Start > lastSegment[lastSegment.Count - 1].End){
            groups.Add(new List<Segment>());
        }
        groups[groups.Count - 1].Add(segment);
    }

    return groups;
}

4단계: 최종 출력

마지막으로 그룹화 된 결과를 출력합니다. 각 그룹의 시작점과 끝점을 기반으로 간단한 텍스트 형식으로 결과를 보여줍니다.

public void PrintGroups(List<List<Segment>> groups){
    for(int i = 0; i < groups.Count; i++){
        var group = groups[i];
        if(group.Count > 0){
            Console.WriteLine($"그룹 {i + 1}: ({group[0].Start}, {group[group.Count - 1].End})");
        }
    }
}

전체 코드

이제 모든 단계를 결합하여 최종 코드를 작성해 보겠습니다:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    public class Segment
    {
        public int Start { get; set; }
        public int End { get; set; }

        public Segment(int start, int end)
        {
            Start = start;
            End = end;
        }
    }

    public static void Main(string[] args)
    {
        int n = int.Parse(Console.ReadLine());
        List<Segment> segments = new List<Segment>();

        for (int i = 0; i < n; i++)
        {
            var input = Console.ReadLine().Split(' ');
            int start = int.Parse(input[0]);
            int end = int.Parse(input[1]);
            segments.Add(new Segment(start, end));
        }

        segments = SortSegments(segments);
        var groups = GroupSegments(segments);
        PrintGroups(groups);
    }

    public static List<Segment> SortSegments(List<Segment> segments)
    {
        segments.Sort((a, b) => a.Start.CompareTo(b.Start));
        return segments;
    }

    public static List<List<Segment>> GroupSegments(List<Segment> segments)
    {
        List<List<Segment>> groups = new List<List<Segment>>();
        groups.Add(new List<Segment>());

        foreach (var segment in segments)
        {
            var lastSegment = groups[groups.Count - 1];
            if (lastSegment.Count == 0 || segment.Start > lastSegment[lastSegment.Count - 1].End)
            {
                groups.Add(new List<Segment>());
            }
            groups[groups.Count - 1].Add(segment);
        }

        return groups;
    }

    public static void PrintGroups(List<List<Segment>> groups)
    {
        for (int i = 0; i < groups.Count; i++)
        {
            var group = groups[i];
            if (group.Count > 0)
            {
                Console.WriteLine($"그룹 {i + 1}: ({group[0].Start}, {group[group.Count - 1].End})");
            }
        }
    }
}

결론

이번 강좌를 통해 선분 그룹화 문제를 해결하는 방법과 함께 C#을 활용하여 코드를 작성하는 방법을 살펴보았습니다. 코딩테스트에서는 다양한 문제를 통해 알고리즘적 사고를 키우는 것이 중요합니다. 반복적인 연습을 통해 다양한 유형의 문제를 풀어보세요!

추가 학습 리소스

이 문제를 해결하는 과정에서 유용한 몇 가지 리소스를 소개합니다:

  • 프로그래머스: 다양한 알고리즘 문제를 제공하는 플랫폼입니다.
  • LeetCode: 알고리즘 연습을 위한 국내외 문제를 제공하는 사이트입니다.
  • 백준 온라인 저지: 다양한 난이도의 알고리즘 문제를 해결할 수 있는 사이트입니다.

이번 글이 코딩테스트 준비에 도움이 되기를 바랍니다. 궁금한 점이나 추가적인 질문이 있으면 댓글로 남겨주세요. 감사합니다!

C# 코딩테스트 강좌, 트리의 부모 찾기

문제 설명

이 문제의 목표는 주어진 이진 트리에서 특정 노드의 부모 노드를 찾는 것입니다.
이진 트리는 각 노드가 최대 두 개의 자식을 가질 수 있는 계층적 데이터 구조입니다.
우리의 목표는 입력된 노드를 기반으로 그 노드의 부모를 올바르게 찾는 프로그램을 작성하는 것입니다.

문제 입력

    트리는 배열로 주어지며, 각 원소는 트리의 노드입니다. 
    배열의 인덱스는 노드의 위치를 나타내며, 인덱스 0은 루트 노드입니다. 
    예를 들어, 배열 [3, 5, 1, 6, 2, 0, 8]일 경우,
    3은 루트 노드,
    5는 노드 3의 왼쪽 자식,
    1은 노드 3의 오른쪽 자식,
    6은 노드 5의 왼쪽 자식, 
    2는 노드 5의 오른쪽 자식,
    0은 노드 1의 왼쪽 자식,
    8은 노드 1의 오른쪽 자식입니다.
    

문제 출력

    특정 노드에 대한 부모 노드의 값을 출력합니다. 
    만약 부모 노드가 없다면(-1) 출력합니다.
    

예시

입력

    트리: [3, 5, 1, 6, 2, 0, 8]
    노드: 6
    

출력

    5
    

입력

    트리: [3, 5, 1, 6, 2, 0, 8]
    노드: 3
    

출력

    -1
    

풀이 접근법

이 문제를 해결하기 위해서는 트리의 구조를 이해하고 각 노드의 부모를 찾는 방법을 알아야 합니다.
이진 트리에서 각 노드의 부모 노드는 자식 노드의 인덱스와 수학적인 연산을 통해 찾을 수 있습니다.

부모 노드 찾기

주어진 인덱스에 대해 그 부모 노드의 인덱스는 다음과 같이 계산할 수 있습니다:

  • 부모 노드의 인덱스: parentIndex = (childIndex - 1) / 2

– 여기서 childIndex는 찾고자 하는 노드의 인덱스입니다.
– 만약 childIndex가 0일 경우, 이는 루트 노드이므로 부모 노드가 존재하지 않습니다.

구현

이제 위의 접근 방식을 바탕으로 C# 코드를 작성해 보겠습니다.


public class TreeNodeSearcher 
{
    public static int FindParent(int[] tree, int childIndex) 
    {
        // 입력된 childIndex가 유효한지 체크
        if (childIndex < 0 || childIndex >= tree.Length) 
        {
            throw new ArgumentOutOfRangeException("Child index is out of the range of the tree array.");
        }
        
        // 루트 노드의 경우 부모가 없음
        if (childIndex == 0) 
        {
            return -1; // 부모가 없음
        }

        // 부모 인덱스 계산
        int parentIndex = (childIndex - 1) / 2;
        return tree[parentIndex];
    }
}
    

테스트

위의 메소드를 유효하게 테스트하기 위해 몇 가지 케이스를 만들어 보겠습니다.


public class Program 
{
    public static void Main() 
    {
        int[] tree = {3, 5, 1, 6, 2, 0, 8};

        Console.WriteLine(TreeNodeSearcher.FindParent(tree, 3)); // 출력: 5
        Console.WriteLine(TreeNodeSearcher.FindParent(tree, 0)); // 출력: -1
        Console.WriteLine(TreeNodeSearcher.FindParent(tree, 5)); // 출력: 1
        Console.WriteLine(TreeNodeSearcher.FindParent(tree, 1)); // 출력: 3
    }
}
    

결론

우리는 주어진 이진 트리에서 특정 노드의 부모 노드를 찾기 위한 알고리즘을 성공적으로 구현했습니다.
이 알고리즘은 시간 복잡도 O(1)로 매우 효율적입니다.
트리의 구조를 이해하고 활용하는 것이 중요하며, 이러한 기초적인 개념은 더 복잡한 데이터 구조를 다룰 때에도 유용하게 적용될 수 있습니다.

추가 학습

트리에 대한 이해를 깊이 하기 위해 이진 검색 트리, AVL 트리, 힙과 같은 고급 주제도 다루어 볼 것을 권장합니다.
이러한 자료구조는 다양한 알고리즘 문제를 해결하는 데 큰 도움이 될 것입니다.

C# 코딩테스트 강좌, 선분 방향 구하기

문제 설명

두 점 A(x1, y1)와 B(x2, y2)로 구성된 선분의 방향을 구하는 문제입니다. 점 A와 B의 좌표가 주어졌을 때, 선분의 방향이 상하, 좌우 또는 대각선으로 향하고 있는지를 판별하는 함수를 작성해야 합니다.

입력 데이터는 A와 B의 좌표로 구성된 정수 쌍이 주어지며, 출력 데이터는 “상”, “하”, “좌”, “우”, “대각선”, “같음” 중 하나로 이루어집니다.

입력 예시

(1, 1), (2, 2)

출력 예시

대각선

문제 분석

문제를 해결하기 위해서는 두 점(A, B)의 좌표 차이를 계산하여 선분의 방향을 판단해야 합니다. 판단 기준은 다음과 같습니다.

  • y2 > y1이면 “상”이다.
  • y2 < y1이면 “하”이다.
  • x2 > x1이면 “우”이다.
  • x2 < x1이면 “좌”이다.
  • x2 == x1 && y2 == y1이면 “같음”이다.
  • 그 외의 경우: “대각선”으로 판단한다.

알고리즘 설계

알고리즘의 흐름은 다음과 같습니다.

  1. 입력으로 A와 B의 좌표를 받아온다.
  2. A와 B의 x, y 좌표 값을 비교한다.
  3. 조건에 맞춰 방향을 결정한다.
  4. 결과를 반환한다.

C# 코드 구현


public class Program
{
    public static void Main(string[] args)
    {
        var result = GetLineDirection(1, 1, 2, 2);
        Console.WriteLine(result); // 대각선
    }

    public static string GetLineDirection(int x1, int y1, int x2, int y2)
    {
        if (x1 == x2 && y1 == y2)
        {
            return "같음";
        }
        else if (y2 > y1 && x2 > x1)
        {
            return "대각선";
        }
        else if (y2 > y1)
        {
            return "상";
        }
        else if (y2 < y1)
        {
            return "하";
        }
        else if (x2 > x1)
        {
            return "우";
        }
        else if (x2 < x1)
        {
            return "좌";
        }
        else
        {
            return "대각선";
        }
    }
}

코드 설명

위의 코드는 두 점 A(x1, y1)와 B(x2, y2)의 좌표를 입력받아 선분의 방향을 결정하는 GetLineDirection 함수를 포함합니다.
Main 메소드에서 샘플 좌표를 바탕으로 함수를 호출하고 결과를 출력합니다. 각 조건문은 선분의 방향을 판단하고 그에 맞는 문자열을 반환합니다.

시간 복잡도 분석

이 알고리즘은 입력된 두 점에 대해 단순 비교 연산만 수행하므로, 시간 복잡도는 O(1)입니다. 즉, 입력 데이터의 크기에 관계없이 일정한 시간이 소요됩니다.

테스트 케이스

다양한 테스트 케이스를 통해 알고리즘의 정확성을 검증합니다.


    // Test cases
    Console.WriteLine(GetLineDirection(1, 1, 1, 1)); // 같음
    Console.WriteLine(GetLineDirection(1, 1, 2, 2)); // 대각선
    Console.WriteLine(GetLineDirection(1, 1, 1, 2)); // 상
    Console.WriteLine(GetLineDirection(1, 2, 1, 1)); // 하
    Console.WriteLine(GetLineDirection(1, 1, 2, 1)); // 우
    Console.WriteLine(GetLineDirection(2, 1, 1, 1)); // 좌

결론

이 문제를 통해 두 점의 좌표를 바탕으로 선분의 방향을 판단하는 간단하지만 유용한 알고리즘을 배웠습니다.
C#의 기능을 활용하여 간단한 수학적 연산을 통해 문제를 해결할 수 있는 방법을 익힐 수 있었습니다.
다양한 각도에서 이 문제를 접근하고 여러 테스트 케이스를 통해 알고리즘의 정확성을 검증하는 것이 중요합니다.

여러분도 이 알고리즘을 바탕으로 자신의 문제를 해결할 수 있는 능력을 키워보세요!

C# 코딩테스트 강좌, 삽입 정렬

서론

안녕하세요. 이번 강좌에서는 코딩테스트 준비에 유용한 정렬 알고리즘 중 하나인 ‘삽입 정렬(Insertion Sort)’에 대해 깊이 있게 다루어 보겠습니다. 정렬 알고리즘은 데이터 구조와 알고리즘 문제해결의 기초가 되는 중요한 주제입니다. 특히, 이론적 배경과 코드 구현, 그리고 문제 풀이의 구체적인 사례를 제시하여 독자 여러분의 이해를 돕고자 합니다.

삽입 정렬이란?

삽입 정렬은 데이터가 정렬된 상태에서 새 데이터를 삽입하는 방식으로 작동하는 정렬 알고리즘입니다. 주어진 데이터에서 하나씩 원소를 선택하여, 이미 정렬된 부분과 비교하면서 적절한 위치에 삽입합니다. 이 알고리즘은 매우 직관적이며, 구현하기도 쉽습니다.

삽입 정렬의 작동 원리

삽입 정렬은 다음과 같은 방식으로 작동합니다:

  1. 정렬되지 않은 리스트에서 첫 번째 원소를 선택합니다. 이 원소는 이미 정렬된 상태로 간주합니다.
  2. 다음 원소를 선택하여 정렬된 원소들과 비교합니다.
  3. 현재 선택한 원소가 정렬된 원소보다 작다면, 정렬된 리스트의 적절한 위치에 삽입합니다.
  4. 이 과정을 리스트의 끝까지 반복합니다.

삽입 정렬의 시간 복잡도

삽입 정렬의 시간 복잡도는 최악의 경우 O(n²)입니다. 그러나 데이터가 거의 정렬된 상태라면 평균적으로 O(n)의 성능을 보여줍니다. 이는 삽입 정렬이 다른 알고리즘들과 비교했을 때 장점이 될 수 있습니다. 특별한 경우에는 O(n)으로 동작하기 때문에 실제 문제에서는 종종 사용됩니다.

삽입 정렬의 C# 구현

이제 실제로 C#을 사용하여 삽입 정렬 알고리즘을 구현해 보겠습니다:


using System;

class Program
{
    static void InsertionSort(int[] arr)
    {
        for (int i = 1; i < arr.Length; i++)
        {
            int key = arr[i];
            int j = i - 1;

            // 현재 key보다 큰 원소를 한 칸씩 뒤로 이동
            while (j >= 0 && arr[j] > key)
            {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key; // key를 적절한 위치에 삽입
        }
    }

    static void Main()
    {
        int[] array = { 12, 11, 13, 5, 6 };
        InsertionSort(array);

        Console.WriteLine("정렬된 배열: ");
        foreach (int num in array)
        {
            Console.Write(num + " ");
        }
    }
}

문제 풀이: 주어진 배열 정렬하기

다음은 실제 코딩테스트에서 주어질 수 있는 문제의 예시입니다:

문제: 정수 배열이 주어졌을 때, 삽입 정렬을 사용하여 배열을 오름차순으로 정렬하시오.

입력 예: [64, 34, 25, 12, 22, 11, 90]

출력 예: [11, 12, 22, 25, 34, 64, 90]

위 문제를 해결하기 위해서는 앞서 설명한 삽입 정렬 알고리즘을 구현하면 됩니다. 주어진 배열을 삽입 정렬로 정렬해보겠습니다.


using System;

class InsertionSortExample
{
    static void InsertSort(int[] array)
    {
        for (int i = 1; i < array.Length; i++)
        {
            int key = array[i];
            int j = i - 1;

            while (j >= 0 && array[j] > key)
            {
                array[j + 1] = array[j];
                j--;
            }
            array[j + 1] = key;
        }
    }

    static void Main()
    {
        int[] nums = { 64, 34, 25, 12, 22, 11, 90 };
        InsertSort(nums);

        Console.WriteLine("정렬된 배열: ");
        foreach (var num in nums)
        {
            Console.Write(num + " ");
        }
    }
}

결론

이번 강좌에서는 삽입 정렬 알고리즘에 대해 깊이 이해하고, C#으로 구현하는 방법과 실제 문제를 해결하는 과정을 살펴보았습니다. 비교적 쉬운 이해와 구현 덕분에 삽입 정렬은 많은 코딩테스트 문제의 출제 원본으로 많이 사용됩니다. 이제 여러분도 삽입 정렬을 마스터했으니, 다양한 문제를 풀어보며 더욱 실력을 쌓아보세요!

C# 코딩테스트 강좌, 너비 우선 탐색

안녕하세요, 여러분! 오늘은 C#를 이용한 코딩테스트에서 중요하게 다뤄지는 알고리즘 중 하나인 너비 우선 탐색(BFS, Breadth-First Search)에 대해서 깊이 있게 알아보도록 하겠습니다. BFS는 그래프 또는 트리 데이터 구조를 탐색하는 알고리즘으로, 최단 경로 문제를 해결하거나, 특정 노드를 찾는 데 유용하게 쓰입니다.

1. 너비 우선 탐색(BFS)란?

BFS는 Queue(큐) 자료 구조를 사용하여 구현되는 탐색 알고리즘입니다. 이 알고리즘은 주어진 노드에서 시작하여 그 노드에 인접한 노드들을 탐색한 다음, 탐색한 노드의 인접 노드들을 다시 탐색하는 방식으로 진행됩니다. 이 방식은 점점 더 넓은 영역을 탐색하게 되어 ‘너비 우선’이라는 이름이 붙여졌습니다.

2. BFS의 특징

  • 최단 경로 탐색: BFS는 모든 간선의 가중치가 동일할 때, 최단 경로를 찾기에 적합합니다.
  • 햇빛 탐사: BFS는 가까운 노드를 먼저 방문하기 때문에, ‘햇빛’이 비추는 방식으로 탐색합니다.
  • 큐를 사용: 탐색 순서를 저장하기 위해 큐를 사용하여, 방문해야 할 노드를 FIFO(선입 선출) 방식으로 관리합니다.

3. BFS의 작동 원리

BFS의 기본적인 작동 방식은 다음과 같습니다:

  1. 탐색을 시작할 노드를 큐에 추가하고 방문 표기를 합니다.
  2. 큐에서 노드를 제거하고, 이 노드의 인접한 모든 노드를 체크합니다.
  3. 인접한 노드가 아직 방문하지 않았다면, 큐에 추가하고 방문 표기를 합니다.
  4. 큐가 비어있지 않을 때까지 2번과 3번 과정을 반복합니다.

4. 문제 풀이

이번에는 실제 코딩 테스트에서 나올 법한 문제를 통해 BFS를 이해해보겠습니다.

문제: ‘단지 번호 붙이기’

우리는 n × n 크기의 0과 1로 이루어진 배열을 가지고 있습니다. 여기서 1은 집이 존재하는 곳을 의미하고, 0은 집이 없는 곳을 의미합니다. 연결된 집을 하나의 단지로 보고, 단지의 번호를 붙이기 위해 BFS를 사용합니다. 같은 단지에 속한 집의 개수를 세어 각 단지의 크기를 출력하는 문제입니다.

입력

5
01101
11011
11100
00011
00000

출력

3
2
1

5. C# 코드 구현

이 문제를 BFS를 이용하여 해결하기 위한 C# 코드를 아래와 같이 작성해보았습니다.


using System;
using System.Collections.Generic;

class Program
{
    static int n;
    static int[,] map;
    static bool[,] visited;
    static int[] dx = { 1, -1, 0, 0 };
    static int[] dy = { 0, 0, 1, -1 };

    static void Main()
    {
        n = int.Parse(Console.ReadLine());
        map = new int[n, n];
        visited = new bool[n, n];

        for (int i = 0; i < n; i++)
        {
            string line = Console.ReadLine();
            for (int j = 0; j < n; j++)
            {
                map[i, j] = line[j] - '0';
            }
        }

        List results = new List();

        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (map[i, j] == 1 && !visited[i, j])
                {
                    results.Add(BFS(i, j));
                }
            }
        }

        results.Sort();
        Console.WriteLine(results.Count);
        foreach (int count in results)
        {
            Console.WriteLine(count);
        }
    }

    static int BFS(int startX, int startY)
    {
        Queue<(int, int)> queue = new Queue<(int, int)>();
        queue.Enqueue((startX, startY));
        visited[startX, startY] = true;

        int count = 0;

        while (queue.Count > 0)
        {
            var (x, y) = queue.Dequeue();
            count++;

            for (int i = 0; i < 4; i++)
            {
                int nx = x + dx[i];
                int ny = y + dy[i];

                if (nx >= 0 && ny >= 0 && nx < n && ny < n && map[nx, ny] == 1 && !visited[nx, ny])
                {
                    queue.Enqueue((nx, ny));
                    visited[nx, ny] = true;
                }
            }
        }

        return count;
    }
}

6. 코드 설명

위의 C# 코드는 다음과 같은 방식으로 작동합니다:

  1. 입력으로 n을 받아 n × n 크기의 집 배치 정보를 2D 배열에 저장합니다.
  2. visited 배열을 통해 각 집의 방문 여부를 기록합니다.
  3. 중첩된 for 루프를 사용하여 모든 집을 탐색하되, 방문하지 않은 집에 대해서만 BFS를 실행합니다.
  4. BFS 메소드는 큐를 사용하여 시작점에서 연결된 집을 탐색하고, 연결된 집의 수를 셉니다.
  5. 모든 단지의 크기를 리스트에 저장하고, 정렬하여 출력합니다.

7. 결론

이번 강좌에서는 너비 우선 탐색(BFS)을 활용한 문제를 통해 코딩 테스트에서 어떻게 문제를 해결할 수 있는지 살펴보았습니다. BFS는 다양한 문제에 적용할 수 있는 강력한 도구입니다. 그래프를 탐색할 때, 최단 경로를 찾을 때 등의 상황에서 BFS의 이해는 아주 중요합니다.

계속해서 BFS에 대한 예제와 더 복잡한 문제를 풀어보며 실력을 쌓아 보세요. 질문이나 의견이 있으시면 언제든 댓글로 남겨주세요. 다음 시간에는 또 다른 알고리즘에 대해 다루도록 하겠습니다!

© 2023 코딩테스트 강좌. All rights reserved.