합병 정렬(Merge sort)이란?

  • 합병정렬(merge sort)은 정렬 알고리즘의 한 종류로, 폰 노이만이 개발한 알고리즘이다.
  • 이 정렬은 안정 정렬에 속하며, 분할 정복(divide and conquer) 알고리즘의 하나이다.

 

합병 정렬(Merge sort) 아이디어

https://en.wikipedia.org/wiki/Merge_sort

합병(Merge)라는 이름에서 알 수 있듯, 합병 정렬의 기본 아이디어는 정렬할 배열을 분할하여, 작은 조각으로 나눈 후 더 이상 나눌 수 없을 때(하나의 원소만 있을때) 다른 조각과 비교하며 합쳐 정렬하는 알고리즘이다.

과정

  1.  정렬되지 않은 리스트를 2개의 리스트로 나눈다.
    • 각 리스트의 길이가 1이 될때까지 반복한다(길이가 1인 리스트는 정렬된 것으로 간주한다.)
  2. 2개의 리스트의 값들을 처음부터 하나씩 비교하여 두 개의 리스트의 값 중에서 더 작은 값을 새로운 리스트로 옮긴다.
    • 둘중 한 리스트가 끝날 때까지 이를 반복한다.
    • 한 리스트가 끝나면, 나머지 값들은 새 리스트에 복사해서 넣어준다(이미 정렬되어 있으므로)
  3. 2번 과정을 하나의 리스트가 될때까지 반복한다

 

합병 정렬(Merge sort) 증명

Merge 과정은 문제없이 기능한다 가정

귀납적 증명(Proof by Induction)

1. Base Case (기본 단계):

배열의 크기가 1 또는 0인 경우

  • 배열의 크기가 0 또는 1이면, 이미 정렬된 상태이다.

2. Inductive Hypothesis (귀납 가정):

배열의 크기가 n 이하인 모든 배열에 대해 Merge sort가 올바르게 작동한다고 가정.


3. Inductive Step (귀납적 단계):

배열의 크기가 n+1인 배열에 대해서 Merge sort가 올바르게 작동함을 증명.

  • 크기가 n+1인 배열 A를 반으로 나누어 두 개의 하위 배열 L과 R로 나눈다고 가정하자. 각 하위 배열의 크기는 대략 n/2 또는 그와 비슷하다.
  • 귀납 가정에 따라, 배열 L과 배열 R에 대해 각각 Merge sort를 호출하면, L과 R은 각각 오름차순으로 정렬된다.
  • Merge 과정이 끝나면, L과 R의 모든 요소가 오름차순으로 정렬된 하나의 배열로 합쳐지고. 이 배열은 오름차순으로 정렬된 상태이다.

따라서 배열의 크기가 n+1일 때도 Merge sort는 올바르게 작동한다.

 

합병 정렬(Merge sort) 시간복잡도

$T(n)=2T(\frac{n}{2})+n$ (이때 n은 merge시 걸리는 시간)

$\ \ \ \ \ \ \ \ =2(2T(\frac{n}{4})+\frac{n}{2})+n=4T(\frac{n}{4})+2n$

$\ \ \ \ \ \ \ \ =4(2T(\frac{n}{8})+\frac{n}{4})+2n=8T(\frac{n}{8})+3n$

$\ \ \ \ \ \ \ \ ...$

$\ \ \ \ \ \ \ \ =nT(1)+log(n)*n$

$\ \ \ \ \ \ \ \ =n*log(n)$

 

합병 정렬(Merge sort) 구현

#include <iostream>
using namespace std;

// 두 개의 하위 배열을 병합하는 함수
void merge(int arr[], int left, int mid, int right) {
    int n1 = mid - left + 1;  // 왼쪽 하위 배열의 크기
    int n2 = right - mid;     // 오른쪽 하위 배열의 크기

    // 임시 배열 생성
    int L[n1], R[n2];

    // 원본 배열의 값을 각각 왼쪽과 오른쪽 임시 배열로 복사
    for (int i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (int j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];

    // 두 배열을 병합하여 정렬된 상태로 원래 배열에 다시 삽입
    int i = 0, j = 0, k = left;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    // 왼쪽 배열의 남은 요소 복사
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    // 오른쪽 배열의 남은 요소 복사
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

// Merge Sort 알고리즘
void mergeSort(int arr[], int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;

        // 왼쪽과 오른쪽 배열에 대해 재귀적으로 정렬
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);

        // 정렬된 두 배열을 병합
        merge(arr, left, mid, right);
    }
}

// 배열을 출력하는 함수
void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++)
        cout << arr[i] << " ";
    cout << endl;
}

int main() {
    int arr[] = {12, 11, 13, 5, 6, 7};
    int arr_size = sizeof(arr) / sizeof(arr[0]);

    cout << "Given array is \n";
    printArray(arr, arr_size);

    mergeSort(arr, 0, arr_size - 1);

    cout << "\nSorted array is \n";
    printArray(arr, arr_size);
    return 0;
}

