그래프 이론 - (1)

# 서로소 집합

• 서로소 집합(Disjoint Sets)란 공통 원소가 없는 두 집합을 의미한다.

 

- 서로소 집합 자료구조

• 서로소 부분 집합들로 나누어진 원소들의 데이터를 처리하기 위한 자료구조이다.
• 서로소 집합 자료구조는 두 종류의 연산을 지원한다.
  • 합집합(Union) : 두 개의 원소가 포함된 집합을 하나의 집합으로 합치는 연산
  • 찾기(Find) : 특정한 원소가 속한 집합이 어떤 집합인지 알려주는 연산
• 서로소 집합 자료구조는 합치기 찾기(Union Find) 자료구조라고 불리기도 한다.

 

- 동작 과정

• 여러 개의 합치기 연산이 주어졌을 때 서로소 집합 자료구조의 동작 과정은 다음과 같다.
  1. 합집합(Union) 연산을 확인하여 서로 연결된 두 노드 A, B를 확인한다.
     • A와 B의 루트 노드 A', B'를 각각 찾고 A'를 B'의 부모 노드로 설정한다.
  2. 모든 합집합(Union) 연산을 처리할 때까지 1번의 과정을 반복한다.
• 예시) 처리할 연산들 : Union(1,4), Union(2,3), Union(2,4), Union(5,6)

    1. 노드의 개수 크기의 부모 테이블을 초기화한다.

    2. 노드 1과 노드 4의 루트 노드를 각각 찾는다. 현재 루트 노드는 각각 1과 4이므로 더 큰 번호에 해당하는

        루트 노드 4의 부모를 1로 설정한다. (Union(1,4) 처리)

    3. 노드 2과 노드 3의 루트 노드를 각각 찾는다. 현재 루트 노드는 각각 2와 3이므로 더 큰 번호에 해당하는

        루트 노드 3의 부모를 2로 설정한다. (Union(2,3) 처리)

    4. 노드 2과 노드 4의 루트 노드를 각각 찾는다. 현재 루트 노드는 각각 2와 1이므로 더 큰 번호에 해당하는

        루트 노드 2의 부모를 1로 설정한다. (Union(2,4) 처리)

    5. 노드 5과 노드 6의 루트 노드를 각각 찾는다. 현재 루트 노드는 각각 5과 6이므로 더 큰 번호에 해당하는

        루트 노드 6의 부모를 5로 설정한다. (Union(5,6) 처리)

• 서로소 집합 자료구조에서는 연결성을 통해 손쉽게 집합의 형태를 확인할 수 있다.

 

 

- 연결성

• 기본적인 형태의 서로소 집합 자료구조에서는 루트 노드에 즉시 접근할 수 없다.
• 루트 노드를 찾기 위해 부모 테이블을 계속해서 확인하며 거슬러 올라가야 한다.

 

- 서로소 집합 자료구조 기본 구현 코드

# 특정 원소가 속한 집합을 찾기
def find_parent(parent, x):
    # 루트 노드를 찾을 때까지 재귀 호출
    if parent[x] != x:
        return find_parent(parent, parent[x])
    return x

# 두 원소가 속한 집합을 합치기
def union_parent(parent, a, b):
    a = find_parent(parent, a)
    b = find_parent(parent, b)
    if a < b:
        parent[b] = a
    else:
        parent[a] = b

# 노드의 개수와 간선(Union 연산)의 개수 입력 받기
v, e = map(int, input().split())
parent = [0] * (v + 1) # 부모 테이블 초기화

# 부모 테이블상에서, 부모를 자기 자신으로 초기화
for i in range(1, v + 1):
    parent[i] = i

# Union 연산을 각각 수행
for i in range(e):
    a, b = map(int, input().split())
    union_parent(parent, a, b)

# 각 원소가 속한 집합 출력
print('각 원소가 속한 집합: ', end='')
for i in range(1, v + 1):
    print(find_parent(parent, i), end=' ')

print()

# 부모 테이블 내용 출력하기
print('부모 테이블: ', end='')
for i in range(1, v + 1):
    print(parent[i], end=' ')

 

- 기본 구현의 문제점

• 합집합(Union) 연산이 편향되게 이루어지는 경우 찾기(Find) 함수가 비효율적으로 동작한다.
• 최악의 경우에는 찾기(Find) 함수가 모든 노드를 다 확인하게 되어 시간 복잡도가 O(V)가 된다.

 

- 경로 압축

• 찾기(Find) 함수를 최적화하기 위한 방법으로 경로 압축(Path Compression)을 이용할 수 있다.
• 찾기 함수를 재귀적으로 호출한 뒤에 부모 테이블의 값을 바로 갱신한다.

# 특정 원소가 속한 집합을 찾기
def find_parent(parent, x):
	# 루트 노드가 아니라면, 루트 노드를 찾을 때까지 재귀적으로 호출
    if parent[x] != x:
    	parent[x] = find_parent(parent, parent[x])
    return parent[x]

 

• 경로 압축 기법을 적용하면 각 노드에 대하여 찾기(Find) 함수를 호출한 이후에 해당 노드의 루트 노드가 바로 부모 노드가 된다.
• 동일한 예시에 대하여 모든 합집합(Union) 함수를 처리한 후 각 원소에 대하여 찾기 함수를 수행하면 다음과 같이 부모 테이블이 갱신된다.
• 기본적인 방법에 비하여 시간 복잡도가 개선된다.

 

- 서로소 집합을 활용한 사이클 판별

