22-alstjr7437

[alstjr7437]

🔗 문제 링크

연결 요소의 개수

✔️ 소요된 시간

40분

💡 부가 설명

네이버 부스트 캠프가 지원 언어로 쳐야할 것 같아서 다시 Swift로 복귀했습니다..
그런데 정말... 여러가지 화난 부분이 많아서 일단 적어봤습니다...

1. n,m 짤라서 받기
2. graph 배열 만들기
3. queue 없이 bfs 돌리기]
4. 마지막 예외 부분..
   그래도 구현을 완료 했습니다.

✨ 수도 코드

사실 수도코드가 필요가 없을 정도로 그래프 탐색을 알면 그냥 누구나 풀 수 있는 문제였습니다.

1. 노드와 간선 수 입력 받기
2. 이어진 간선 입력 받기
3. 2번을 가지고 그래프 배열 만들기
4. 모든 노드 반복문 돌리기
   • 방문 안했으면 BFS로 들어가기 ( 결과에 +1 하기)
   • 방문 했으면 넘어가기
5. 결과 출력하기

📜 정답 코드

import Foundation

let input = readLine()!.split(separator:
                            " ").map{ Int($0)!}

let n = input[0] , m = input[1]

var graph : [[Int]] = Array(repeating: [], count: n + 1)
var visited : [Bool] = Array(repeating: false, count: n + 1)
var result : Int = 0

for _ in 0..<m {
    let tmp = readLine()!.split(separator: " ").map { Int($0)!}
    graph[tmp[0]].append(tmp[1])
    graph[tmp[1]].append(tmp[0])
}

func bfs(start: Int){
    visited[start] = true
    var queue: [Int] = [start]
    
    var idx : Int = 0
    
    while idx < queue.count{
        let current = queue[idx]
        
        idx += 1
        for i in graph[current]{
            if visited[i] == false {
                queue.append(i)
                visited[i] = true
            }
        }
    }
}

for i in 1...n{
    if visited[i] == false {
        bfs(start : i)
        result += 1
    }
}

print(result)

📚 새롭게 알게된 내용

1️⃣ Swift n,m 잘라서 입력 받기

Swift에서 입력을 받을 때 split로 잘라서 map으로 각각의 값을 반환해서 list로 만들어 주고
그 만든 list를 이용하여 n,m으로 나눠줬습니다..

let input = readLine()!.split(separator:
                            " ").map{ Int($0)!}

let n = input[0] , m = input[1]

2️⃣ 비어진 배열의 기본값 배열 만들기

graph 배열을 만들때 노드 갯수만큼 반복된 배열 만들기
예) [0, 0, 0, 0, 0]

var graph : [[Int]] = Array(repeating: [], count: n + 1)
var visited : [Bool] = Array(repeating: false, count: n + 1)

3️⃣ queue 없이 BFS 돌리기

Swift에서는 queue가 제공되지 않아서 따로
Array는 removeFirst()함수가 제공 되지만 O(n)으로 시간복잡도를 가져서
어떻게 구현을 하지 생각하다가 블로그에서 참고한 부분이

아래와 같은 로직입니다.

아래 gif는 빨간색 부분이 idx이고 queue가 배열입니다.

func bfs(start: Int){
    visited[start] = true
    var queue: [Int] = [start]
    
    var idx : Int = 0
    
    while idx < queue.count{
        let current = queue[idx]
        
        idx += 1
        for i in graph[current]{
            if visited[i] == false {
                queue.append(i)
                visited[i] = true
            }
        }
    }
}

4️⃣ 런타임 에러 찾기

위 사진과 같이 계속해서 런타임 에러가 발생했었다..

처음에는 런타임 에러길래 크기를 잘못줬나 하면서
스위프트 욕을 엄청 하고 있는데

코드가 전혀 다른 부분이 없는 것 같은 코드를 들고와서 비교해봐도 해당 코드는 맞고 내 코드는 런타임 에러가 발생하길래
쭉 살펴보니까....

// 런타임 에러 발생 코드
for _ in 1...m {
    let tmp = readLine()!.split(separator: " ").map { Int($0)!}
    graph[tmp[0]].append(tmp[1])
    graph[tmp[1]].append(tmp[0])
}

// 런타임 에러 발생하지 않는 코드
for _ in 0..<m {
    let tmp = readLine()!.split(separator: " ").map { Int($0)!}
    graph[tmp[0]].append(tmp[1])
    graph[tmp[1]].append(tmp[0])
}

이렇게 코드가 나왔었는데

자세히 살펴보면 _로 사용해서 따로 반복문의 횟수만 중요하다고 생각해서 계속해서 넘어갔지만

문제는

정점의 개수 N과 간선의 개수 M이 주어진다. (1 ≤ N ≤ 1,000, 0 ≤ M ≤ N×(N-1)/2)

이 였다.

M이 0부터 시작이 되서 1...m을 하면 1 -> 0으로 에러가 발생하는 부분이였다..

문제를 잘 읽자

[9kyo-hwang]

아니 queue 지원 안하는 거 좀 끔찍하네;

찾아보니 저런 식으로 head를 가리키는 포인터를 두고 걔를 올리는 식으로 사용하는 방법도 있고, stack 2개를 사용하는 방법도 있네요.

특이한 게 보통 reverse란 메서드는 $O(n)$의 시간복잡도가 걸리는데 swift에서 reversed()란 메서드는 $O(1)$만에 처리 가능하도록 구현돼있어서 stack 2개를 써도 문제가 없네요...

[alstjr7437]

아니 queue 지원 안하는 거 좀 끔찍하네;

찾아보니 저런 식으로 head를 가리키는 포인터를 두고 걔를 올리는 식으로 사용하는 방법도 있고, stack 2개를 사용하는 방법도 있네요.