프림 알고리즘(Prim Algorithm)이란?

어떠한 그래프에서 최소신장트리(Minimum Spanning Tree)를 찾는 알고리즘이다.

그리디(Greedy) 알고리즘 중 하나이다.

 

프림 알고리즘(Prim Algorithm)의 아이디어

  • 트리중 하나의 노드에서 시작(아무 노드나 상관없음)
  • 우리가 만들어가고 있는 트리에 인접한 edge들 중 가장 작은 weight를 가진 edge를 추가
  • (단, 사이클을 만들지 않아야함)
  • spanning tree가 될때까지 반복 
    출처 : https://en.wikipedia.org/wiki/File:Prim-animation.gif

프림 알고리즘(Prim Algorithm)의 증명

정확성

G : 주어진 그래프(방향성X, 가중치O)

V : 전체 node의 집합

E : 전체 edge의 집합

Y : 방문한 node

F : 방문한 edge

 

G = (V,E)로 나타낼 수 있고, F  E, Y V이다.

G'(만들어가는중인 그래프) = (Y,F)

MST = (V,F') 이라고 정의하자.

 

가장 처음 F는 empty set이므로 F ⊆ F' 이 성립한다. 

 

1. G'에 인접한 edge들 중 가장 가중치가 낮은 edge를 e(v1 Y와 v2 V-Y를 잇는 edge)라고 하자

2. e가 F'의 원소일 경우, F U {e} 도 MST가 될 수 있는 상태이다.

3. e가 F'의 원소가 아닐 경우, F'은 spanning tree이므로 F' U {e}에는 하나의 사이클이 생길것이다.

    이때, F' U {e}에는 사이클에 속하지만 F에 속하지 않는 edge e'가 존재할 것이다.

3-1. F' U {e} - {e'}이 spanning tree가 된다면 e<=e'이므로, F' U {e} - {e'} 이 MST일 것이다.

3-2. F U {e} F' U {e} - {e'} 이므로 F U {e}는 항상 MST가 될 수 있는 상태이다.

 

이를 Y=V가 될 때까지 반복하여 MST를 만들 수 있다.

 

시간복잡도

E = edge, V = vertex

Minimum edge weight data structure Time complexity (total)
adjacency matrix, searching $O(|V|^2)$
binary heap and adjacency list $O((|V|+|E|)log|V|) = O(|E|log|V|)$
Fibonacci heap and adjacency list $O(|E|+|V|log|V|)$

출처 : https://en.wikipedia.org/wiki/Prim%27s_algorithm

구현(백준 1647번)

문제

동물원에서 막 탈출한 원숭이 한 마리가 세상구경을 하고 있다. 그러다가 평화로운 마을에 가게 되었는데, 그곳에서는 알 수 없는 일이 벌어지고 있었다.

마을은 N개의 집과 그 집들을 연결하는 M개의 길로 이루어져 있다. 길은 어느 방향으로든지 다닐 수 있는 편리한 길이다. 그리고 각 길마다 길을 유지하는데 드는 유지비가 있다. 임의의 두 집 사이에 경로가 항상 존재한다.

마을의 이장은 마을을 두 개의 분리된 마을로 분할할 계획을 가지고 있다. 마을이 너무 커서 혼자서는 관리할 수 없기 때문이다. 마을을 분할할 때는 각 분리된 마을 안에 집들이 서로 연결되도록 분할해야 한다. 각 분리된 마을 안에 있는 임의의 두 집 사이에 경로가 항상 존재해야 한다는 뜻이다. 마을에는 집이 하나 이상 있어야 한다.

그렇게 마을의 이장은 계획을 세우다가 마을 안에 길이 너무 많다는 생각을 하게 되었다. 일단 분리된 두 마을 사이에 있는 길들은 필요가 없으므로 없앨 수 있다. 그리고 각 분리된 마을 안에서도 임의의 두 집 사이에 경로가 항상 존재하게 하면서 길을 더 없앨 수 있다. 마을의 이장은 위 조건을 만족하도록 길들을 모두 없애고 나머지 길의 유지비의 합을 최소로 하고 싶다. 이것을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 집의 개수 N, 길의 개수 M이 주어진다. N은 2이상 100,000이하인 정수이고, M은 1이상 1,000,000이하인 정수이다. 그 다음 줄부터 M줄에 걸쳐 길의 정보가 A B C 세 개의 정수로 주어지는데 A번 집과 B번 집을 연결하는 길의 유지비가 C (1 ≤ C ≤ 1,000)라는 뜻이다.

임의의 두 집 사이에 경로가 항상 존재하는 입력만 주어진다.

출력

첫째 줄에 없애고 남은 길 유지비의 합의 최솟값을 출력한다.

예시

 

풀이

