SCC

1. 문제

2. 입출력

3. 입출력 예시

4. 문제 설계

• 방향 그래프에서 같은 그룹의 정점이라면 서로 오고갈수 있는 경로가 존재하는 그룹끼리 그래프를 나누는 것을 SCC(Strongly Connected Component)라고 하며, 이를 구할 수 있는 대표적인 알고리즘이 코사라주 알고리즘
• 따라서 주어진 그래프를 정방향 그래프와 역방향 그래프 두가지로 구성하고, 정방향 그래프에 대해 DFS를 적용하여 빠져나오는 순서대로 그 정점의 번호를 기록하고, 가장 나중에 빠져나온 정점이 역방향 그래프에서는 단말노드가 되므로,
• 역방향 그래프에 대해 가장 나중에 빠져나온 정점부터 다시 DFS를 적용하게 되면 SCC를 구할 수 있음
• 따라서 O(V + E)의 시간복잡도로 문제를 해결할 수 있음

5. 전체 코드

//MARK: - SCC(Strongly Connected Component) - 코사라주 알고리즘(Kosaraju's Algorithm)

//MARK: - Framework
import Foundation

//MARK: - Type
struct Graph {
    //MARK: - Property
    var edges: [Int]
    
    //MARK: - Init
    init() {
        self.edges = []
    }
}

//MARK: - Variable
var graph: [Graph] = [], reverseGraph: [Graph] = []
var visited: [Bool] = []
var orders: [Int] = [], groups: [Int] = []
var orderCount: Int = 0, groupCount: Int = 0

//MARK: - Function
func graphDFS(_ x: Int) -> Void {
    visited[x] = true
    
    for i in 0..<graph[x].edges.count {
        let y: Int = graph[x].edges[i]
        
        if !visited[y] {
            graphDFS(y)
        }
    }
    
    orders[orderCount] = x
    orderCount += 1
}

func reverseGraphDFS(_ x: Int) -> Void {
    visited[x] = true
    groups[x] = groupCount
    
    for i in 0..<reverseGraph[x].edges.count {
        let y: Int = reverseGraph[x].edges[i]
        
        if !visited[y] {
            reverseGraphDFS(y)
        }
    }
}

func solution() -> Void {
    //MARK: - Input
    guard let input: [String] = readLine()?.components(separatedBy: " ") else { return }
    let N: Int = input.map { Int($0) }[0] ?? 0
    let M: Int = input.map { Int($0) }[1] ?? 0
    graph = Array(repeating: Graph(), count: N + 10)
    reverseGraph = Array(repeating: Graph(), count: N + 10)
    visited = Array(repeating: false, count: N + 10)
    orders = Array(repeating: 0, count: N + 10)
    groups = Array(repeating: 0, count: N + 10)
    
    for _ in 0..<M {
        guard let inputData: [String] = readLine()?.components(separatedBy: " ") else { return }
        let a: Int = inputData.map { Int($0) }[0] ?? 0
        let b: Int = inputData.map { Int($0) }[1] ?? 0
        
        graph[a].edges.append(b)
        reverseGraph[b].edges.append(a)
    }
    
    //MARK: - Process
    for i in stride(from: 1, through: N, by: 1) {
        if !visited[i] {
            graphDFS(i)
        }
    }
    
    visited = Array(repeating: false, count: N + 10)
    
    for i in stride(from: orderCount - 1, through: 0, by: -1) {
        if !visited[orders[i]] {
            reverseGraphDFS(orders[i])
            groupCount += 1
        }
    }
    
    //MARK: - Output
    print(groupCount)
}
solution()

 

전체코드는 여기에서 확인할 수 있습니다.