SuperM

[DP] 2. 디자인 패턴 (Design Pattern)

슈퍼마리호 — Wed, 1 May 2019 19:22:41 +0900

2_디자인 패턴

2. 디자인 패턴 (Design Pattern)

디자인 패턴이란?

스트래티지 패턴

싱글턴 패턴

옵서버 패턴

템플릿 메서드 패턴

팩토리 메서드 패턴

1. 디자인 패턴이란?

소프트웨어를 설계할 때, 특정 맥락에서 자주 발생하는 고질적인 문제들이 또 발생했을 때 재사용 을 통해 해결할 수 있는 방법이다.

바퀴를 다시 발명하지 마라 (Don't reinvent the wheel)

이미 만들어져서 잘 되는 것을 처음부터 다시 만들 필요가 없다는 의미이다

2. 스트래티지 패턴

행위를 클래스로 캡슐화해 동적으로 행위를 자유롭게 바꿀 수 있게 해주는 패턴이다. 같은 문제를 해결하는 여러 알고리즘이 클래스별로 캡슐화 되어 있고, 이들이 필요할 때 마다 교체할 수 있도록 함으로써 동일한 문제를 다른 알고리즘으로 해결할 수 있게 해준다. 즉, 전략을 쉽게 바꿀 수 있도록 도와주는 디자인 패턴이다.

GoF에 따르면, Strategy 패턴의 의도는 다음과 같다.

다양한 알고리즘 군을 정의하고, 이들 각각을 캡슐화하여, 호환성 있게 만든다.

Strategy 패턴은 알고리즘을 이용하는 클라이언트와는 상관없이 독립적으로 이 알고리즘이 변화할 수 있게 해준다.

예를 들어, 국제적인 e-tail 시스템에서는 다른 나라의 세금을 계산하기 위해 서로 다른 세금 계산 알고리즘을 사용한다.

3. 싱글턴 패턴

전역 변수를 사용하지 않고, 객체를 하나만 생성 하도록 하며, 생성된 객체를 어디에서든지 참조할 수 있도록 하는 패턴이다.

GoF에 따르면, Singleton 패턴의 의도는 다음과 같다.

한 클래스가 오직 하나의 인스턴스만을 갖도록 하고, 이 인스턴스에 접근할 수 있는 광범위한 지시자(global point) 를 제공한다.

아래는 java를 이용한 기본적인 싱글턴 패턴의 소스 코드이다.

class USTax {
  private static USTax instance;
  private USTax() { }
  
  public static USTax getInstance() {
    if(instance == null)
      instance = new USTax();
    
    return instance;
  }
}

하지만 이 코드에서는 한 가지 문제점이 발생한다.

만약 다중 스레드 환경에서 동시에 getInstance() 를 호출한다고 가정해보자. 두 스레드는 동시에 null 을 확인하는데, 이 때 두 스레드는 모두 인스턴스를 생성하지 않았다. 따라서, 두 스레드가 new USTax() 를 수행하게 되어 2개의 인스턴스가 생성된다.

이에 대한 해결책으로, synchronized 키워드를 사용한 doSync() 메소드를 활용하는 방법이 있다.

class USTax {
  private static USTax instance;
  private USTax() { }
  
  public synchronized static void doSync() {
    if(instance == null)
      instance = new USTax();
  }
  
  public static USTax getInstance() {
    if(instance == null)
      doSync();
    
    return instance;
  }
}

4. 옵서버 패턴

한 객체의 상태 변화에 따라 다른 객체의 상태도 연동되도록 일대다 객체 의존 관계를 구성하는 패턴이다. Observer 패턴에서 이벤트를 발생시키고 있는 객체인 Subject는 그 이벤트에 대해 알아야 하는 모든 객체를 예측할 수 가 없다. 따라서 Observer 인터페이스를 생성하고 모든 Observer가 자신을 Subject에 등록하는 책임을 가지도록 요구한다.

GoF에 따르면, Observer 패턴의 의도는 다음과 같다.

한 객체의 상태가 변경되면, 이 객체에 의존적인 모든 객체가 통지를 받고 자동으로 수정되게 하기 위해, 객체들 간의 일대다 의존관계를 정의하는 것이다.

예를 들어, 차량 연료량 클래스는 연료량이 부족한 경우 연료량에 관심을 가지는 구체적인 클래스(연료량 부족 경고 클래스, 주행 가능 거리 출력 클래스) 에 직접 의존하지 않는 방식으로 이를 통보해야한 다.

5. 템플릿 메소드 패턴

어떤 작업을 처리하는 일부분을 서브 클래스로 캡슐화하여 전체 일을 수행하는 구조는 바꾸지 않으면서 특정 단계에서 수행하는 내역을 바꾸는 패턴이다. 즉, 전체적으로는 다른 구문으로 구성된 메소드의 코드 죽복을 최소화 할 때 유용하다.

GoF에 따르면, Templete Method 패턴의 의도는 다음과 같다.

Operation에 알고리즘의 골격을 정의하고, 이 알고리즘이 가진 몇 가지 단계의 내용은 서브클래스에게 정의를 맡긴다. Templete Method 패턴은 알고리즘의 구조를 변경하지 않으면서 알고리즘의 단계의 내용을 재정의 한다.

6. 팩토리 메소드 패턴

객체 생성 처리를 서브 클래스로 분리하여 처리하도록 캡슐화하는 패턴이다. 즉, 객체의 생성 코드를 별도의 클래스/메소드로 분리함으로써 객체 생성의 변화에 대비하는 방법이다.

GoF에 따르면, Factory Method 패턴의 의도는 다음과 같다.

객체 생성을 위한 인터페이스를 정의하고, 어떤 클래스가 인스턴스화되는지에 대한 결정은 서브클래스가 내리게 한다. Factory Method 패턴은 클래스가 서브클래스에게 인스턴스화에 대한 책임을 전가할 수 있게 해준다.

[AL] 9. 자료구조 (Trie)

슈퍼마리호 — Tue, 23 Apr 2019 15:00:17 +0900

9. 자료구조 (Trie)

트라이(Trie)

구현 방법

1. 트라이(Trie)

1.1. 개념

트라이(Trie) 는 Retireval(탐색) 에서 나온 단어이며, 문자열에서의 검색을 빠르게 해주는 자료구조이다.

만약 정수형에서 BST 를 이용한다면 O(logN) 의 시간만에 검색을 할 수 있다. 하지만 문자열에서 BST 를 사용한다고 할 때, 문자열의 길이가 M 이라면 O(M logN) 의 시간 복잡도를 갖는다.

이 때, 트라이를 이용한다면 O(M) 의 시간만에 원하는 문자열을 검색할 수 있게 된다!

1.2. 예시

우선 문자열 5개 {"blog", "he", "her", "supreme", "superm"} 이 있다고 가정해보자. 트라이는 이때 아래와 같은 트리를 형성하게 된다.

루트 노드가 되는 최상위 노드에는 어떠한 단어도 들어가지 않고, 루트 아래 노드부터 문자열들의 접두사가 하나씩 나타나게 된다.

superm 은 s → su → sup → supe → super → superm 으로 이루어지는데 이 과정에서 나타난 것들은 모두 superm 의 접두사이다.

1.3. 트라이의 단점

트라이는 공간 복잡도에서 치명적인 단점을 갖는다.

트라이에서 저러한 O(m)의 시간 복잡도가 나오기 위해서는 다음 문자를 가리키는 노드가 필요하다. 예를 들어, 알파벳에 대해 트리를 형성해야 한다면 a~z 인 총 26개의 포인터 배열을 가지고 있어야 한다.

즉, 최종 메모리는 O(포인터 크기 * 포인터 배열의 개수 * 트라이에 존재하는 총 노드의 수) 가 된다.

2. 구현 방법

2.1. 소스 코드 (C++)

struct Trie {
  bool finish;		// 끝나는 지점
  Trie* next[26];	// 알파벳 26개에 대한 트라이
  
  Tire() : finish(false) {
    memset(next, 0, sizeof(next));
  }
  ~Trie() {
    for(int i=0; i<26; i++){
      if(next[i])
        delete next[i];
    }
  }
  
  void insert(const char* key) {
    if(*key == '\0')
      finish = true;	// 문자열이 끝나는 지점 표시
    else{
      int current = *key - 'A';
      if(next[current] == NULL){
        next[current] = new Trie();	// 탐색이 처음되는 지점일 경우 동적할당
      }
      next[current]->insert(key+1);	// 다음 문자 삽입
    }
  }
  
  Trie* find(const char* key){
    if(*key == '\0')
      return this;		// 문자열이 끝나는 위치를 반환
    
    int current = *key - 'A';
    if(next[current] == NULL)
      return NULL;		// 찾는 값이 존재하지 않음
    return next[current]->find(key+1);	// 다음 문자 탐색
  }
  
}

참고 자료

[OS] 8. 디스크 관리 (Disk Management)

슈퍼마리호 — Mon, 22 Apr 2019 17:41:38 +0900

8. 디스크 관리

디스크 관리

디스크 스케줄링

1. 디스크 관리

디스크에 대한 접근 시간(Access Time) 은 아래와 같이 구분된다

탐색 시간(Seek Time)

디스크 헤드를 해당 실린더 위치로 이동시키는 데 걸리는 시간

회전 지연 시간(Rotational Latency)

디스크가 회전해서 읽고 쓰려는 섹터가 헤드 위치에 도달하기까지 걸리는 시간

전송 시간(Transfer Time)

해당 섹터가 헤드 위치에 도달한 후 데이터를 실제로 섹터에 읽고 쓰는데 소요되는 시간

2. 디스크 스케줄링

효율적인 디스크 입출력을 위해 여러 섹터들에 대한 입출력 요청이 들어왔을 때, 이들을 어떠한 순서로 처리할 것인지 결정하는 매커니즘이다. 디스크 스케줄링의 가장 중요한 목표는 디스크 헤드의 이동 거리를 줄이는 것이다.

2.1. FCFS 스케줄링

디스크에 먼저 들어온 요청을 먼저 처리하는 방식을 말한다.

만약 입출력 요청이 한쪽 끝과 반대쪽 끝에 번갈아 도착한다면 헤드는 디스크를 계속 왕복하며 일을 처리해야 하므로 탐색 시간이 매우 늘어나는 결과를 초래한다.

2.2. SSTF 스케줄링

현재 헤드의 위치로부터 가장 가까운 위치에 있는 요청을 제일 먼저 처리하는 알고리즘을 말한다.

헤드의 이동 거리를 줄여 디스크 입출력의 효율성을 증가시키지만, 기아 현상(Starvation) 을 발생시킬 수 있다. 만약 현재 위치와 가까운 곳에 지속적인 요청이 들어올 경우 헤드와 먼 요청은 무한히 기다려야 하는 문제가 발생할 수 있다.

2.3. SCAN 알고리즘 (= 엘리베이터 스케줄링 알고리즘)

헤드가 디스크 원판의 한쪽 끝에서 다른 쪽 끝으로 이동하며, 그 경로에 존재하는 모든 요청을 처리한다. 즉, 디스크의 어떠한 위치에 요청이 들어오는가와 상관없이 정해진 방향으로 이동하며 요청을 처리하는 방법이다.

FCFS의 비효율성 , SSTF의 비형평성 을 극복한 방법이지만, 가운데 위치가 기다리는 평균 시간이 더 짧다는 문제점을 지니고 있다.

2.4. C-SCAN 알고리즘

SCAN 알고리즘의 문제점을 극복한 방법으로, 다른 쪽 끝에 도달해 방향을 바꾼 후에는 요청을 처리하지 않고 곧바로 출발점으로 다시 이동만 한다. SCAN 보다 헤드의 이동 거리는 조금 길어지지만 탐색 시간의 편차를 해결할 수 있다.

2.5. LOOK / C-LOOK

SCAN 알고리즘은 요청의 존재 여부와 관계 없이 헤드가 무조건 디스크의 끝에서 끝으로 이동하는 반면에, LOOK 은 한쪽 방향으로 이동 중이다가 전방에 더 이상 대기중인 요청이 없으면 이동 방향을 즉시 변경하는 방식이다.

C-LOOK 은 전방에 요청이 없을 때 방향을 바꾼다는 측면에서 LOOK 과 유사하며, 한쪽 방향으로 이동할 때만 요청을 처리한다는 점에서 C-SCAN 과 유사하다.

[OS] 7. 가상 메모리 (Virtual Memory)

슈퍼마리호 — Mon, 22 Apr 2019 17:41:12 +0900

7. 가상 메모리 (Virtual Memory)

가상 메모리

요구 페이징

페이지 교체 알고리즘

1. 가상 메모리 (Virtual Memory)

1.1. 배경

운영체제는 CPU에서 당장 수행해야 할 부분만 메모리에 올려놓고 그렇지 않은 부분은 디스크의 스왑 영역(Swap Area) 에 내려놓았다가 다시 필요해지면 메모리에 올라가 있는 부분과 교체하는 방식을 사용한다. 이와 같이 메모리의 연장 공간으로 스왑 영역이 사용될 수 있기 때문에 프로그램 입장에서는 물리적 메모리 크기에 대한 제약을 생각할 필요가 없다.

1.2. 개념

가상 메모리는 프로세스마다 각각 0번지부터의 주소 공간을 가지게 되며, 이들 공간 중 일부는 물리적 메모리에 적재되고 일부는 디스크의 스왑 영역에 존재하게 된다.

2. 요구 페이징

2.1. 요구 페이징 (Demand Paging)

프로그램 실행 시, 프로세스를 구성하는 모든 페이지를 한꺼번에 메모리에 올리는 것이 아니라 당장 사용될 페이지만을 메모리에 올리는 방식이다.

당장 실행에 필요한 페이지만을 메모리에 적재하기 때문에, 메모리 사용량이 감소하고 프로세스 전체를 메모리에 올리는 데 들었던 입출력 오버헤드도 줄어든다.

요구 페이징에서는 유효-무효비트 를 두어 각 페이지가 메모리에 존재하는지를 구별한다.

유효비트

현재 페이지가 메모리에 있는 경우

무효비트

현재 페이지가 스왑 영역에 있는 경우

2.2. 페이지 부재 (Page Fault)

CPU가 참조하려는 페이지가 현재 메모리에 올라와 있지 않아 유효-무효비트가 무효로 세팅되어 있는 경우를 말한다.

페이지 부재 처리

CPU가 무효 페이지에 접근하면, 주소 변환을 담당하는 하드웨어인 MMU가 페이지 부재 트랩(page fault trap) 을 발생시킨다. 그러면 CPU 제어권이 커널 모드로 전환되고, 운영체제의 페이지 부재 처리 루틴(page fault handler) 이 호출되어 아래와 같이 처리를 진행한다.

해당 페이지에 대한 접근이 적법한지를 체크

물리적 메모리에서 비어 있는 프레임(free frame) 을 할당받아 그 공간에 해당 페이지를 읽어옴

만약 비어 있는 프레임이 없다면 페이지 중 하나를 스왑 영역으로 쫓아냄 swap out

이 과정은 오랜 시간이 소요되므로, 페이지 부재를 발생시킨 프로세스는 CPU 제어권을 빼앗기고 blocked 상태가 된다. 작업이 모두 완료되면 해당 페이지를 다시 유효비트로 설정하고, blocked 상태의 프로세스를 ready queue 로 이동시킨다.

3. 페이지 교체 알고리즘

페이지 부재가 발생했을 때, 페이지 부재율을 최소화하여 swap out 시킬 페이지를 선택하는 알고리즘

3.1. 최적 페이지 교체 (Optimal Page Replacement)

페이지 교체시 물리적 메모리에 존재하는 페이지 중 가장 먼 미래에 참조될 페이지를 쫓아내는 방법이다. 이 알고리즘은 미래에 어떤 페이지가 어떠한 순서로 참조될지 미리 알고있다는 전재 하에 운영하므로 실제로 사용할 수 있는 알고리즘은 아니다.

3.2. FIFO 알고리즘

페이지 교체시 물리적 메모리에 가장 먼저 올라온 페이지를 우선적으로 내쫓는다. 페이지의 향후 가능성을 고려하지 않고, 물리적 메모리에 들어온 순서대로 내쫓을 대상을 선정하기 때문에 비효율적인 상황이 발생할 수 있다.

FIFO 이상 현상

메모리를 증가시켰음에도 불구하고 페이지 부재가 오히려 늘어나는 상황

3.3. LRU 알고리즘

최근에 참조된 페이지가 가까운 미래에 다시 참조될 가능성이 높다는 시간 지역성(Temporal Locality) 을 활용해서 페이지 교체시 가장 오래 전에 참조가 이루어진 페이지를 교체하는 방법이다.

3.4. LFU 알고리즘

페이지 부재시 과거에 참조 횟수가 가장 적었던 페이지를 교체하는 방법이다. 최저 참조 횟수를 가진 페이지가 여러 개 존재한다면 임의로 하나를 선정하여 쫓아낸다. LRU 는 직접 참조된 시점만을 반영하지만, LFU 는 참조 횟수를 통해 장기적인 시간 규모에서의 참조 성향을 고려한다는 장점을 가지고 있다.

3.5. Clock 알고리즘

LRU 와 LFU 알고리즘은 페이지의 최근 참조 시각 및 참조 횟수를 유지해야 하므로 시간적인 오버헤드가 발생한다. 클럭 알고리즘은 하드웨어적인 지원을 통해 운영 오버헤드를 감소시킨 방법이다.

LRU 를 근사(approximation)시킨 알고리즘으로 NUR(Not Used Recently) 또는 NRU(Not Recently Used) 라고 불린다. LRU 이 가장 오래 전에 참조된 페이지를 교체하는 것에 비해, 클럭 알고리즘은 오랫동안 참조되지 않은 페이지 중 하나를 교체한다. 교체되는 페이지의 참조 시점이 가장 오래되었다는 것을 보장하지 못한다는 점에서 LRU를 근사시킨 알고리즘으로 볼 수 있다.

하드웨어에 의해 조작되며 운영체제는 참조 비트(Reference bit) 를 참고하여 Victim 결정

Reference bit = 1 (최근사용) , Reference bit = 0 (최근사용 X)

시계방향으로 움직이며 참조 비트가 1이면 0으로 바꾸고, 한바퀴 돌고와서도 0인 것을 교체

[OS] 6. 메모리 관리 (Memory Management)

슈퍼마리호 — Mon, 22 Apr 2019 17:40:42 +0900

6. 메모리 관리

메모리 관리 (Memory Management)

연속 할당 방식 (Contiguous Allocation)

비연속 할당 방식 (Noncontiguous Allocation)

1. 메모리 관리 (Memory Management)

1.1. 메모리 관리

물리적 주소 (Physical Address)

물리 메모리에 실제 올라기는 위치

논리적 주소 (Logical Address)

프로그램이 메모리에 적재되면 생기는 해당 프로세스를 위한 독자적인 주소 공간

CPU 가 보는 주소는 Logical Address

주소 바인딩 (Address Binding)

프로세스의 논리적 주소를 물리적 메모리 주소로 연결시켜 주는 작업

1.2. MMU

논리적 주소를 물리적 주소로 매핑해 주는 하드웨어 장치로서, 재배치 레지스터(Relocation Register) 와 한계 레지스터(Limit Register) 를 사용하여 매핑한다. 매핑하는 과정은 아래와 같다.

CPU가 논리적 주소 123 번지에 있는 내용을 요청

재배치 레지스터에 저장된 23000 이라는 값에 논리적 주소를 더함

논리적 주소 123 번지는 물리적 메모리의 시작 위치인 재배치 레지스터 값으로부터 요청된 위치가 얼마나 떨어져있는지를 나타내는 오프셋(offset)

한계 레지스터는 해당 프로세스의 크기를 저장

만약 요청한 논리적 주소가 이 값을 벗어나면 트랩을 이용해 프로세스 강제 종료

23123 번지의 물리적 메모리에는 CPU가 요청한 정보가 들어있음

1.3. 관련 용어

동적 로딩 (Dynamic Loading)

물리 메모리에 프로세스 전체를 올려놓는 것이 아닌, 필요한 루틴 을 그 때마다 적재하는 방식

다중 프로그래밍 환경에서 효율성을 높이기 위함

동적 연결 (Dynamic Linking)

Linking(Object File과 Library File을 묶어 실행 파일 생성) 을 실행 시점에서 하는 것

중첩 (Overlay)

프로세스의 크기가 물리 메모리보다 클 때 유용한 방법

프로세스에서 당장 필요한 부분을 메모리에 적재하는 방식

동적 로딩 과 유사하지만 그 목적이 다름

스와핑 (Swapping)

프로세스를 일시적으로 Swap Area 로 쫓아내는 것

다중 프로그래밍 환경에서 프로그램 수를 조절하여 성능 이슈를 해결하기 위함

2. 연속 할당 방식 (Contiguous Allocation)

각각의 프로세스가 메모리의 연속적인 공간에 적재되도록 하는 방식

2.1. 고정 분할 방식 (Fixed Partition Allocation)

물리적 메모리를 주어진 개수만큼의 영구적인 분할(Partition) 으로 미리 나누어 각 분할에 하나의 프로세스를 적재하여 실행하도록 하는 방식
융통성이 매우 떨어지는 방식
외부 단편화 및 내부 단편화가 발생할 수 있음
- 외부 단편화 : 빈 파티션이지만 프로세스보다 크기가 작아 이용될 수 없음
- 내부 단편화 : 파티션에 프로세스를 적재했을 때, 공간이 남아 메모리 낭비 발생

2.2. 가변 분할 방식 (Variable Partition Allocation)

프로그램의 크기를 고려하여 파티션의 크기 및 개수를 동적으로 바꾸는 방식
어떤 프로그램이 종료되었을 때, 그 빈 파티션에서 외부 단편화가 발생할 수 있음

가변 분할 방식에서 크기가 n인 프로세스를 적재할 파티션을 찾는 방법

First Fit

크기가 n 이상인 것 중, 최초로 찾은 파티션에 적재

Best Fit

크기가 n 이상인 것 중, 가장 크기가 작은 파티션에 적재

Worst Fit

크기가 가장 큰 파티션에 적재

3. 비연속 할당 방식 (Noncontiguous Allocation)

하나의 프로세스가 메모리의 여러 영역에 분산되어 올라가는 방식

3.1. 페이징 (Paging)

프로세스의 가상 메모리를 동일한 사이즈의 페이지 단위로 나누어 물리적 메모리에 불연속적으로 저장하는 방식

물리 메모리와 가상 메모리를 동일한 크기의 Frame 으로 나눔

모든 프로세스가 각각의 주소 변환을 위한 페이지 테이블 을 가지며, 이 테이블은 프로세스가 가질 수 있는 페이지의 개수만큼 주소 변환 엔트리를 갖음

특정 프로세스의 몇 번째 페이지가 물리적 메모리의 몇 번째 프레임에 들어 있다는 페이지별 주소 변환 정보를 유지하고 있어야함

외부 단편화 X , 내부 단편화 O

3.2. 세그먼테이션 (Segmentation)

프로세스의 가상 메모리를 의미 단위인 세그먼트로 나누어 물리 메모리에 적재하는 방식

일반적으로 code, data, stack 부분이 하나씩의 세그먼트로 정의

논리적인 단위인 세그먼트로 나누었기 때문에 그 크기가 균일하지 않음

페이징 기법과는 달리, 프로그램을 의미 단위로 나누었기 때문에 부가적인 메모리 관리 오버헤드가 뒤따름

세그먼트는 의미 단위이기 때문에 공유와 보안에 있어 페이징 기법보다 효과적

세그먼트의 길이가 동일하지 않으므로 외부 단편화 발생

3.3. 페이지드 세그먼테이션 (Paged Segmentation)

페이징 기법과 세그먼테이션 기법의 장점만을 취하는 주소 변환 기법

프로그램을 의미 단위인 세그먼트로 나누지만, 세그먼트가 임의의 길이를 가질 수 없고 반드시 동일한 크기의 페이지들의 집합 으로 구성

물리 메모리에 적재하는 단위는 페이지 단위

하나의 세그먼트 크기를 페이지 크기의 배수로 함으로써 외부 단편화 해결

세그먼트 단위로 프로세스 간의 공유나 프로세스 내의 접근 권한 보호로 페이징 기법의 약점 보완

[AL] 8. 최단 경로 알고리즘

슈퍼마리호 — Sat, 20 Apr 2019 17:01:54 +0900

8. 최단 경로 알고리즘

최단 경로(Short Path) 알고리즘

다익스트라(Dijkstra) 알고리즘

플로이드-와샬(Floyd-Warshall) 알고리즘

1. 최단 경로(Short Path) 알고리즘

1.1. 알고리즘의 종류

Single-Source (One-to-All)

하나의 출발 노드로부터 다른 모든 노드까지의 최단 경로

Dijkstra Algorithm 을 사용하여 해결

Single-Destination

모든 노드로부터 하나의 노드까지의 최단 경로

모든 Edge를 뒤집으면 One-to-All 과 동일함

Single-Pair (One-to-One)

하나의 출발 노드로부터 하나의 목적 노드로까지의 최단 경로

시간복잡도에서 One-to-All 보다 비효율적

All-Pair (All-to-All)

모든 노드 쌍의 최단 경로

Floyd-Warshall Algorithm 을 사용하여 해결

2. 다익스트라(Dijkstra) 알고리즘

2.1. Logic

초기 dist 배열을 모두 INF 값으로 초기화

첫 정점을 기준으로 연결되어 있는 정점을 추가해가며 최단 거리를 갱신함

A → B 인 경우, dist[b] 는 아래의 2개 중 최소값을 저장함

시작점 부터 a 까지의 최소비용 + a → b 의 가중치

기존에 가지고 있던 b 의 최소비용

2.2. Relax 연산

// u : 정점1
// v : 정점2
// w : 정점1과 정점2의 가중치
if(dist[v] > dist[u] + w){
  dist[v] = dist[u] + w;
}

2.3. 진행 과정

먼저 시작점은 E 이다

E 에서 갈 수 있는 경로는 B 와 D 이다

먼저 D 노드를 보면, 현재 비용은 ∞ 이고, E를 거쳐 갈 수 있는 비용은 2 이다. 이 중 최소값은 2이다

B 노드의 경우, 현재 비용은 ∞ 이고, E를 거쳐 갈 수 있는 비용은 4 이다. 이 중 최소값은 4이다

이제 나머지 정점 중에서 가장 짧은 정점을 가지고 있는 D 를 고른다

D 노드에서 갈 수 있는 경로는 B 와 C 이다

B 의 현재 비용은 4 이고, D 를 거치는 비용은 3 이다. 이 중 최소값은 3이다

C 노드의 경우 현재 비용은 ∞ 이고, D 를 거치는 비용은 3 이다. 이 중 최소값은 3이다

이런 식으로 진행 하다보면 최소 경로를 모두 구할 수 있다

3. 플로이드-와샬(Floyd-Warshall) 알고리즘

3.1. Logic

두 정점 사이에 간선이 존재하지 않는다면 dist 배열에 INF 를 설정

만약 간선이 존재한다면 가중치를 설정

i → j 의 최단 경로는 k를 지나는 경우와 지나지 않는 경우 중 하나이다

정점 i 와 j 의 경우를 탐색할 때, k는 모든 정점을 반복문으로 탐색

i → j 의 비용 과 i → k + k → j 의 비용 중 최소값을 저장

3.2. 소스 코드 (C++)

int dist[15][15];
int n;

int floyd(){
  
  for(int k=1; k<=n; k++){
    for(int i=1; i<=n; i++){
      for(int j=1; j<=n; j++){
        if(dist[i][j] > dist[i][k] + dist[k][j]){
          dist[i][j] = dist[i][k] + dist[k][j];
        }
      }
    }
  }
    
}

3.3. 정리

Case : 정점 V 개 , 간선 E 개

다익스트라 알고리즘

시작점으로부터 나머지 정점까지의 최단거리를 구할 때

공간 복잡도 : V^2 (인접행렬) , V+E (인접리스트)

시간 복잡도 : V^2 (인접행렬) , E logV (인접리스트+우선순위 큐)

플로이드 와샬 알고리즘

각 정점간 최단 경로를 구할 때

공간 복잡도 : V^2

시간 복잡도 : V^3

장단점

만약 간선 수가 많은 경우 플로이드 알고리즘 이 유리할 수 있음

한 점으로부터 각 정점까지의 최단거리만 필요하다면 다익스트라 가 압도적으로 빠름

그래프의 음의 가중치 간선이 존재한다면 다익스트라 X , 플로이드 O

[OS] 5. 데드락 (Deadlock)

슈퍼마리호 — Thu, 18 Apr 2019 19:17:25 +0900

5. 데드락 (Deadlock)

데드락 (Deadlock)

데드락의 처리

1. 데드락 (Deadlock)

1.1. Deadlock (= 교착 상태)

일련의 프로세스들이 서로가 가진 자원을 기다리며 Block 된 상태

1.2. Deadlock 발생의 4가지 조건

Mutual Exclusion (상호 배제)

매 순간 하나의 프로세스만이 자원을 사용할 수 있음

No Preemption (비선점)

프로세스는 자원을 스스로 내놓을 뿐 강제로 빼앗기지 않음

Hold and Wait (점유 대기)

자원을 가진 프로세스가 다른 자원을 기다릴 때, 보유 자원을 놓지 않고 갖고 있음

Circular Wait (순환 대기)

자원을 기다리는 프로세스간, 사이클이 형성되어야함

2. 데드락의 처리

2.1. Deadlock Prevention

자원 할당 시, 데드락의 4가지 조건 중, 어느 하나가 만족되지 않도록 하는 것

상호 배제 (Mutual Exclusion) 부정

여러 개의 프로세스가 공유 자원을 사용할 수 있도록 한다

비선점 (No Preemption) 부정

Save & Restore 이 가능한 자원에서 선점(Preemption)을 허용한다

점유 대기 (Hold and Wait) 부정

프로세스 시작 시, 모든 자원을 할당한다

자원이 필요한 경우, 보유 자원을 놓는다

순환 대기 (Circular Wait) 부정

할당 순서를 정하여, 정해진 순서대로 자원을 할당한다

2.2. Deadlock Avoidance

자원 요청에 대한 부가적인 정보를 이용하여, 데드락의 가능성이 없는 경우에만 자원 할당

자원 할당 그래프 (Resource Allocation Graph)

각 자원의 타입이 한 개 씩 있는 경우 (Single Instance)

프로세스와 자원의 요청 및 할당 관계를 표시함

Circular Wait 조건을 발견하기 위한 목적으로 사용

사이클을 형성 (단, 자원이 사이클을 형성하는 프로세스 외의 다른 프로세스들에게도 점유 당하고 있다면 제외) 한다면 데드락이 발생하는 경우

은행원 알고리즘 (Banker's Algorithm)

각 자원의 타입이 여러개 있는 경우 (Multiple Instance)

프로세스가 자원을 요구할 때, 시스템이 자원을 할당한 후 안정 상태로 남아있게 되는지를 사전에 검사하여 교착상태를 회피하는 방법

알고리즘을 이용해 안정 상태 인지 확인하고 안정 상태라면 자원을 할당하고 그렇지 않으면 다른 프로세스들이 자원을 해제할 때까지 대기

할당할 수 있는 자원의 수와 사용자의 수가 일정해야하고, 항상 불안정 상태를 방지해야 하므로 자원 이용도가 낮다는 단점을 지님

2.3. Deadlock Detection & Recovery

데드락 발생은 허용하되, 그에 대한 감지를 하여 데드락 발견시 회복함

Detection

Single Instance 의 경우 자원할당 그래프

Multiple Instance 의 경우 Banker's Algorithm

Recovery

Process Termination

데드락에 연관된 모든 프로세스를 죽임

Resource Preemption

비용을 최소화할 Victim 프로세스를 선정하여 자원을 빼앗음

2.4. Deadlock Ignore

데드락을 시스템이 책임지지 않음

데드락이 매우 드물게 발생하므로, 데드락에 대한 조치 자체가 더 큰 overhead 일 수 있음

만약, 시스템에서 데드락이 발생한 경우, 프로그래머가 직접 process를 죽이는 방법으로 대처

UNIX, Windows 등 대부분의 OS 가 채택

예상 질문

교착상태란 무엇인가를 설명한 후, 교착상태 발생 조건 4가지에 대하여 설명하세요

교착상태 회피 기법인 Banker's Algorithm 에 대하여 설명하세요

기아상태를 설명하는 Dining Philosophers Problem 에 대하여 설명하세요

참고자료

https://m.blog.naver.com/dong5053/220717510273

[AL] 7. 최소 비용 신장 트리(MST) 알고리즘

슈퍼마리호 — Wed, 17 Apr 2019 20:09:42 +0900

<!doctype html>

7. 최소 비용 신장 트리(MST) 알고리즘

신장 트리 (Spanning Tree)

최소 비용 신장 트리 (MST)

Kruskal MST 알고리즘

Prim MST 알고리즘

1. 신장 트리 (Spanning Tree)

1.1. Spanning Tree

그래프 내의 모든 정점을 포함하는 트리

Spanning Tree는 그래프의 최소 연결 부분 그래프 이다

트리의 특수한 형태로 모든 정점들이 연결되어 있고 사이클은 존재하지 않는다

n 개의 정점을 정확히 n-1 개의 간선으로 연결한다

BFS, DFS 를 이용하여 그래프에서 Spanning Tree를 찾을 수 있다

하나의 그래프에는 많은 Spanning Tree가 존재한다

2. 최소 비용 신장 트리 (MST, Minimum Spanning Tree)

2.1. MST

Spanning Tree 중에서 사용된 간선들의 가중치 합이 최소인 트리

각 간선의 가중치가 동일하지 않을 때, 단순히 가장 적은 간선을 사용한다고 최소 비용이 아니다

MST 는 간선의 가중치를 고려하여 최소 비용을 선택하는 알고리즘이다

즉, 그래프에 있는 모든 정점을 선택하고 가장 적은 수의 간선과 비용으로 Spanning Tree 를 구성하는 것이다

3. Kruskal MST 알고리즘

3.1. 이론

탐욕적인 방법(Greedy) 을 이용하여 가중치 그래프의 모든 정점을 최소 비용으로 연결하는 방법

MST 가 최소 비용의 간선으로 구성됨 , 사이클을 포함하지 않음 의 조건에 근거하여 각 단계에서 사이클을 이루지 않는 최소 비용 간선을 선택한다
간선 선택을 기반으로 하는 알고리즘이다
이전 단계에서 만들어진 신장 트리와는 상관없이 무조건 최소 간선만을 선택하는 방법이다

3.2. 과정

그래프의 간선들을 가중치의 오름차순으로 정렬한다
정렬된 간선 리스트에서 순서대로 사이클을 형성하지 않는 간선을 선택한다
- 즉, 가장 낮은 가중치를 먼저 선택한다
- 사이클을 형성하는 간선을 제외한다
- 해당 간선을 현재의 MST의 집합에 추가한다

주의할점

간선을 추가할 때 사이클이 생성되는지를 체크해야함

새로운 간선이 이미 다른 경로에 의해 연결되어 있는 정점들을 연결할 때 사이클을 형성함

즉, 추가할 때 새로운 간선의 양끝 정점이 같은 집합에 속해 있으면 사이클이 형성됨

Union-Find 알고리즘을 이용하여 사이클 생성 여부를 확인할 수 있다!

시간 복잡도

Union-Find 알고리즘을 이용하면 Kruskal 알고리즘의 시간 복잡도는 간선들을 정렬하는 시간에 좌우된다. 즉, 간선 N개를 효율적으로 정렬한다면 O(N logN) 의 시간 복잡도를 갖는다.

3.3. 소스 코드 (C++)

// Krusal
typedef struct kruskal {
    int from,to,val;
} Edge;

bool comp(Edge e1, Edge e2){
    return e1.val < e2.val;
}

class Kruskal {
private:
    int parent[MAX+1];
    int res;
    vector<Edge> edge;
public:
    // 생성자
    Kruskal(){
        for(int i=1; i<=MAX; i++){
            parent[i] = i;
        }
        
        go();
    }
    
    // Union
    void merge(int u,int v){
        u = find(u);
        v = find(v);
        
        if(u == v) return;
        
        parent[u] = v;
    }
    
    // Find
    int find(int u){
        if(parent[u] == u) return u;
        
        else return parent[u] = find(parent[u]);
    }
    
    // GO
    void go(){
        int V,E;
        
        cin >> V >> E;
        
        // 간선의 정보 입력
        for(int i=0; i<E; i++){
            Edge e;
            cin >> e.from >> e.to >> e.val;
            edge.push_back(e);
        }
        
        // 간선을 가중치로 오름차순 정렬
        sort(edge.begin(),edge.end(),comp);
        
        for(int i=0; i<E; i++){
            // 두 정점이 사이클을 형성하지 않는다면
            if(find(edge[i].from) != find(edge[i].to)){
                // 가중치값 더해줌
                res += edge[i].val;
                
                // MST 형성
                merge(edge[i].from, edge[i].to);
            }
        }
        
        cout << res << "\n";
    }
};

4. Prim MST 알고리즘

4.1. 이론

시작 정점에서부터 출발하여 신장트리 집합을 단계적으로 확장 해나가는 방법

4.2. 과정

시작 단계에서는 시작 정점만이 MST 에 포함된다
앞 단계에서 만들어진 MST 집합에 인접한 정점들 중에서 최소 간선으로 연결된 정점을 선택하여 트리를 확장한다
- 즉, 가장 낮은 가중치를 먼저 선택한다
위의 과정을 트리가 N-1 개의 간선을 가질 때까지 반복한다

시간 복잡도

1차 반복문이 정점의 수인 n만큼 반복하고, 2차 반복문이 n번 반복된다. 따라서 Prim 알고리즘은 O(N^2) 의 시간 복잡도를 갖는다. 만약, 우선순위 큐를 사용한다면 O(E logV) 의 시간 복잡도를 갖는다.

따라서 그래프 내의 간선의 숫자가 적은 희소 그래프(Sparse Graph) 의 경우 Kruskal 알고리즘 이 유리하고, 그래프 내의 간선의 숫자가 많은 밀집 그래프(Dense Graph) 의 경우 Prim 알고리즘 이 유리하다.

4.3. 소스 코드 (C++)

// Prim
typedef pair<int, int> pii;

class Prim {
private:
    bool visited[MAX+1];
    vector<pii> adj[MAX];
public:
    Prim(){
        memset(visited, false, sizeof(visited));
        
        go();
    }
    
    int prim(int start){
        int res = 0;
        visited[start] = true;
        
        // 우선순위 큐
        priority_queue<pii, vector<pii>, greater<pii>> pq;
        
        // 시작정점의 간선들 삽입
        for(int i=0; i<adj[start].size(); i++){
            pq.push(pii(adj[start][i].first ,adj[start][i].second));
        }
        
        while(!pq.empty()){
            int curr = pq.top().first;
            int cost = pq.top().second;
            pq.pop();
            
            if(!visited[curr]){
                visited[curr] = true;
                res += cost;
                
                for(int i=0; i<adj[curr].size(); i++){
                    pq.push(pii(adj[curr][i].first ,adj[curr][i].second));
                }
            }
        }
        
        return res;
    }
    
    void go(){
        int V,E;
        
        cin >> V >> E;
        
        // 간선의 정보 입력
        for(int i=0; i<E; i++){
            int from, to, val;
            
            cin >> from >> to >> val;
            
            adj[from].push_back(pii(to,val));
            adj[to].push_back(pii(from,val));
        }
        
        cout << prim(1) << "\n";
    }
};

참고 자료

https://www.crocus.co.kr/733?category=209527

[DP] 1. 객체 지향 프로그래밍 (OOP)

슈퍼마리호 — Fri, 12 Apr 2019 19:46:20 +0900

1. 객체 지향 프로그래밍

객체 지향 프로그래밍 (OOP)

OOP 특징

오버로딩과 오버라이딩

추상클래스와 인터페이스

1. 객체 지향 프로그래밍 (OOP)

1.1. OOP (Object Oriented Programming)

OOP(객체 지향 프로그래밍) 이전의 프로그래밍을 살펴보면, 컴퓨터가 사고하는대로 프로그래밍을 하는 컴퓨터 중심적 패러다임 이었다. 하지만, 객체 지향 프로그래밍이란 인간 중심적 패러다임 이라고 할 수 있다. 즉, 현실 세계를 프로그래밍으로 옮겨와 프로그래밍하는 것을 말한다. 현실 세계의 사물들을 객체라고 보고, 그 객체로부터 개발하고자 하는 애플리케이션에서 필요한 특징들을 뽑아와 프로그래밍 하는 것이다.

1.2. 클래스 (Clsss)

연관되어 있는 변수와 메서드의 집합이다. 객체를 만들어 내기 위한 설계도 혹은 틀이라 표현할 수 있다.

1.3. 객체 (Object)

소프트웨어 세계에 구현할 대상이다. 클래스에 선언된 모양 그대로 생선된 실체로, 클래스의 인스턴스 라고도 부른다. 객체는 모든 인스턴스를 대표하는 포괄적인 의미를 갖는다.

1.4. 인스턴스 (Instance)

클래스를 바탕으로 소프트웨어에 구현된 구체적인 실체이다. 즉, 객체를 소프트웨어에 실체화 하면 그것을 인스턴스라고 부른다.

인스턴스는 객체에 포한된다고 볼 수 있다

OOP 관점에서 객체가 메모리에 할당되어 실제 사용될 때 인스턴스 라고 부른다

인스턴스는 어떤 원본(추상적인 개념)으로부터 생성된 복제본 을 의미한다

2. OOP 특징

2.1. 추상화 (Abstraction)

어떤 영역에서 필요로 하는 속성이나 행동을 추출하는 작업

사물들의 공통된 특징, 즉 추상적 특징 을 파악해 인식의 대상으로 삼는 행위
구체적인 사물들의 공통적인 특징을 파악해서 이를 하나의 개념(집합) 으로 다루는 수단

2.2. 캡슐화 (Encapsulation)

캡슐화는 낮은 결합도 를 유지할 수 있도록 해주는 객체지향 설계 원리이다

캡슐화는 정보 은닉 을 통해 높은 응집도와 낮은 결합도를 갖도록 해준다

정보 은닉 (Information Hiding)

필요가 없는 정보는 외부에서 접근하지 못하도록 제한하는 것

private 키워드

응집도 (Cohesion)

클래스나 모듈 안의 요소들이 얼마나 밀접하게 관련되어 있는지

결합도 (Coupling)

어떤 기능을 실행하는 데 다른 클래스나 모듈들에 얼마나 의존적인지

2.3. 일반화 (Generalization)

일반화는 여러 개체들이 가진 공통된 특성을 부각시켜 하나의 개념이나 법칙으로 성립시키는 과정이다

일반화 관계는 객체지향 프로그래밍 관계에서 상속 관계 라고 한다
따라서 속성이나 기능의 재사용만 강조해서 사용하는 경우가 많다

일반화는 또 다른 캡슐화

일반화 관계는 자식 클래스를 외부로부터 은닉하는 캡슐화의 일종이다

즉, 자식 클래스 자체를 캡슐화 하는 것으로 확장된다

서브 클래스의 캡슐화는 외부 클라이언트 가 개별적인 클래스들과 무관하게 프로그래밍을 할 수 있게 한다

2.4. 다형성 (Polymorphism)

다형성은 서로 다른 클래스의 객체가 같은 메시지 를 받았을 때, 각자의 방식 으로 동작하는 능력이다

다형성이 상속과 연계되어 동작하면 매우 효과적이다
다형성과 일반화 관계는 코드를 간결하게 할 뿐 아니라 변화에도 유연하게 대처할 수 있게한다

// 부모 클래스
public abstract class Pet {
  public abstract void talk();
}

// 자식 클래스
public class Cat extends Pet {
  public void talk(){ System.out.println("야옹"); }
}
public class Dog extends Pet {
  public void talk(){ System.out.println("멍멍"); }
}
public class Parrot extends Pet {
  public void talk(){ System.out.println("안녕"); }
}

3. 오버로딩과 오버라이딩

3.1. 오버로딩 (Overloading)

두 메서드가 같은 이름을 갖고 있으나, 인자의 수나 자료형이 다른 경우를 말한다

public double getArea(Circle c) { }
public double getArea(Circle c1, Circle c2) { }
public double getArea(Square s) { }

3.2. 오버라이딩 (Overriding)

상위 클래스의 메서드와 이름의 용례(signature)가 같은 함수를 하위 클래스에 재정의 하는 것을 말한다

public abstract class Shape {
  public void print() { System.out.println("Shape"); }
}

public class Circle extends Shape {
  @Override
  public void print() { System.out.println("Circle"); }
}

public class Square extends Shape {
  @Override
  public void print() { System.out.println("Square"); }
}

4. 추상클래스와 인터페이스

4.1. 추상 클래스 (Abstract Class)

abstract 키워드로 선언된 클래스를 뜻하며, 하나 이상의 추상 메소드를 가지고 있다면 반드시 추상 클래스로 선언해야한다.

abstract class Shape {
  Shape() { }
  void edit() { }
  abstract public void draw();
}

class Circle extends Shape {
  public void draw() { System.out.println("Circle"); }
}

4.2. 인터페이스 (Interface)

추상 메소드와 상수만을 포함하며, interface 키워드를 사용하여 선언한다. 상속받을 서브 클래스에게 구현할 메소드의 원형을 모두 알려주어, 클래스가 자신의 목적에 맞게 메소드를 구현하도록 한다.

오직 상수 필드와 추상 메소드로 구성됨

모든 메소드는 추상 메소드로서, abstract public 생략 가능

상수는 public static final 이며, 생략 가능

인터페이스를 상속받아 새로운 인터페이스를 만들 수 있음

interface Phone {
  int BUTTONS = 20;
  void sendCall();	// 추상 메소드
  abstract public void receiveCall();	// 추상 메소드
}

class IphoneX implements Phone {
  // Phone의 모든 추상 메소드를 구현한다
  public void sendCall() { }
  public void receiveCall() { }
  // 추가적으로 다른 메소드를 작성할 수 있다
  public void callSiri() { }
}

4.3. 추상 클래스와 인터페이스

공통점

인스턴스(객체) 를 생성할 수 없다

선언만 있고 구현 내용은 없다

차이점

서로 다른 목적을 가지고 있다

추상클래스 : 자식 클래스가 추상 메소드를 구체화하여 그 기능을 확장

인터페이스 : 서로 관련이 없는 클래스에서 공통적으로 사용하지만 각각 기능을 구현할 때

추상 클래스는 클래스이지만 인터페이스는 클래스가 아니다

추상 클래스는 단일 상속이지만 인터페이스는 다중 상속이 가능하다

추상 클래스는 is a kind of , 인터페이스는 can do this

추상클래스 : Appliances - TV, Refrigerator

인터페이스 : Flyalbe - Plane, Bird

참고 자료

https://gmlwjd9405.github.io/2018/07/05/oop-features.html

[AL] 6. Union-Find 알고리즘

슈퍼마리호 — Fri, 5 Apr 2019 00:04:44 +0900

6. Union-Find 알고리즘

Union-Find

Union-Find 구현

최적화 (Optimization)

1. Union-Find

1.1. Union-Find 란?

서로소 집합(Disjoint Set) 라고 불리며, Union(x,y) 과 Find(x) 연산을 수행한다

Union(x,y) 를 수행하면 x와 y는 같은 집합에 속하게 되며, Find(x) 와 Find(y) 는 x, y 가 같은 집합에 속할 때만 같은 값을 가진다. 따라서, 전체 요소들을 서서히 묶어나가는 상황에서 유용하게 사용할 수 있는 자료구조이다.

1.2. 원리

배열을 이용해서 Tree 자료구조를 만들어 구현하며, 최상단 노드를 Root 노드로 하여 집합을 구분한다
주어진 두 원소 또는 집합을 합하는 Union 부분과 원소가 어떤 집합에 있는지 찾는 Find 부분으로 이루어져있다
parent[i] : 원소 i 의 부모 노드를 가지고 있는 배열, 즉 parent[i] 는 i 의 부모노드
(1,2) (2,5) (5,6) (5,8) (3,4) 수행 시, 아래와 같은 결과를 보인다

2. Union-Find 구현

2.1. 초기화

N 개의 원소가 각각의 집합에 포함되어 있도록 초기화 한다

void Set(){
    for(int i=1; i<=SIZE; i++){
        parent[i] = i;
    }
}

2.2. Union

두 원소 u, v 가 주어질 때, 이들이 속한 두 집합을 하나로 합친다

// u와 v의 원소가 들어오면 각각의 Root 노드를 찾아주고
// 두 root노드가 같지 않다면, u의 root 노드를 v로 설정해준다
void Union(int u,int v){
    
    u = Find(u);
    v = Find(v);
    
    // root가 같다면 이미 같은 트리
    if(u == v) return;
  
    // u의 루트가 v가 되도록
    parent[u] = v;
}

2.3. Find

어떤 원소 u 가 주어질 때, 이 원소가 속한 집합의 Root 를 반환한다

int Find(int u){
    
    // Root인 경우 x를 반환
    if(parent[u] == u){
        return u;
    }
    
    // 아니면 Root를 찾아감
    return parent[u] = Find(parent[u]);
}

3. 최적화 (Optimization)

이와 같이 트리로 구현하는 방법에는 큰 문제점이 발생할 수 있다.

바로 최악의 경우 완전히 비대칭적인 트리, 즉 연결 리스트 형태가 될 수 있다는 것이다. 만약 트리의 모양이 일자로 나온다면 Union 연산과 Find 연산의 수행시간이 O(N) 이 되버려 배열로 구현했을 때 보다도 효율이 나빠지게 된다.

이 문제는 두 트리를 합칠 때, 항상 높이가 더 낮은 트리를 높은 트리 밑에 넣음 으로서 해결이 가능하다. 이렇게 되면 트리의 높이가 크게 높아지는 현상을 방지할 수 있다. 이러한 최적화를 union-by-rank 라 하며, 여기서 rank 는 해당 트리의 높이를 저장한다.

시간 복잡도

일단 트리로 압축시켰기 때문에 find 시간복잡도는 O(logN) 을 갖게된다

또한 union 도 find 의 지배를 받기에 O(logN) 을 갖게 된다

사실 실제 시간 복잡도는 O( (N)) 이라고 한다. 는 애커만 함수를 뜻하며 N이 2^65536 일때, 함수 값이 5가 된다. 따라서 그냥 상수로 봐도 무방하다.

3.1. 최적화 소스코드

#include <iostream>
using namespace std;

const int SIZE = 100;

int parent[SIZE+1];
int level[SIZE+1];

void Set(){
    for(int i=1; i<=SIZE; i++){
        parent[i] = i;
        level[i] = 1;
    }
}

int Find(int u){
    
    // Root인 경우 x를 반환
    if(parent[u] == u){
        return u;
    }
    
    // 아니면 Root를 찾아감
    return parent[u] = Find(parent[u]);
}

// u와 v의 원소가 들어오면 각각의 Root 노드를 찾아주고
// 두 root노드가 같지 않다면, u의 root 노드를 v로 설정해준다
void Union(int u,int v){
    
    u = Find(u);
    v = Find(v);
    
    // root가 같다면 이미 같은 트리
    if(u == v) return;
        
    // v에 더 큰 값을 배치시키기 위함
    if(level[u] > level[v])
        swap(u, v);
        
    // u의 루트가 v가 되도록
    parent[u] = v;
    
    // u와 v의 깊이가 같을 때 v의 깊이를 늘려준다
    if(level[u] == level[v])
        ++level[v];
}

참고 자료

https://www.crocus.co.kr/683