MST를 구하는 문제로, kruskal알고리즘 또는 Prim 알고리즘을 사용할 수 있다. 이 글에선 Prim알고리즘을 사용하여 문제를 풀어보았다.

입력받은 값들로 MST를 구한 후 가장 긴 edge를 제거하면 풀리는 문제이다.

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

typedef struct edge {
    int vertex1, vertex2;
    int weight;

    edge() {
        vertex1 = 0;
        vertex2 = 0;
        weight = 0;
    }

    edge(int v1, int v2, int w) {
        vertex1 = v1;
        vertex2 = v2;
        weight = w;
    }

    bool operator < (const edge& e) const {
        return weight < e.weight;
    }
}edge;

int Prim(int* vertex, vector<edge> edges[], int v) {
    int total_weight = 0;
    priority_queue<edge> adj_edges;
    int cur_vertex = 0, max_edge=0;
    vertex[0] = 1;

    for (int j = 0; j < v - 1; j++) {
        for (int i = 0; i < edges[cur_vertex].size(); i++) {
            adj_edges.push(edges[cur_vertex][i]);
        }
        while (!adj_edges.empty() && (vertex[adj_edges.top().vertex1] == 1 && vertex[adj_edges.top().vertex2] == 1)) {
            adj_edges.pop();
        }
        edge e = adj_edges.top();
        adj_edges.pop();
        vertex[e.vertex2] = 1;
        cur_vertex = e.vertex2;
        total_weight += e.weight;
        if(max_edge>e.weight){
            max_edge = e.weight;
        }
    }
    // return MST; 이렇게 하고 싶지만 최대한 빠르게 하기 위해서..total_weight를 리턴하는 걸로 하자
    return  -(total_weight-max_edge);

}

int main()
{
    int v, e;
    int v1, v2, w;
    int total_weight = 0;

    scanf("%d %d", &v, &e);

    int* vertex = new int[v];
    fill(vertex, vertex + v, 0);
    vector<edge> *edges = new vector<edge> [v];

    for (int i = 0; i < e; i++) {
        scanf("%d %d %d", &v1, &v2, &w);
        edges[v1-1].push_back(edge(v1-1, v2-1, -w));
        edges[v2-1].push_back(edge(v2-1, v1-1, -w));
    }

    total_weight = Prim(vertex, edges, v);
    printf("%d\n", total_weight);
}

 

 

 

오류수정은 언제나 환영입니다^^

'CS > Algorithm' 카테고리의 다른 글

합병 정렬(Merge sort)  (0) 2024.10.12
그리디 알고리즘(Greedy Algorithm, 탐욕법)  (0) 2024.07.13

1. 그리디 알고리즘이란?

  • 최적의 값을 구해야 하는 상황에서 전체적인 상황을 상정하여 구하는 것이 아닌, 각 단계에서 최선의 선택을 하는 근시안적 방법론입니다.
  • 전체적인 상황을 상정하지 않기 때문에 항상 최적의 해를 구하는 것이 보장되어있지 않지만, 근사해를 구하는것이 가능합니다.

아래와 같은 트리에서 각 노드의 합의 최대값을 구하는 상황일때, 탐욕법을 이용하면 각 단계에서 가장 큰 값을 선택하게 되어 5->10->4와 같이 선택하게 됩니다.

최적의 해는 5->7->9이므로 탐욕법을 이용하는것이 항상 최적의 해를 구하는 것은 아님을 보여줍니다.

출처 https://velog.io/@kyunghwan1207/%EA%B7%B8%EB%A6%AC%EB%94%94-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98Greedy-Algorithm-%ED%83%90%EC%9A%95%EB%B2%95

2. 그리디 알고리즘의 특징

2.1 그리디 알고리즘의 조건

그리디 알고리즘이 근사값이 아닌 최적값을 보장하는 조건 2가지가 있습니다.

 

  • 탐욕 선택 속성 (Greedy Choice Property)
현재의 선택이 미래의 선택에 영향을 끼치지 않는다.
  • 최적 부분 구조 (Optimal Substructure)
부분의 최적해가 모여 전체의 최적해가 된다.

 

문제가 이 두가지의 조건을 만족한다면 그리디 알고리즘을 사용해 최적값을 구할 수 있습니다.

2.2 그리디 알고리즘의 단계

1. 선택절차(Selection Procedure)

현재 상태에서 최적인 선택을 한다. 이 선택은 바뀌지 않는다.

 

2. 적절성 검사(Feasibility Check)

선택한 항목이 문제의 조건을 만족시키는지 확인한다.

 

3. 해답 검사(Solution Check)

모든 선택이 완료되면, 최종 선택이 문제의 조건을 만족시키는지 확인한다.

 

Reference

 

'CS > Algorithm' 카테고리의 다른 글

합병 정렬(Merge sort)  (0) 2024.10.12
프림 알고리즘(Prim Algorithm) 구현과 증명  (0) 2024.09.17

+ Recent posts