특이한 게 보통 reverse란 메서드는 O(n)의 시간복잡도가 걸리는데 swift에서 reversed()란 메서드는 O(1)만에 처리 가능하도록 구현돼있어서 stack 2개를 써도 문제가 없네요...

오.. 교황님 말씀을 듣고 reversed와 reverse 메서드를 조금 찾아보니까

reverse는 그냥 배열을 반대로 뒤집는 메서드라 O(n)이 나오고
reversed는 원본을 복사해서 들고가는데 복사 시점에서 변경이 일어나도 바뀌는 부분은 없군요..
그래고 새로운 ReversedCollection 래핑 객체를 만들더군요!!

감사합니다 새로운 지식을 넣어주셔서!

var originalArray = [1, 2, 3]
var reversedArray = originalArray.reversed()

print("0th index of OriginalArray \(originalArray[0])") // 1
print("0th index of ReversedBaseArray \(reversedArray._base[0])")       // 1


print("0th index of OriginalArray \(originalArray.first)")  // 1
print("0th index of ReversedBaseArray \(reversedArray.first)")  // 3


originalArray[0] = 4 // Modification makes a separate copy of each instance
print("0th index of OriginalArray \(originalArray[0])") // 4
print("0th index of ReversedBaseArray \(reversedArray._base[0])")   // 1


originalArray.reverse()
print(originalArray)    // [3,2,4]
print(reversedArray)    // ReversedCollection<Array<Int>>(_base: [1, 2, 3])

+ index 접근 불가..

아래 예제와 같이 ReversedCollection은 Int 인덱싱이 불가능하더군요..

let arr = [1,2,3,4]
let rev = arr.reversed() // ReversedCollection<Array<Int>> 이것은 Int인덱싱이 불가능하다.
let i = rev[1] // compile error!

그리고 배열 두개 쓰는게 이게 맞을까요..?
append를 해서 하면 어짜피 O(n)이 될 것 같은데
타입때문에 방법이 생각 안나네요.. @9kyo-hwang

func bfs3(start: Int){
    visited[start] = true
    var stack1: [Int] = [start]
    
    while !stack1.isEmpty{
        var temp: [Int] = []
        for i in stack1.reversed() { temp.append(i) }
        stack1 = temp
        let current = stack1.removeLast()
        for i in graph[current]{
            if visited[i] == false {
                stack1.append(i)
                visited[i] = true
            }
        }
    }
}

[9kyo-hwang]

Swift로 Queue 구현하기 여기 블로그 보고 해본 코드인데...

struct Queue<T> {
    private var enqueue: [T] = []
    private var dequeue: [T] = []
    
    var isEmpty: Bool {
        return enqueue.isEmpty && dequeue.isEmpty
    }
    
    mutating func push(_ input: T) {
        enqueue.append(input)
    }
    
    @discardableResult
    mutating func pop() -> T? {
        if dequeue.isEmpty {
            dequeue = enqueue.reversed()
            enqueue = []
        }
        return dequeue.popLast()
    }
}

이런 식으로 구현하는데, 보면 인덱스로 접근하는 건 아무것도 없고 전부 내장 메서드로 처리하더라구요.

해서

func bfs(start: Int) {
    visited[start] = true
    
    var q = Queue<Int>()
    q.push(start)
    
    while !q.isEmpty {
        let current = q.pop()!
        for i in graph[current] {
            if visited[i] == false {
                q.push(i)
                visited[i] = true
            }
        }
    }
}

이렇게 사용합니다.

push는 enqueue에만, pop은 dequeue에 대해서만 수행합니다.
reversed()는 $O(1)$ 시간에 해결되고, enqueue를 지우는 걸 배열 재할당으로 하면 $O(1)$만에 해결돼서 시간 복잡도는 문제가 되지 않습니다.

---

stack1의 reversed를 할 때마다 재 생성하는 것이 아닌, pop할 때 비었을 때만 하도록 설정해야 올바르게 동작할 겁니다.

[fnzksxl]

그렇다면 DFS를 돌려봅시다!

import sys

sys.setrecursionlimit(10**6)
input = sys.stdin.readline

def dfs(start,visited):
    visited[start ] =mark
    for node in graph[start]:
        if visited[node] == 0:
            dfs(node,visited)

N, M = map(int, input().split())

graph=[[] for _ in range(n+1)]

for i in range(m):
    start, end = map(int, input().split())
    graph[start].append(end)
    graph[end].append(start)

visited=[0] * (N+1)
mark = 1

for i in range(1, N+1):
    if visited[i] == 0:
        dfs(i, visited)
        mark += 1

print(max(visited))

[SeongHoonC]

무난한 bfs 문제군요 swift 에 queue 없는건 진짜..
화이팅입니다 하하

gif 너무 이쁘게 잘만들어서 직관적이고 좋았어요!!

fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val (n, m) = br.readLine().split(" ").map { it.toInt() }
    val graph = List(n + 1) { mutableListOf<Int>() }
    val visited = Array<Boolean>(n + 1) { false }

    repeat(m) {
        val (x, y) = br.readLine().split(" ").map { it.toInt() }
        graph[x].add(y)
        graph[y].add(x)
    }

    println((1..n).count { isConnected(it, graph, visited) })
}

private fun isConnected(start: Int, graph: List<List<Int>>, visited: Array<Boolean>): Boolean {
    if (visited[start]) {
        return false
    }

    val deque = ArrayDeque<Int>()
    deque.add(start)

    while (deque.isNotEmpty()) {
        val now = deque.removeFirst()
        for (next in graph[now]) {
            if (visited[next]) {
                continue
            }
            deque.add(next)
            visited[next] = true
        }
    }
    return true
}