• 서로소 집합은 무방향 그래프 내에서의 사이클을 판별할 때 사용할 수 있다. (방향 그래프에서의 사이클 여부는 DFS를 이용한다.)
• 사이클 판별 알고리즘은 다음과 같다.
  1. 각 간선을 하나씩 확인하며 두 노드의 루트 노드를 확인한다.
     • 루트 노드가 서로 다르다면 두 노드에 대하여 합집합(Union) 연산을 수행한다.
     • 루트 노드가 서로 길다면 사이클(Cycle)이 발생한 것이다.
  2. 그래프에 포함되어 있는 모든 간선에 대하여 1번 과정을 반복한다.
• 동작 과정

    1. 모든 노드에 대하여 자기 자신을 부모로 설정하는 형태로 부모 테이블을 초기화한다.

    2. 간선 (1,2)를 확인한다. 노드 1과 노드 2의 루트 노드는 각각 1과 2이다. 따라서 더 큰 번호에 해당하는 노드 2의

        부모 노드를 1로 변경한다.

    3. 간선 (1,3)을 확인한다. 노드 1과 노드 3의 루트 노드는 각각 1과 3이다. 따라서 더 큰 번호에 해당하는 노드 3의

        부모 노드를 1로 변경한다.

    4. 간선 (2,3)을 확인한다. 이미 노드 2와 노드 3의 루트 노드는 모두 1이므로 사이클이 발생한다는 것을 알 수 있다.

 

- 사이클 판별 구현 코드

# 특정 원소가 속한 집합을 찾기
def find_parent(parent, x):
    # 루트 노드를 찾을 때까지 재귀 호출
    if parent[x] != x:
        parent[x] = find_parent(parent, parent[x])
    return parent[x]

# 두 원소가 속한 집합을 합치기
def union_parent(parent, a, b):
    a = find_parent(parent, a)
    b = find_parent(parent, b)
    if a < b:
        parent[b] = a
    else:
        parent[a] = b

# 노드의 개수와 간선(Union 연산)의 개수 입력 받기
v, e = map(int, input().split())
parent = [0] * (v + 1) # 부모 테이블 초기화

# 부모 테이블상에서, 부모를 자기 자신으로 초기화
for i in range(1, v + 1):
    parent[i] = i

cycle = False # 사이클 발생 여부

for i in range(e):
    a, b = map(int, input().split())
    
    # 사이클이 발생한 경우 종료
    if find_parent(parent, a) == find_parent(parent, b):
        cycle = True
        break

    # 사이클이 발생하지 않았다면 합집합(Union) 연산 수행
    else:
        union_parent(parent, a, b)

if cycle:
    print('사이클이 발생했습니다.')
else:
    print('사이클이 발생하지 않았습니다.')

---

# 연습문제

- 문제 설명 (백준 1717번 문제)

• 초기에 {0}, {1}, {2}, ... {n} 이 각각 n+1개의 집합을 이루고 있다. 여기에 합집합 연산과 두 원소가 같은 집합에 포함되어 있는지를 확인하는 연산을 수행하려고 한다.
• 집합을 표현하는 프로그램을 작성하시오.

 

- 조건

• 첫째 줄에 n이 1이상 1,000,000이하, m이 1이상 100,000이하로 주어진다. m은 연산의 개수이다.
• 다음 m개의 줄에는 각각의 연산이 주어진다.
• 합집합은 0 a b의 형태로 입력이 주어진다. a가 포함되어 있는 집합과 b가 포함되어 있는 집합을 합친다는 의미이다.
• 두 원소가 포함되어 있는지를 확인하는 연산은 1 a b의 형태로 주어진다. 이는 a와 b가 같은 집합에 포함되어 있는지를 확인하는 연산이다.
• a와 b는 n이하의 자연수 또는 0이며 같을 수도 있다.
• 1로 시작하는 입력에 대하여 한 줄에 하나씩 YES/NO로 결과를 출력한다. (yes/no 처럼 소문자도 가능)

 

- 예제 입출력

 

- 내 풀이

### 백준 유니온파인드 문제 1717 ###

# 특정 원소가 속한 집합을 찾기
def find_parent(parent, x):
    # 루트 노드를 찾을 때까지 재귀 호출
    if parent[x] != x:
        parent[x] = find_parent(parent, parent[x])
    return parent[x]

# 두 원소가 속한 집합을 합치기
def union_parent(parent, a, b):
    a = find_parent(parent, a)
    b = find_parent(parent, b)
    if a < b:
        parent[b] = a
    else:
        parent[a] = b

# 노드의 개수와 간선(Union 연산)의 개수 입력 받기
n, m = map(int, input().split())
parent = [0] * (n + 1) # 부모 테이블 초기화

# 부모 테이블상에서, 부모를 자기 자신으로 초기화
for i in range(1, n + 1):
    parent[i] = i

# 연산 정보를 입력 받고 수행하기
for _ in range(m):
    cal, a, b = map(int, input().split())
    if cal == 0:
        union_parent(parent, a, b)
    else:
        if find_parent(parent, a) == find_parent(parent, b):
            print('yes')
        else:
            print('no')

 

- 고찰

• 코딩 테스트에서 입력을 받는 부분에 다음과 같은 코드를 추가하면 시간초과가 발생하는 것을 방지할 수 있다.

import sys

input = int(sys.stdin.readline)

• 부모 테이블상에서 부모를 자기 자신으로 초기화 하는 부분은 다음과 같이 표현할 수 있다.

parent = [0] * (n + 1)
for i in range(1, n + 1):
    parent[i] = i

      |  |  |
      v  v  v

parent = [i for i in range(n+1)]

• class를 선언해서 해결할 수도 있다.

class DisjointSet():
	def __init__(self, n):
    		self.parent = list(range(n))
    
    	def find(self, idx):
    
    	def union(self, a, b):
    	

• 문제가 Union Find 유형임을 파악을 할 수 있다면 쉽게 해결할 수 있을 것으로 보인다.