만득

백준 2116 주사위 쌓기

2021-12-16T00:00:00+00:00

전형적인 DP문제. 하나씩 주사위를 쌓아가면서 가장 위의 주사위가 1~6 이 될 때 옆면의 최대 숫자를 구해주면 된다. 예를들어 가장 윗 주사위의 숫자가 3이고 반대편 주사위 숫자가 5라고 했을 때 DP[n][3] = DP[n-1][5] + PossibleSideMaxNumber[3]이 된다.

따라서 DP 공식은 다음과 같다.

DP[n][A] = DP[n-1][F] + PossibleSideMaxNumber[A]
DP[n][B] = DP[n-1][D] + PossibleSideMaxNumber[B]
// C-F 도 반복

이 때 유의할 점으로는 A-F, B-D, C-E가 짝을 이루게 되므로 어떤 숫자끼리 짝을 이루는지 미리 지정을 해주면 편하게 풀 수 있다.

전체 코드

import Foundation

let n = Int(readLine()!)!
var dp = Array(repeating: Array(repeating: 0, count: 7), count: n)

(0..<n).forEach { index in
    let dice = readLine()!.split(separator: " ").map{ Int(String($0))! }
    let pair = makePair(dice: dice)
    let maxNumber = makeMaxNumber(dice: dice, pair: pair)
    
    if index == 0 {
        dp[index] = maxNumber
    } else {
        (0...5).forEach {
            let diceNumber = dice[$0]
            guard let pairNumber = pair[diceNumber] else { return }
            dp[index][diceNumber] = dp[index-1][pairNumber] + maxNumber[diceNumber]
        }
    }
}
print(dp[n-1].max()!)

func makeMaxNumber(dice: [Int], pair: [Int: Int]) -> [Int] {
    let numbers = [1, 2, 3, 4, 5, 6]
    var maxNumber = Array(repeating: 0, count: 7)
    (0...5).forEach {
        let diceNumber = dice[$0]
        guard let pairNumber = pair[diceNumber],
              let tmpMaxNumber = numbers.filter({ $0 != diceNumber && $0 != pairNumber }).max()
        else { return }
        maxNumber[diceNumber] = tmpMaxNumber
    }
    return maxNumber
}

func makePair(dice: [Int]) -> Dictionary<Int, Int> {
    var dict = [Int: Int]()
    dict[dice[0]] = dice[5]
    dict[dice[5]] = dice[0]
    dict[dice[1]] = dice[3]
    dict[dice[3]] = dice[1]
    dict[dice[2]] = dice[4]
    dict[dice[4]] = dice[2]
    return dict
}

백준 18428 감시 피하기

2021-12-16T00:00:00+00:00

문제 보러 가기

N이 최대 6이기 때문에 브루트포스를 사용해야 함을 짐작할 수 있다. 모든 비어있는 공간에 대하여 3개의 Object를 배치시키고 모든 선생님들이 학생을 감시할 수 없는 경우가 하나라도 있는지 확인하면 된다. Object 3개를 배치하는 것은 순열을 통해 모든 경우를 확인해주면 된다.

전체 코드

import Foundation

let n = Int(readLine()!)!
var board: [[String]] = []
var empty: [(x: Int, y: Int)] = []
var teacher: [(x: Int, y: Int)] = []
var possibleCount = 0

(0..<n).forEach { yIndex in
    let line = readLine()!.split(separator: " ").map{ String($0) }
    (0..<n).forEach { xIndex in
        if line[xIndex] == "X" { empty.append((xIndex, yIndex)) }
        if line[xIndex] == "T" { teacher.append((xIndex, yIndex)) }
    }
    board.append(line)
}

empty.indices.forEach { index in makeObject(index: index, count: 0) }
print(possibleCount != 0 ? "YES" : "NO")

func findStudent(x: Int, y: Int) -> Bool {
    let dx = [1, -1, 0, 0]
    let dy = [0, 0, 1, -1]
    
    loop: for i in 0...3 {
        var nextX = x + dx[i]
        var nextY = y + dy[i]
        while (0..<n) ~= nextX && (0..<n) ~= nextY {
            switch board[nextY][nextX] {
            case "S":
                return true
            case "T", "O":
                continue loop
            default:
                break
            }
            nextX += dx[i]
            nextY += dy[i]
        }
    }
    return false
}

func makeObject(index: Int, count: Int) {
    if count == 3 {
        let result = teacher.map{ findStudent(x: $0.x, y: $0.y) }.contains(true)
        if !result { possibleCount += 1 }
        return
    }
    
    let position = empty[index]
    for i in index+1..<empty.count {
        board[position.y][position.x] = "O"
        makeObject(index: i, count: count + 1)
        board[position.y][position.x] = "X"
    }
}

백준 1194 달이 차오른다, 가자.

2021-12-13T00:00:00+00:00

문제 보러 가기

재미있었던 문제, 일반적인 BFS 문제에 비트마스크를 섞은 문제이다. 메모리 제한이 꽤 제한적인 편이여서 메모리적으로 고려를 하면서 풀면 좋다.

방식은 A-F 까지의 키를 각각 1, 2, 4, 8, 16, 32에 대응시킨 뒤 해당 키를 비트마스크 연산으로 관리해주는 문제이다. 이 때 비트마스크 연산을 이용한다면 A-F까지의 키를 단순히 Int값 0부터 63으로 관리할 수 있게된다. 예를들어 Key = 63이면 A-F의 키를 모두 들고있는 셈이 된다. 또 Key = 33이면 A키와 F키만 들고있다는 의미가 된다.

먼저 미로를 단순히 NxM 한개만 존재하는 것이 아니라 Key값에 따라 개별적인 미로를 갖는다고 생각하자. 예를들어 Key 0일때 통과했던 곳이여도 Key값이 바뀌면 통과한적이 없는것과 마찬가지로 보는 것이다. 따라서 NxMx64의 방문여부 Check 배열이 존재하게 된다. 그 후 BFS를 이용하여 방문하지 않은 곳일 경우 Queue에 추가해주면서 출구를 찾을때까지 혹은 Queue가 끝날때까지 반복해주면 된다.

이 때 메모리적으로 조건이 있기 때문에 Queue에 추가하기전에 출구 여부를 판단해서 출구를 찾을 경우 더이상 작업을 하지 않도록 관리해준다. 또한 동일한 위치를 동일한 키로 방문하는 경우를 중복해서 Queue에 추가하는 일이 없도록 Queue에 새로운 위치를 추가하게 되면 해당 위치&Key에 해당하는 Check 배열을 항상 True로 만들어주자.

또한 시간적 조건을 통과하기 위해서 Queue.removeFirst()를 사용하지 말고 Queue에 계속 추가하면서 index를 관리해주는 방식으로 접근하는 것이 좋다. (필자는 처음에 removeFirst를 써서 시간초과가 났다…)

전체 코드

//
//  main.swift
//  baekjoon
//
//  Created by 강현준 on 2021/12/13.
//

import Foundation

enum Key: Int {
    case a, b, c, d, e, f
    
    static func bitmaskKey(of key: Character) -> Int {
        switch key {
        case "a": return 1
        case "b": return 2
        case "c": return 4
        case "d": return 8
        case "e": return 16
        case "f": return 32
        default: return 0
        }
    }
    
    static func isPassable(road: Character, key: Int) -> Bool {
        switch road {
        case "A": return key&1 == 1
        case "B": return key&2 == 2
        case "C": return key&4 == 4
        case "D": return key&8 == 8
        case "E": return key&16 == 16
        case "F": return key&32 == 32
        case "#": return false
        default: return true
        }
    }
}

let nm = readLine()!.split(separator: " ").map { Int(String($0))! }
let n = nm[0]
let m = nm[1]
var board: [[Character]] = []
var startX = -1
var startY = -1

(0..<n).forEach { _ in board.append(readLine()!.map { Character(String($0)) }) }
loop: for i in 0..<n {
    for j in 0..<m {
        if board[i][j] == "0" {
            startX = j
            startY = i
            break loop
        }
    }
}

let dx = [-1, 1, 0, 0]
let dy = [0, 0, -1, 1]
var boardChecker = Array(repeating: Array(repeating: Array(repeating: false, count: m), count: n), count: 64)
var queue = [(y: Int, x: Int, key: Int)]()
queue.append((startY, startX, 0))
boardChecker[0][startY][startX] = true

var index = 0
var result = 0
var flag = false
loop: while index < queue.count {
    result += 1
    for k in index..<queue.count {
        let position = queue[k]
        for i in 0...3 {
            let nextY = position.y + dy[i]
            let nextX = position.x + dx[i]
            if (0..<n) ~= nextY && (0..<m) ~= nextX && !boardChecker[position.key][nextY][nextX] &&
                Key.isPassable(road: board[nextY][nextX], key: position.key) {
                
                if board[nextY][nextX] == "1" {
                    flag = true
                    break loop
                }
                let newKey = position.key|Key.bitmaskKey(of: board[nextY][nextX])
                boardChecker[newKey][nextY][nextX] = true
                queue.append((nextY, nextX, newKey))
            }
        }
        index += 1
    }
}
print(flag ? result : -1)

백준 1933 스카이라인

2021-11-17T00:00:00+00:00

문제 보러 가기

다양한 풀이방법이 있겠지만 스위핑과 maxHeap을 활용한 해법으로 풀었다. 개인적으로 정말 어려웠던 문제이다…

먼저 모든 빌딩을 시작지점과 끝 지점을 구분지은뒤 (start, end, height) 형태로 배열에 저장한다.
- 시작 지점이라면 start로 빌딩 시작 지점을 end로 해당 빌딩의 끝 지점을 입력해준다.
- 끝 지점이라면 start = end = 빌딩 끝 지점으로 입력하여 start와 end만으로 시작 선분인지 끝 선분인지 알 수 있게 해준다.
다음과 같은 규칙으로 모든 선분을 정렬해준다.
1. x 좌표가 낮은 것이 먼저오도록
2. 만약 x좌표가 같다면 시작 선분이 끝 선분보다 먼저오도록
3. 만약 x좌표도 같고 선분 종류도 같다면 시작선분일 경우 높이가 높은 것이 먼저, 끝 선분일 경우 높이가 낮은 것이 먼저오게한다.

이제 정렬된 배열을 앞에서부터 쭉 스위핑하면서 문제를 해결한다.
- Start 지점일 경우
  - 현재의 skyline 최고 높이보다 더 높을 경우 최고 높이를 업데이트 해주고 최종 결과에 해당 위치와 높이를 추가해준다.
  - 어떤 경우든 시작 지점이 나타나면 MaxHeap에 추가해준다. (다음그림과 같이 시작 높이가 MaxHeap root보다 작더라도 후에 쓰일 수 있다.)
  - 앞에서 동일한 위치에서 Start지점일 경우 높이가 큰 것이 먼저오게 한 이유도 작은 높이는 최종 결과에 반영하지 않기 위해서이다.
- End 지점일 경우
  - MaxHeap에 존재하는 최댓값을 하나씩 빼면서 만약 End지점의 x좌표보다 작거나 같은 값이라면 Heap에서 제거해준다.
  - 최종적으로 Heap이 비었다면 skyline을 0으로 Heap에 값이 남아있다면 그것이 현재 X축에서 가장 높은 빌딩의 높이가 될 것이기 때문에 해당 값으로 skyline을 업데이트 해준다. 그 후 해당 지점과 skyline 높이를 최종 결과에 반영한다.
  - 이 때 skyline값이 이전과 동일해서 변하지 않았다면 최종결과에 반영하지 않는다 (높이가 변하지 않았으므로)
전체 코드

//
//  Created by 강현준 on 2021/11/17.
//

let INF = Int.max
let n = Int(readLine()!)!
var building: [(start: Int, end: Int, height: Int)] = []

(0..<n).forEach { index in
    let line = readLine()!.split(separator: " ").map { Int($0)! }
    building.append((line[0], line[2], line[1]))
    building.append((line[2], line[2], line[1]))
}

building.sort(by: {
    let firstFlag = $0.start == $0.end
    let secondFlag = $1.start == $1.end
    if $0.start != $1.start { return $0.start < $1.start }
    if firstFlag != secondFlag { return !firstFlag }
    return firstFlag ? $0.height < $1.height : $0.height > $1.height
})

var skyline = 0
var heap = MaxHeap<(end: Int, height:Int)>(compare: { $0.1 < $1.1 })
var result = ""

building.forEach { line in
    if line.start != line.end {
        if skyline < line.height {
            skyline = line.height
            result += "\(line.start) \(line.height) "
        }
        heap.insert((line.end, line.height))
    } else {
        while heap.root?.end ?? INF <= line.end { heap.pop() }
        if skyline != heap.root?.height ?? 0 {
            skyline = heap.root?.height ?? 0
            result += "\(line.end) \(skyline) "
        }
    }
}
print(result)


struct MaxHeap<T> {
    var arr = [T]()
    var compare: (T, T) -> Bool
    
    var root: T? {
        return arr.count == 0 ? nil : arr[0]
    }
    
    init(compare: @escaping (T, T) -> Bool) {
        self.compare = compare
    }
    
    mutating func shiftUp(_ index: Int) {
        var child = index
        var parent = (child-1)/2
        while child > 0 {
            if compare(arr[parent], arr[child]) {
                arr.swapAt(parent, child)
                child = parent
                parent = (child-1)/2
            } else {
                break
            }
        }
    }
    
    mutating func shiftDown(_ index: Int) {
        var parent = index
        var child = parent*2+1
        while child < arr.count {
            if child+1 < arr.count && compare(arr[child], arr[child+1]) {
                child += 1
            }
            if compare(arr[parent], arr[child]) {
                arr.swapAt(child, parent)
                parent = child
                child = parent*2+1
            } else {
                break
            }
        }
    }
    
    mutating func pop() -> T? {
        if arr.isEmpty { return nil }
        arr.swapAt(0, arr.count-1)
        let result = arr.popLast()
        shiftDown(0)
        return result
    }
    
    mutating func insert(_ element: T) {
        arr.append(element)
        shiftUp(arr.count-1)
    }
}

백준 1208 부분수열의 합 2

2021-11-10T00:00:00+00:00

문제 보러 가기

이분탐색이 응용되는 문제이다. 완전 탐색으로 2^N안에 해결할 수 있지만 이렇게 될 경우 N = 40이기 때문에 시간 초과가 발생하게 된다.

먼저 좌측과 우측으로 구역을 나눠서 각각에 대해 완전 탐색을 시행해준다. 이렇게만 해도 2^40 -> 2^21로 크게 시간을 단축할 수 있다. 그 후 우측 구역을 오름차순으로 정렬해주자.
좌측 영역에 대한 부분수열의 합 중에서 하나를 선택하고 이를 LeftSum 이라고 해보자. 우측 영역에 대한 부분수열의 합 중에서 RightSum = S-LeftSum이 되는 RightSum의 갯수를 찾아주면 전체 영역의 부분 수열 중에서 합이 S인 부분수열을 찾는 것과 같다. 이를 모든 LeftSum에 대해서 반복 시행해주면 전체 경우의 수를 찾을 수 있다.
한가지 유의할 점으로 S가 0일 경우 좌측도 아무것도 선택하지 않고 우측도 아무것도 선택하지 않는 경우가 포함되게 된다. 원소가 존재하지 않을 경우 부분수열이라고 부르지 못하기 때문에 S가 0이면 최종결과에서 1을 빼주면 된다.

전체 코드

//
//  main.swift
//  testttt
//
//  Created by 강현준 on 2021/11/09.
//

import Foundation

let ns = readLine()!.split(separator: " ").map { Int($0)! }
let arr = readLine()!.split(separator: " ").map { Int($0)! }
let n = ns[0], s = ns[1]
var left = [Int]()
var right = [Int]()
var result = 0

comb(index: 0, last: n/2, sum: 0, result: &left)
comb(index: n/2, last: n, sum: 0, result: &right)

right.sort(by: { $0 < $1 })
left.forEach {
    let l = lowerBound(start: 0, end: right.count, val: s-$0, arr: right)
    let r = upperBound(start: 0, end: right.count, val: s-$0, arr: right)
    result += (r-l)
}
if s == 0 { result -= 1 }
print(result)

func comb(index: Int, last: Int, sum: Int, result: inout [Int]) {
    if index == last {
        result.append(sum)
        return
    }
    
    comb(index: index+1, last: last, sum: sum+arr[index], result: &result)
    comb(index: index+1, last: last, sum: sum, result: &result)
}

func lowerBound(start: Int, end: Int, val: Int, arr: [Int]) -> Int {
    if start >= end { return end }
    
    let mid = (start+end)/2
    if arr[mid] >= val { return lowerBound(start: start, end: mid, val: val, arr: arr) }
    else { return lowerBound(start: mid+1, end: end, val: val, arr: arr) }
}

func upperBound(start: Int, end: Int, val: Int, arr: [Int]) -> Int {
    if start >= end { return end }
    
    let mid = (start+end)/2
    if arr[mid] > val { return upperBound(start: start, end: mid, val: val, arr: arr) }
    else { return upperBound(start: mid+1, end: end, val: val, arr: arr) }
}

백준 2339 석판 자르기

2021-11-09T00:00:00+00:00

문제 보러 가기

분할정복의 일종으로 불순물이 있는 곳을 중점으로 자른 후 양쪽으로 구역이 나뉘었을 때 좌측/우측의 경우의 수를 구해 곱해주면 해결할 수 있다.

이 때 문제의 조건이 몇가지 존재한다.

항상 첫번째 자른 방향과 다른 방향으로 다음번에 잘라야한다.
불순물을 기준으로 자를때 해당 선분에 보석이 존재해서는 안된다. 이 때 다른 불순물이 존재하는 것은 상관없다.
최종적으로 나뉘어진 각각의 조각에는 보석이 1개씩 존재해야한다. 없어서는 안된다.

따라서 우리는 분할정복을 하는 함수를 구현할 때 Board상에서 범위의 최솟값과 최댓값을 받아야하고 수직으로 잘라야하는지 수평으로 잘라야하는지 여부를 같이 받아야한다. 만약 min값이 max값보다 큰 경우가 존재할 경우 해당 영역은 존재하지 않기 때문에 1을 return해주어 경우의수를 구하는데 오류가 생기지 않도록 해준다.

그 후 다음과 같이 영역의 조건을 확인해주고 필요한 경우 분할정복을 다시 적용하여 경우의 수를 계산해주자. 최종적으로 전체 범위에 대해 수직, 수평 각각에 대해서 적용한 것을 더해주면 모든 경우의 수를 구할 수 있다.

보석 1개만 존재 -> 성공 (return 1)
보석 0개 혹은 보석 2개 이상 && 불순물 0 -> 실패 (return 0)
그 외 경우 (다시 분할정복 적용)

전체 코드

//
//  main.swift
//  testttt
//
//  Created by 강현준 on 2021/11/09.
//

import Foundation

let n = Int(readLine()!)!
var board: [[Int]] = []

(0..<n).forEach { _ in
    let line = readLine()!.split(separator: " ").map { Int($0)! }
    board.append(line)
}

let vertical = calc(min: (0, 0), max: (n-1, n-1), isVertical: true)
let horizontal = calc(min: (0, 0), max: (n-1, n-1), isVertical: false)
print((vertical + horizontal > 0) ? vertical + horizontal : -1)


func calc(min: (Int, Int), max: (Int, Int), isVertical: Bool) -> Int {
    if min.0 > max.0 || min.1 > max.1 { return 1 }
    
    var goods: [(Int, Int)] = []
    var bads: [(Int, Int)] = []
    
    for i in min.0...max.0 {
        for j in min.1...max.1 {
            if board[i][j] == 2 { goods.append((i, j)) }
            if board[i][j] == 1 { bads.append((i, j)) }
        }
    }
    
    if goods.count == 1 && bads.count == 0 {
        return 1
    } else if goods.count == 0 || (goods.count > 1 && bads.count == 0) {
        return 0
    } else {
        var result = 0
        bads.forEach { bad in
            guard !goods.contains(where: { good in isVertical ? bad.0 == good.0 : bad.1 == good.1 }) 
            else { return }

            let left = calc(
              min: min, 
              max: isVertical ? (bad.0-1, max.1) : (max.0, bad.1-1), 
              isVertical: !isVertical
            )
            let right = calc(
              min: isVertical ? (bad.0+1, min.1) : (min.0, bad.1+1), 
              max: max, 
              isVertical: !isVertical
            )
            result += left*right
        }
        return result
    }
}

SwiftUI Lecture7-8 정리

2021-07-08T00:00:00+00:00

이번 강의에서는 Animation에 대해서 공부를 진행했다. 실제 앱을 이용하다보면 카드가 이동한다던지 카드의 그림이 회전한다던지 하는 경우가 있다. 이는 모두 Animation 효과를 사용해서 진행하는 것으로 iOS에서는 자체적으로 animation 기능을 제공한다.

1. ViewModifier

Animation에 대해 학습하기 전에 ViewModifier에 대해 먼저 알아보고 넘어가자. .font, .backGroundColor 와 같이 View의 속성을 조정해주는 함수들을 기억할 것이다. ViewModifier는 이러한 행위를 하게 해주는 프로토콜의 일종으로 View에게 특정한 행위를 해주고자 할 때 사용한다.

struct Cardify: ViewModifier {
		var isFaceUp: Bool
  	func body(content: Content) -> some View {
  			if isFaceUp {
      			content.font(.largeTitle)
    		} else {
      			content.font(.title)
    		}
  	}
}
Text("👻").modifier(Cardify(isFaceUp: true))

View struct를 만드는 것과 비슷하게 작성하면 되며 var body가 아닌 func body를 만드는 것을 유의하자. 이 때 content라는 변수가 사용되는데 이는 input으로 받는 view를 의미하며 그 view가 어떤 것이던지 body 함수 내부의 행위를 적용시켜준다. ViewModifier에서는 isFaceUp과 같은 argument가 매우 중요한데 왜냐하면 이 값이 변할때마다 애니메이션을 작동시킬 수 있기 때문이다.

만약 .modifier() 와 같은 형태로 사용하고 싶지 않고 다른 font와 같은 modifier 처럼 사용하고 싶다면 다음과 같이 정의를 해주면 된다.

extension View {
    func cardify(isFaceUp: Bool) -> some View {
        return self.modifier(Cardify(isFaceUp: isFaceUp))
    }
}
Text("👻").cardify(isFaceUp: true)

참고로 모든 ViewModifier가 animatable 하지는 않다. 예를들어 font는 animatable하지 않다. ViewModifier가 animatable 하다는 것을 나타내고 싶을 때는 var animatableData: Type(Dont care) 를 사용해줘야한다. 이것은 해당 변수가 변할 때 선형적으로 변하도록 하겠다는 의미이다. animatableData는 VectoArithmetic 해야하며 AnimatablePair를 가질수도있다. 이를 적용해서 Cardify ViewModifier Struct를 다시한번 보면 다음과 같다. 만약 변화하는 animatableData가 한개라면 AnimatableModifier로 선언해주고 두개라면 AnimatablePair<Type, Type>로 선언해주자.

struct Cardify: AnimatableModifier {
    init(isFaceUp: Bool) {
        rotation = isFaceUp ? 0 : 180
    }
    
    var animatableData: Double {
        get { rotation }
        set { rotation = newValue }
    }
    
    var rotation: Double // in degrees
    func body(content: Content) -> some View {
        ZStack {
            let shape = RoundedRectangle(cornerRadius: DrawingConstants.cornerRadius)
            if rotation < 90 {
                shape.fill().foregroundColor(.white)
                shape.strokeBorder(lineWidth: DrawingConstants.lineWidth)
            } else {
                shape.fill()
            }
            content
                .opacity(rotation < 90 ? 1 : 0)
        }
        .rotation3DEffect(Angle.degrees(rotation), axis: (0, 1, 0))
    }
}

2. Animation

자 이제 애니메이션에 대해서 알아보자. 애니메이션은 ViewModifier나 Shape를 이용해서 적용이 가능하고 무언가 변수가 변하거나 View의 등장과 소멸에 대해서 애니메이션이 동작한다. 이 때 View에 대한 애니메이션은 해당 View가 UI에 들어간 후에만 일어날 수 있다는 것을 명심하자. 특정 View의 등장과 소멸에 대한 애니메이션을 사용하고 싶다면 해당 View를 감싸는 Container가 이미 UI에 존재해 있어야 한다.

애니메이션은 크게 3가지의 애니메이션으로 구분된다. Implicitly, explicitly, transition이 그에 해당한다.

Implicitly

일명 automatical animation으로도 불리는 이 녀석은 설정을 해주면 해당 view에 대해 어떤 argument가 변하면 자동적으로 애니메이션이 적용되는 형태이다. .animation(Animation)의 형태로 사용할 수 있다.
```
Text("👻")
    .opacity(scary ? 1 : 0)
    .rotationEffect(Angle.degrees(upsideDown ? 180 : 0))
    .animation(Animation.eraseInOut)
```
위와 같이 설정을 해주면 scary 변수와 upsideDown 변수가 변할때마다 투명도가 변한다던지 빙글빙글 도는 애니메이션이 자동으로 설정되는 형태이다. 이 때 .animation은 본인 이전에 선언된 ViewModifier에 대해서만 해당 animation 속성을 적용시킨다.

Animation struct는 여러가지 animation의 속성을 설정할 수 있다. duration, delay, repeat등이 이에 해당한다. 또한 animation curve 속성을 설정할 수 있는데 이는 애니메이션이 동작하는 속도 템포를 조절하는 역할을 한다. .linear 는 균일하게, .eraseInOut은 처음과 끝을 느리게, .spring은 끝날때 살짝 스프링처럼 흔들리도록 하는 역할을 한다.
Explicitly

Implicitly는 View에 선언된 모든 argument가 변할때마다 자동으로 적용이 되었다면 Explicitly는 내가 원하는 동작을 수행할 때 변하는 argument에게만 animation을 주겠다는 것이다. 사용법으로는 withAnimation(Animation) { } 의 형태를 사용하며 대괄호 내부에 원하는 함수들을 정의해주면 된다. 마찬가지로 Animation struct에는 여러가지 속성을 설정할 수 있다.
```
withAnimation(.linear(duration: 2)) {
    //do somthing that will cause ViewModifier/Shape arguments to change somewhere
}
```
Transition

View가 생성되고 삭제될때 수행할 애니메이션에 대해 설정해 줄 수 있다. 예를들어 등장할때는 점점 투명도가 변해서 등장하고 삭제될 때는 크기가 점점 줄어들어 삭제되게 한다던지 설정을 해줄 수 있다. 이 때 Transition은 CTAAOS (Containers That Are Already On-Screen) 안에 있는 View에 대해서만 동작한다. 형태로는 .transition(AnyTransition) 의 형태로 AnyTransition struct 내부에 pre-canned transition 목록들이 정의되어 있다.
```
CardView(card: $0)
		.matchedGeometryEffect(id: $0.id, in: dealingNamespace)
		.transition(.asymmetric(insertion: .identity, removal: .scale))
		.zIndex(zIndex(of: $0)) // zIndex(Double) 속성을 설정해주어 겹쳤을 떄 어떤 View가 위로갈지 정해줌
```
유의할 점으로는 transition은 단순히 등장과 삭제할때 발생할 애니메이션을 정의해주었을 뿐 실제로 애니메이션이 작동하지는 않는다. 따라서 Implicitly Animation이나 Explicitly Animation을 이용해서 발동시켜야한다.

Transition은 외부 Container에 적용하면 Container 전체가 생성되고 삭제될 때 적용이 되는 형태이다. 내부의 View들에게 그 정보를 넘겨주지 않는다. 약간 Padding과 비슷하다고 생각하면 된다. 하지만 Implicitly Animation은 외부 Container에 선언을 하면 내부의 모든 View들에게 각각 적용이 된다. 마치 backGroundColor를 외부 컨테이너에 선언하면 내부 모든 View들에게 적용되는 것처럼 말이다.

3. matchedGeometyEffect

만약 특정 container에서 다른 container로 View를 옮겨가고 싶다면 어떻게 해야할까? 아쉽게도 애니메이션 자체적으로는 해당 기능을 수행할 수 없다. 이를 위해 존재하는 기능이 바로 .matchedGeometryEffect(id: ID, in: Namespace)와 같은 형태로 사용한다. 사용하고 싶은 두 container에 대해서 모두 선언을 해주면 하나의 container에서 다른 container로 이동하는 것과 같은 animation 효과를 얻을 수 있다.

여기서 id는 우리가 view에 사용하는 id에 해당하고 namespace는 동일한 id를 갖는다해도 여러 컨테이너에 존재할 수 있기 때문에 어떤 컨테이너에서 어떤 컨테이너로 갈 것인지를 매칭시켜주기 위해 사용한다. @Namespace private var dealingNamespace 와 같이 상위 view struct에 선언해주고 사용하면 된다.

    var gameBody: some View {
        AspectVGrid(items: game.cards, aspectRatio: CardConstants.aspectRatio) { card in
            if isUndealt(card) || (card.isMatched && !card.isFaceUp) {
                Color.clear
            } else {
                CardView(card: card)
                    .matchedGeometryEffect(id: card.id, in: dealingNamespace)
                    .padding(4)
                    .transition(.asymmetric(insertion: .identity, removal: .scale))
                    .zIndex(zIndex(of: card))
                    .onTapGesture {
                        withAnimation {
                            game.choose(card)
                        }
                    }
            }
        }
        .foregroundColor(CardConstants.color)
    }
    
    var deckBody: some View {
        ZStack {
            ForEach(game.cards.filter(isUndealt)) {
                CardView(card: $0)
                    .matchedGeometryEffect(id: $0.id, in: dealingNamespace)
                    .transition(.asymmetric(insertion: .identity, removal: .scale))
                    .zIndex(zIndex(of: $0))
            }
        }
        .frame(width: CardConstants.undealtWidth, height: CardConstants.undealtHeight)
        .foregroundColor(CardConstants.color)
        .onTapGesture {
            for card in game.cards {
                withAnimation(dealAnimation(for: card)) {
                    deal(card)
                }
            }
        }
    }

위의 코드를 보면 deckBody에서 사라지고 gameBody로 Card가 생성될 때 마치 카드가 이동하는 것처럼 효과를 줄 수 있다.

SwiftUI Lecture5-6 정리

2021-07-05T00:00:00+00:00

이번 강의에서는 주로 layout에 대해서 배웠다. 먼저 layout이 그려지는 방식은 다음을 따른다.

가능한 공간이 주어진다.
각 내부 view들 별로 본인의 사이즈를 결정한다.
컨테이너 뷰에서 각 내부 view들에게 공간을 할당한다.
컨테이너 뷰 역시 다른 컨테이너 뷰 속에 들어있을 수 있기 때문에 1-3 반복

이때 각 view별로 공간을 할당하는 방식이 조금씩 다르다. 이를 알아보도록 하자.

1. HStack & VStack

least felxible view를 먼저 공간 할당을 하는 방식으로 동작한다. 그 후 가능한 공간을 줄인다. 예시로 flexible 정도를 나타내면 다음과 같다.

infelxible : Image
slightly more flexible : Text
very flexible : RoundedRectangle

생각해보면 RoundedRectangle의 경우 남아있는 모든 공간을 차지한다는 것을 기억할 것이다. 만약 very flexible view가 포함될 경우 그 stack은 마찬가지로 very flexible이 된다.

.layoutPriority(value)를 변경해주면 priority를 임의로 부여할 수 있다. 예를들어 Text View가 여러개 있을 때 특정 Text의 공간을 먼저 확보하도록 할 때 사용될 수 있다. 기본적으로 모두 0으로 설정되어있다.

2. LazyHStack & LazyVStack

visible 하지 않은 view는 draw하지 않는 lazy stack이다. 달리 얘기하자면 화면 상에 드러나지 않은 view들은 불러오지 않고 있다가 화면에서 등장하면 그 때 불러와서 view를 그리는 방식이다. 기존의 HStack과 VStack은 모든 원소를 불러왔지만 lazy는 늦게 불러온다는 점에서 차이가 있다.

view를 모두 화면에 띄우는 것이 아니기 때문에 일정하게 각각의 크기를 조정해줘야한다. 따라서 not flexible하다.

그 외에도 LazyHGrid, LazyVGrid는 최대한 적게 공간을 차지하도록 되어있다는 것을 기억하자. List & Form & OutlineGroup 이라는 것도 존재하는데 really smart VStack이라고 불린다. 이는 추후에 다시 다룰 예정이다.

3. GeometryReader View

우리는 View를 작성할 때 그 공간의 Size에 맞게 폰트 크기라던지 여러 설정들을 변경하고 싶을 수 있다. 그럴 때 사용하는 것이 GeometryReader View이다.

size에 대한 정보를 포함하고 있는 geometry라는 변수를 사용해서 그 size 정보를 이용해서 여러 요소들을 설정해준다. GeometryReader{} 라는 view 속에서 사용을 하면 된다. .size는 CGSize 타입으로 width와 height 정보를 포함하고 있다. 그 외에도 safe area를 알려주는 역할도 수행하는데 이는 노치와 같이 그리면 잘리는 영역을 빼고 그릴 수 있도록 도와준다.

이를 활용하여 우리의 CardView를 다시 그리면 다음과 같다. font 함수에서 geometry size 변수를 활용한 것을 볼 수 있다. 중간의 Pie 함수는 Pie모양 도형을 그려주는 함수로 추후에 다룰 예정이니 가볍게 이해하고 넘어가자.

struct CardView: View {
    let card: EmojiMemoryGame.Card
    
    var body: some View {
        GeometryReader { geometry in
            ZStack {
                let shape = RoundedRectangle(cornerRadius: DrawingConstants.cornerRadius)
                if card.isFaceUp {
                    shape.fill().foregroundColor(.white)
                    shape.strokeBorder(lineWidth: DrawingConstants.lineWidth)
                    Pie(startAngle: Angle(degrees: 270), endAngle: Angle(degrees: 20)).padding(5).opacity(0.5)
                    Text(card.content).font(font(in:geometry.size))
                } else {
                    shape.fill()
                }
            }
        }
    }
    
    private func font(in size: CGSize) -> Font {
        Font.system(size: min(size.width, size.height) * DrawingConstants.fontScale)
    }
    
    private struct DrawingConstants {
        static let cornerRadius: CGFloat = 10
        static let lineWidth: CGFloat = 3
        static let fontScale: CGFloat = 0.7
    }
}

여기서 한가지 포인트는 cornerRadius와 같은 특정 상수값들을 따로 빼서 DrawingConstants로 선언해서 사용하는 것을 확인할 수 있다. 이렇게 해주는 이유는 사용하는 기기 환경 등에서 따라서 값을 변경해야할 때 일괄적으로 처리하기 위함이다.

4. @ViewBuiler

만약 특정 상황에서는 카드 View를 보여주고싶고 특정 상황에서는 카드를 안보이게 하고싶다면 어떻게 해야할까? 가장 먼저 떠오르는 것이 if else를 활용하는 것이다. 하지만 실제로 if else를 body 내부에 표현하면 오류가 난다.

이 때 사용하는 것이 @ViewBuilder 속성이다. 이는 내부에 여러 View들이 나열될 수 있다는 것을 나타내주는 것으로 어떤 함수 앞에 이를 표시하면 해당 함수 내에서는 여러 View들의 list를 나타낼 수 있다.

이를 활용해서 우리의 EmojiMemoryGameView를 다시 표현하면 다음과 같다. AspectVGird라는 View를 이용해 CardView를 각각 그리려고 하는데 카드가 매치가 되었다면 해당 카드를 그리지 않고 안보이게 하도록 구현하였다. 이 때 cardView 함수 위에 @ViewBuilder 속성을 활용하여 if else 구문과 함께 여러 view들을 나열한 것을 확인하자.

struct EmojiMemoryGameView: View {
    @ObservedObject var game: EmojiMemoryGame
    var body: some View {
        AspectVGrid(items: game.cards, aspectRatio: 2/3) { card in
            cardView(for: card)
        }
        .foregroundColor(.red)
        .padding(.horizontal)
    }
    
    @ViewBuilder
    private func cardView(for card: EmojiMemoryGame.Card) -> some View {
        if card.isMatched && !card.isFaceUp {
            Rectangle().opacity(0)
        } else {
            CardView(card: card)
                .padding(4)
                .onTapGesture {
                    game.choose(card)
                }
        }
    }
}

이 때 AspectVGrid라는 것은 ScrollView를 쓰지 않으면 lazyVGrid를 그릴 때 카드의 갯수에 따라 화면 밖으로 잘리는 경우가 생길 것이다. 이를 방지하기 위해서 전체 화면에 모든 카드를 띄울 수 있는 grid의 width를 계산해서 그려주는 View 구조체를 만든 것이다.

5. AspectVGrid View

이를 코드로 나타내면 다음과 같다. 유의할 것은 Card라는 아이템을 여기서는 인풋으로 주지만 card를 그리는 것이 아닌 다른 것을 그릴 수도 있기 때문에 Item 과 ItemView라는 Generic Type을 활용한 것을 확인하자. 이 때 각각의 Item은 Identifiable해야하고 ItemView는 하나의 View여야 한다고 속성을 부여해주어야한다. 이제 우리는 item들의 Array와 그리는 비율, 각각의 item들을 View로 바꾸어주는 함수를 인풋으로 받아서 VGrid View를 그릴 것이다.

이 때 init함수에서 content라는 함수를 단순히 self.content = content하게 되면 에러가 발생한다. @escaping 속성을 부여해주지 않으면 에러가 발생하는데 인풋으로 받은 함수를 struct 내부에서 사용하고 싶다면 부여해줘야한다.

그 외에는 코드를 읽어보면 간단히 이해할 수 있다. 유의할 점으로는 Grid간의 spacing을 가로 세로 모두 0으로 설정해주어 격자 각각의 크기를 구하는데 spacing을 고려하지 않아도 되는 편의성을 주었다는 점이다. 대신 그 공간에 들어가는 Card View자체에 padding 속성을 부여해주어 카드간의 간격을 설정해주었다.

import SwiftUI

struct AspectVGrid<Item, ItemView>: View where ItemView: View, Item: Identifiable {
    var items: [Item]
    var aspectRatio: CGFloat
    var content: (Item) -> ItemView
    
    init(items: [Item], aspectRatio: CGFloat, @ViewBuilder content: @escaping (Item)  -> ItemView) {
        self.items = items
        self.aspectRatio = aspectRatio
        self.content = content
    }
    
    var body: some View {
        GeometryReader { geometry in
            VStack {
                let width: CGFloat = widthThatFits(itemCount: items.count, in: geometry.size, itemAspectRatio: aspectRatio)
                LazyVGrid(columns: [adaptiveGridItem(width: width)], spacing: 0) {
                    ForEach(items) {
                        content($0).aspectRatio(aspectRatio, contentMode: .fit)
                    }
                }
                Spacer(minLength: 0)
            }
        }
    }
    
    private func adaptiveGridItem(width: CGFloat) -> GridItem {
        var gridItem = GridItem(.adaptive(minimum: width))
        gridItem.spacing = 0
        return gridItem
    }
    
    private func widthThatFits(itemCount: Int, in size: CGSize, itemAspectRatio: CGFloat) -> CGFloat {
        var columnCount = 1
        var rowCount = itemCount
        repeat {
            let itemWidth = size.width/CGFloat(columnCount)
            let itemHeight = itemWidth/itemAspectRatio
            if CGFloat(rowCount)*itemHeight < size.height {
                break
            }
            columnCount += 1
            rowCount = (itemCount + (columnCount-1))/columnCount
        } while columnCount < itemCount
        if columnCount > itemCount {
            columnCount = itemCount
        }
        return floor(size.width/CGFloat(columnCount))
    }
}

6. Pie

View Struct를 직접 정의했듯이 Pie 라는 도형을 그리는 Struct도 직접 구현할 수 있다. 도형의 구조체는 속성이 Shape로 View에서는 body variable을 정의해줘야 했듯이 Shape 구조체는 path라는 함수를 구현해줘야한다.

path함수는 CGRect를 변수로 받아 Path라는 경로를 return하는 함수로 CGRect는 도형을 그리기 쉽도록 주어진 영역의 좌표 정보들을 저장해놓은 변수이다. midX, midY와 같은 정보를 통해 중심값을 찾을 수도 있고 width와 height를 알수도 있다.

Path()라는 p 변수에 addline과 같은 함수를 통해 도형을 그려주자. 유의할 점으로는 addArc를 할 때 clockwise의 inverse를 사용하는 것을 알 수 있다. 우리는 실제로 반시계방향으로 그림을 그리고 싶기 때문에 clockwise 변수를 false로 선언해주었다. 그러나 arc를 그릴 때는 clockwise: true를 사용하게 되는 것인데 실제 그림을 그릴 때는 y축이 아래에서 위로 뻗어나가는 것이 아닌 위에서 아래로 뻗어나가는 축을 기준으로 그림을 그린다. 따라서 우리가 평소에 생각하는 반시계 방향은 그림을 그리는 평면에서는 시계방향이 되는 것이다.

import SwiftUI

struct Pie: Shape {
    var startAngle: Angle
    var endAngle: Angle
    var clockwise: Bool = false
    
    func path(in rect: CGRect) -> Path {
        let center = CGPoint(x: rect.midX, y: rect.midY)
        let radius = min(rect.width, rect.height)/2
        let start = CGPoint(
            x: center.x + radius * CGFloat(cos(startAngle.radians)),
            y: center.y + radius * CGFloat(sin(startAngle.radians))
        )
        var p = Path()
        p.move(to: center)
        p.addLine(to: start)
        p.addArc(
            center: center,
            radius: radius,
            startAngle: startAngle,
            endAngle: endAngle,
            clockwise: !clockwise
        )
        p.addLine(to: center)
        return p
    }
}

SwiftUI Lecture3-4 정리

2021-06-30T00:00:00+00:00

MVVM(Model View ViewModel)

Model과 View, ViewModel로 나누는 방식을 MVVM 모델이라고 부른다. Data를 저장하고 그에 관련한 Logic을 포함하고 있는 Model, Data를 바탕으로 UI를 만들어주는 UI Architecture인 View, 마지막으로 둘 사이에서 징검다리처럼 연결을 해주는 ViewModel로 나뉘어지는 구조이다. 하나하나 나눠서 살펴보자.

1. Model

UI Independent한 형태로 Data와 그와 관련된 Logic으로 구성되어있다. 우리의 코드를 MVVM모델로 적용시키기 위해 만든 Model의 모습은 다음과 같다. 놀랍게도 UI Independent하기 때문에 import SwiftUI가 없는 것을 확인할 수 있다.

메모리 게임을 실행시키면 해당 게임의 카드 Set (Data) 을 저장해줘야하고 해당 카드를 클릭했을 때 카드의 속성이 변하는 것을 처리해주는 연산 함수 (Logic)가 포함되어있다. 실제로 choose함수를 보면 특정 카드를 눌렀을 때 처리할 연산이 함수형태로 구현되어있다. 놀랍게도 UI와는 전혀 무관하게 가지고 있는 card set만으로 동작한다. 우리는 어떤 카드가 선택되었는지 그 정보만 View로부터 받으면 되는 형태이다.

import Foundation

struct MemoryGame<CardContent> where CardContent: Equatable {
    private(set) var cards: Array<Card>
    private var indexOfTheOneAndOnlyFaceUpCard: Int?
    
    mutating func choose(_ card: Card) {
        if let chosenIndex = cards.firstIndex(where: { $0.id == card.id }),
           !cards[chosenIndex].isFaceUp,
           !cards[chosenIndex].isMatched {
            if let potentialMatchIndex = indexOfTheOneAndOnlyFaceUpCard {
                if cards[potentialMatchIndex].content == cards[chosenIndex].content {
                    cards[chosenIndex].isMatched = true
                    cards[potentialMatchIndex].isMatched = true
                }
                indexOfTheOneAndOnlyFaceUpCard = nil
            } else {
                for index in cards.indices {
                    cards[index].isFaceUp = false
                }
                indexOfTheOneAndOnlyFaceUpCard = chosenIndex
            }
            cards[chosenIndex].isFaceUp.toggle()
        }
    }
    
    init(numberOfPairsOfCards: Int, createCardContent: (Int) -> CardContent) {
        cards = Array<Card>()
        // add numberOfPairsOfCards x 2 to array
        for pairIndex in 0..<numberOfPairsOfCards {
            let content = createCardContent(pairIndex)
            cards.append(Card(content: content, id: pairIndex*2))
            cards.append(Card(content: content, id: pairIndex*2+1))
        }
    }
    
    struct Card: Identifiable {
        var isFaceUp: Bool = false
        var isMatched: Bool = false
        var content: CardContent
        var id: Int
    }
}

구현자체는 간단하니 조금만 읽어보면 알 수 있다. Model에서 중요한 포인트가 몇가지 있는데 이를 알아보고 넘어가려고 한다.

Generic Type

스위프트에서는 나중에 타입을 매칭시켜주는 generic type 선언이 존재한다. <CardContent>가 이에 해당하는데 우리가 카드의 이미지로 사용하는 값이 현재는 emoji String이지만 설정에 따라 JPEG가 될 수도 있고 다양할 것이다. 이는 ViewModel에 맡기고 Model에서는 Logic구현에 좀 더 신경을 써주는 모습이다.
Identifiable

struct Card: Identifiable로 표현이 되어있는 것을 Card 구조체에서 확인이 가능하다. 우리가 View에서 각각의 카드를 하나의 View로 표현하기 위해서는 id가 존재해야 했다는 것을 기억할 것이다. 따라서 Card 구조체는 Identifiable하다고 선언해주고 구조체 내부에 이를 구분지어주는 id를 설정해주는 형태이다. id는 꼭 Int가 아니여도 Hashable하다면 다른 형태를 사용해도 무방하다.
Read Only

private(set) var cards: Array<Card> 로 표현된 부분을 볼 수 있다. 이 것이 우리의 Data인 Card Set을 저장해주는 배열이다. 각각의 Card들은 뒤집혀있는지, 매치가 완료되었는지, 그림 정보는 무엇인지, id는 무엇인지를 저장해주고 있다. 후에 View에서는 카드들의 해당 정보를 ViewModel을 통해 읽어와서 이를 바탕으로 UI를 그린다.

그런데 해당 배열을 private으로 선언을 한다면 다른 곳에서 읽어오는 것이 불편해질 것이다. 그렇다고 public으로 선언을 하면 view에서 값을 변경해버리는 위험이 존재하기 때문에 read only 형태인 private(set) 을 사용한다.

2. ViewModel

Model과 View의 징검다리 역할을 하는 ViewModel이다. Interpreter, GateKeeper의 성질을 지니고 있다. View에서 UI를 그리려고 한다면 다음의 방식을 따른다.

Model의 Card 정보를 알기 위해 ViewModel의 cards 변수를 호출
ViewModel은 Model의 cards 변수를 호출
얻어낸 Model의 cards를 통해 UI를 그림

마찬가지로 View에서 특정 카드를 선택하는 등 변화가 생긴다면 다음의 방식을 따른다.

ViewModel의 Logic 함수를 호출
ViewModel은 Model의 Logic 함수를 호출
Model에서 Logic을 통해 Data 정보를 변경
변경된 정보가 존재하므로 Model이 다시 UI를 그리라고 ViewModel에게 요청
ViewModel은 View에게 UI를 다시 그리라고 요청
위의 UI 그리는 방식을 다시 반복하여 새로운 UI 작성

이렇듯 Model과 View는 직접 소통할 수 없고 ViewModel이 중간에서 연결시켜주는 형태로 되어있다는 것이다. Model이 정의가 되어있다면 해당 Model을 사용하면 되지만 우리의 경우는 Model을 직접 생성해주는 형태로 되어있다. 유의할 것은 해당 모델은 private으로 선언해서 View에서 직접 Model을 불러오는 일이 없도록 해야한다는 것이다.

import SwiftUI

class EmojiMemoryGame: ObservableObject {
    static let emojis = ["🚖", "🛵", "🚆", "🚍", "🛺", "🛫", "🏖", "🚔", "🛸", "🚁", "🏍", "🛳", "🚐", "🚛", "🚚"]
    
    static func createMemoryGame() -> MemoryGame<String> {
        MemoryGame<String>(numberOfPairsOfCards: 3) { pairIndex in
            emojis[pairIndex]
        }
    }
    
    @Published private var model: MemoryGame<String> = createMemoryGame()
    
    var cards: Array<MemoryGame<String>.Card> {
        model.cards
    }
    
    // MARK: - Intent(s)
    
    func choose(_ card: MemoryGame<String>.Card) {
        //objectWillChange.send()
        model.choose(card)
    }
}

그런데 Model의 Data가 변경되었을 때 다시 UI를 그리도록 요청하기 위해서는 몇가지 수정이 필요하다. 바로 Observe 속성을 설정해주는 것인데 이는 해당 Model을 보고있다가 변화가 생긴다면 자동으로 View에게 다시 UI를 그리라고 요청해주는 역할을 한다. 이를 사용하기 위해서는 2가지 방식이 존재한다.

먼저 class EmojiMemoryGame: ObservableObject와 같이 ObservableObject로 ViewModel을 선언해주어야한다. 그리고 나중에 View Struct 안에서 ViewModel을 선언해줄 때 @ObservedObject var viewModel: EmojiMemoryGame 형태로 @ObservedObject임을 명시해줘야한다. 이는 해당 ViewModel을 지속적으로 관찰해서 요청이 들어오면 UI Update를 하겠다는 의미이다.

두번째로는 Model에서 요청이 들어왔을 때 이를 ViewModel이 감시해야한다는 것인데 Model 자체를 @Published로 선언해서 변화가 생길 때마다 UI를 새로 그리도록 할 수도 있고 choose function의 objectWillChange.send()를 통해서 필요할 때 Update를 하도록 직접 명시해줄 수도 있다.

3. View

마지막 파트인 View이다. View에는 되도록 @State선언과 같이 데이터를 직접 조작하는 일이 없도록 구현해주는 것이 좋다. 모든 정보는 Model에 저장되어 있는 정보를 ViewModel을 통해 호출하는 형식으로 구현한다. 위에서 봤듯이 @ObservedObject로 ViewModel을 선언해주는 것을 잊지말자.

import SwiftUI

struct ContentView: View {
    @ObservedObject var viewModel: EmojiMemoryGame
    var body: some View {
        ScrollView {
            LazyVGrid(columns: [GridItem(.adaptive(minimum: 65))]) {
                ForEach(viewModel.cards){ card in
                    CardView(card: card)
                        .aspectRatio(2/3, contentMode: .fit)
                        .onTapGesture {
                            viewModel.choose(card)
                        }
                }
            }
        }
        .foregroundColor(.red)
        .padding(.horizontal)
    }
}



struct CardView: View {
    let card: MemoryGame<String>.Card
    var body: some View {
        ZStack {
            let shape = RoundedRectangle(cornerRadius: 20.0)
            if card.isFaceUp {
                shape.fill().foregroundColor(.white)
                shape.strokeBorder(lineWidth: 3.0)
                Text(card.content).font(.largeTitle)
            } else if card.isMatched {
                shape.opacity(0)
            } else {
                shape.fill()
            }
        }
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        let game = EmojiMemoryGame()
        ContentView(viewModel: game)
            .preferredColorScheme(.dark)
        ContentView(viewModel: game)
            .preferredColorScheme(.light)
    }
}

SwiftUI Lecture1-2 정리

2021-06-25T00:00:00+00:00

SwftUI Lecture는 Stanford 대학 Youtube 채널의 CS193p - Developing Apps for iOS 온라인 강의를 보고 정리.

swiftUI는 Xcode에서 제작해볼 수 있는 ios app 제작 도구이다.

import SwiftUI

struct ContentView: View {
    var body: some View {
        Text("Hello, world!")
            .padding()
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

기본적인 셋팅을 마치고 처음 프로젝트를 열게되면 위와 같은 코드가 등장한다. ContenView_Previews 는 Preview 영역에 어떤 View를 띄울지 정해주는 구조체이고 중요한 것은 위에 있는 ContentView 구조체이다.

기본적으로 SwiftUI는 View라는 속성을 지닌 구조체를 사용한다. 그리고 내부에 body라는 변수를 꼭 지정해줘야한다. 여기서 신기하게도 some View라는 단어를 볼 수 있는데 이는 View의 일종이 여러개 올 수 있다는 의미이다. 다음과 같이 body를 Text로 선언하면 안되는지 궁금할 수도 있는데 지금 상태에서는 충분히 가능하다.

struct ContentView: View {
    var body: Text {
        Text("Hello, world!")
    }
}

그러나 padding이라는 modify가 추가되면 Text라는 구조체가 아니게 된다. 이처럼 여러 복합적인 View들을 섞어쓰는 가능성을 대비해서 some View라는 형태로 타입 선언을 해준다. 참고로 Text 구조체 역시 View의 일종이다.

struct ContentView: View {
    var body: Text {
        Text("Hello, world!")
      			.padding()
    }
}

자 이제 간단한 텍스트가 아닌 카드의 형태로 View를 구성하고 싶다. 이 때 하나 이상의 View를 통합해서 화면에 표시하고 싶다면 View를 통합해주는 어떤 복합체를 사용해야 한다. 사용할 수 있는 View 복합체들은 여러개가 존재한다. 여기서는 5개의 복합체를 안내하도록 하겠다.

ZStack :

하나의 View위에 다른 View를 순차적으로 쌓는 형태이다.
HStack :

수평으로 View들을 나열하는 방식이다.
VStack :

수직으로 View들을 나열하는 방식이다.
HStack과 VStack은 사용가능한 공간을 꽉 채워서 사용한다.
LazyVGrid :

Grid를 생성할 때 사용하는 방식이다. 만약 일정한 간격으로 View들을 배열하고 싶을 때 사용한다.
```
LazyVGrid(columns: [GridItem(), GridItem(), GridItem()]) {}
   
LazyVGrid(columns: [GridItem(.adaptive(minimum: 65))]) {}
```
columns에 GridItem()을 원하는 만큼 배치해서 가로 갯수를 정해줄 수 있다. 혹은 .adaptive 속성을 사용하여 그리드의 가로 길이의 최솟값을 정해줄 수 있다. 이렇게 하면 주어진 영역에 대해 조건을 만족하는 한에서 최대한 많이 grid를 배치한다. 가로 모드와 세로 모드에서 배열을 다르게 하고 싶을 때 종종 사용한다.

주의할 것은 LazyVGrid는 가로로는 길이를 정해줄 수 있지만 세로로는 View가 가질 수 있는 최소의 길이를 갖는다는 것이다. 따라서 수직 길이를 변경하고 싶다면 GridItem이 되는 각각의 View에 대해서 ratio 설정으로 해결하자.
ScrollView :

내부에 존재하는 View들을 Scroll 형식으로 볼 수 있게 해주는 형식이다.
범위를 넘어가도 scroll을 통해 확인할 수 있다.

예시로 만든 코드는 다음과 같다.

import SwiftUI

struct ContentView: View {
    @State var emojiCount = 4
    var emojis = ["🚖", "🛵", "🚆", "🚍", "🛺", "🛫", "🏖", "🚔", "🛸", "🚁", "🏍", "🛳", "🚐", "🚛", "🚚"]
    var body: some View {
        VStack {
            ScrollView {
                LazyVGrid(columns: [GridItem(.adaptive(minimum: 65))]) {
                    ForEach(emojis[0..<emojiCount], id: \.self){
                        CardView(content: $0).aspectRatio(2/3, contentMode: .fit)
                      	//aspectRatio로 View의 가로 세로 비율 조정하기
                      	//aspectRatio(가로/세로, contentMode: )로 사용한다.
                    }
                }
            }
            .foregroundColor(.red)
            Spacer() 
          	//modify는 값을 안주면 기기별 default 설정이 입력된다.
          	//Spacer는 남는 공간을 모두 빈공간으로 채워주는 역할을 하는 View이다.
            HStack {
                remove
                Spacer()
                add
            }
            .font(.largeTitle)
            .padding(.horizontal)
        }
        .padding(.horizontal)
    }
    var remove: some View {
        Button {
            if emojiCount > 1 {
                emojiCount -= 1
            }
        } label: {
                Image(systemName: "minus.circle")
          			//ios 자체 내장된 아이콘을 사용
          			//sf-symbols라는 문서를 통해 어떤 아이콘이 존재하는지 확인 후 사용
        }
    }
    var add: some View {
        Button {
            if emojiCount < emojis.count {
                emojiCount += 1
            }
        } label: {
                Image(systemName: "plus.circle")
        }
    }
}



struct CardView: View {
    var content: String
    @State var isFaceUp: Bool = true
    var body: some View {
        ZStack {
            let shape = RoundedRectangle(cornerRadius: 20.0)
          	//View를 미리 변수로 선언해둬서 후에 코드를 이쁘게 만들어주었다.
          	//RoundedRectangle은 둥근 모서리를 가진 직사각형을 만들어준다.
            if isFaceUp {
                shape.fill().foregroundColor(.white)
                shape.strokeBorder(lineWidth: 5.0)
              	//그냥 stroke와 strokeBorder의 차이점은 경계선을 그을 때 경계선 외부-내부를 그리는지
              	//경계선 내부로만 그리는지의 차이이다.
              	//참고로 내부를 채우는 fill과 stroke는 동시에 사용할 수 없어 각각 View를 생성해줘야한다.
                Text(content)
                    .font(.largeTitle)
            } else {
                shape.fill()
            }
        }
        .onTapGesture {
            isFaceUp = !isFaceUp
        }
    }
}

fill이나 font와 같은 속성들에 대해서는 보면 무엇인지 바로 확인이 가능할테니 설명을 넘어가고 몇가지 유의할 사항에 대해 이야기해보겠다. 먼저 HStack과 같은 상위 View에 modify를 적용하면 내부의 모든 view들에 적용이 가능하다. 다만 padding과 같이 상위 view에 적용이 가능한 속성은 내부에 전파하지 않는다. 예시로 다음을 보면 font는 HStack내부로 전파가 되지만 padding은 HStack을 감싸는 전체에 대해 적용이 된다.

HStack {
		remove
		Spacer()
		add
}
.font(.largeTitle)
.padding(.horizontal)

CardView 구조체를 선언해놓고 ContentView에서 가져다 사용하는 것을 확인할 수 있는데 구조체로 미리 선언을 해서 반복적으로 사용하는 코드를 함축시킬 수 있다. 단, 사용횟수가 얼마 없어 단순히 코드를 깔끔하게 하고 싶은 것이라면 remove/add variable처럼 computed variable로 선언할 수도 있다.

정말 중요한 속성 중 하나로 View는 생성된 이후로 Immutable해야한다는 것이다. 그런데 자세히 보면 @State var emojiCount = 4나 ‘@State var isFaceUp: Bool = true’ 와 같은 형태로 변수를 선언해서 body내부에서 변수를 바꿔주는 것을 알 수 있다. @State는 포인터의 개념으로 해당 변수가 저장된 주소를 저장해준다. 따라서 주소값은 변하지 않기 때문에 View is Immutable의 속성을 만족할 수 있다.

아래의 2가지 방법으로 onclick 이벤트를 처리해주었다. 먼저 Button은 버튼이 눌렸을 때 실행할 action과 해당 버튼을 표시해주는 label View로 구성되어있다. .onTapGesture는 해당 View를 클릭할 시 실행할 action을 나타내준다.

Button(action: {}, label: {Text("Button")})

ZStack{}.onTapGesture {}

마지막으로 ContentView의 body 내부를 살펴보자. 놀랍게도 CardView라는 View를 반복해서 적는 것 대신 ForEach문을 사용한 것을 확인할 수 있다. SwiftUI body에서는 for문을 사용할 수 없는데 대신 ForEach 문이 사용이 가능하다. 주의할 것은 각 View마다 id라는 것을 부여해줘야 하는데 여기서는 emoji 그림 자체를 id로 부여해주었다.

유의할 것은 각각의 View에 대해 id를 다 다르게 설정해줘야한다는 것이다. 만약 동일한 emoji가 존재한다면 아래 코드에 대해서 두 View는 같은 object를 가르키게 된다. 이렇게될시 LazyVGrid 같은 것을 쓸 때 동일한 object가 2개 이상 존재할 시 에러가 나므로 꼭 모두 다른 id를 부여해주자.

LazyVGrid(columns: [GridItem(.adaptive(minimum: 65))]) {
		ForEach(emojis[0..<emojiCount], id: \.self){
				CardView(content: $0).aspectRatio(2/3, contentMode: .fit)
		}
}

백준 5615 아파트 임대

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/5615

2xy+x+y 에 해당하는 형태의 아파트가 될 수 있는 면적인지 아닌지 파악하는 문제이다. 2xy+x+y = S인 S가 존재한다고 하자. 2S+1 = 4xy+2x+2y+1 = (2x+1)(2y+1)로 나타낼 수 있다. 만약 2S+1이 소수가 된다면 (2x+1)(2y+1)로 인수분해가 불가능하기 때문에 존재할 수 없는 면적이라는 결론을 내릴 수 있다.

면적은 최대 2^31-1 까지 가질 수 있기 때문에 일반적인 소수 판정으로는 시간내에 처리할 수 없다. 따라서 밀러 라빈 알고리즘을 이용해서 해결하도록 하자.

전체 코드

let alist:[UInt64] = [2, 7, 61]
func powmod(x: UInt64, y: UInt64, m:UInt64) -> UInt64 {
    var X = x%m
    var iter = y
    var result:UInt64 = 1
    while iter != 0 {
        if iter%2 == 1 {
            result = (result*X)%m
        }
        X = (X*X)%m
        iter /= 2
    }
    return result
}

func miller(n: UInt64, a: UInt64) -> Bool {
    var d = n-1
    while d%2 == 0 {
        if powmod(x: a, y: d, m: n) == n-1 {
            return true
        }
        d /= 2
    }
    let tmp = powmod(x: a, y: d, m: n)
    return tmp == n-1 || tmp == 1
}

func isPrime(n: UInt64) -> Bool {
    if n <= 1 {
        return false
    }
    for a in alist {
        if !miller(n: n, a: a) {
            return false
        }
    }
    return true
}

let t = Int(readLine()!)!
var result = 0
for _ in 0..<t {
    let k = UInt64(readLine()!)!
    let C = 2*k+1
    if C == 2 || C == 7 || C == 61 {
        result += 1
    }
    else if isPrime(n: 2*k+1) {
        result += 1
    }
}
print(result)

백준 15718 돌아온 떡파이어

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/15718

m-1개의 날짜에 대해서 총 n이라는 떡국의 갯수를 나누어 주는 문제와도 같다. 이 때 각 날짜별로 떡국은 최소 1개는 있어야 한다. 이는 중복조합으로 달리 나타내면 _n-1C_m-2와도 같다. 이 때 조합의 값을 100007로 나눈 값을 구하는 문제이다.

n과 m의 값이 크기때문에 이항계수를 구하는 문제는 dp로 접근할 수 없다. 따라서 앞에서 배운 뤼카의 정리를 써보려해도 100007은 소수가 아니기 때문에 어렵다. 놀랍게도 100007 = 97 x 1031 로 두 소수의 곱으로 이루어져 있다. 따라서 100007로 나눈 나머지는 97로 나눈 나머지와 1031로 나눈 나머지를 알아내면 중국인의 나머지 정리를 이용해 찾을 수 있게 된다.

중국인의 나머지 정리를 보면 알겠지만 a₉₇n₉₇s₉₇ + a₁₀₃₁n₁₀₃₁s₁₀₃₁ (mod 100007) 로 최종 결과를 얻어낼 수 있다. 그런데 소수는 97과 1031로 고정되어 있기 때문에 여러 테스트 케이스에 대해서 n₉₇s₉₇과 n₁₀₃₁s₁₀₃₁을 계산할 필요가 없다. 따라서 미리 확장 유클리드 알고리즘을 이용해서 저장해둔 뒤 반복계산을 하지 않도록 해주자.

전체 코드

var combo:[[Int]] = []
func Euclid(a: Int, b: Int) -> Int {
    var r1 = a, r2 = b, s1 = 1, t1 = 0, s2 = 0, t2 = 1
    while r2 != 0 {
        let q = r1/r2
        let r = r1-q*r2, s = s1-q*s2, t = t1-q*t2
        r1 = r2
        s1 = s2
        t1 = t2
        r2 = r
        s2 = s
        t2 = t
    }
    return s1 > 0 ? s1 : b+s1
}

func lucas(n: Int, m: Int, p: Int) -> Int {
    var N = n, M = m
    var result = 1
    while N != 0 && M != 0 {
        result *= combo[Int(N%p)][Int(M%p)]
        result %= p
        N /= p
        M /= p
    }
    return result
}

combo = Array(repeating: Array(repeating: 0, count: 1032), count: 1032)
combo[0][0] = 1
for i in 1...1031 {
    combo[i][0] = 1
    for j in 1...i {
        combo[i][j] = (combo[i-1][j-1] + combo[i-1][j])%100007
    }
}
let nsB = 97*Euclid(a: 97, b: 1031)
let nsA = 1031*Euclid(a: 1031, b: 97)
let t = Int(readLine()!)!
for _ in 0..<t {
    let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
    let n = nm[0], m = nm[1]
    if n < m-1 {
        print(0)
    }
    else if n == 0 {
        if m == 1 {
            print(1)
        }
        else {
            print(0)
        }
    }
    else if m == 1 {
        print(0)
    }
    else {
        let A = lucas(n: n-1, m: m-2, p: 97)
        let B = lucas(n: n-1, m: m-2, p: 1031)
        let result = (A*nsA + B*nsB)%100007
        print(result)
    }
}

백준 3955 캔디 분배

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/3955

캔디를 총 KX + 1개를 구매하려고 하는데 사탕 한 봉지당 C개의 사탕이 들어있다고 할 때 문제의 조건을 만족하는 사탕 봉지의 갯수를 구하는 문제이다. 이 때 K와 C는 정해져있고 X는 자연수이다.

식을 다시 정리해보면 KX + 1 = CY 라고 쓸 수 있다. -KX + CY = 1로 식을 다시 정리할 수 있고 우리는 이를 만족하는 X와 Y를 찾고싶다. 확장 유클리드 알고리즘의 형태를 생각해보면 AX + BY = gcd(A, B)라는 것을 기억할 것이다.

즉 A = K, B = C, gcd(A, B) = 1인 부정방정식의 해를 찾는 문제로 바꿀 수 있다. K앞의 음수 부호는 최종적으로 구한 X값에 -를 취해주기만 하면 되기 때문에 별 문제없이 풀 수 있다.

따라서 확장 유클리드 알고리즘을 활용해 gcd값이 1일 때 Y해를 찾도록 하자. 유의할 것은 사탕 봉지의 최대 갯수가 정해져있기 때문에 해당 갯수를 넘어설 경우 실패처리를 해주자. 또한 오는 사람이 1명일 경우와 사탕 봉지의 사탕갯수가 1개일 경우 X = 0 혹은 Y = 0인 결과가 나오기 때문에 예외처리를 해줘야한다.

전체 코드

func calc(a: CLongLong, b: CLongLong) -> CLongLong {
    var r1 = a, r2 = b, s1:CLongLong = 1, s2:CLongLong = 0, t1:CLongLong = 0, t2:CLongLong = 1
    while r2 != 0 {
        let q = r1/r2
        let r = r1-q*r2, s = s1-q*s2, t = t1-q*t2
        r1 = r2
        s1 = s2
        t1 = t2
        r2 = r
        s2 = s
        t2 = t
    }
    t1 = (t1%a + a) % a
    if r1 != 1 || t1 > 1_000_000_000 {
        return -1
    }
    return t1
}

let t = Int(readLine()!)!
let MAX:CLongLong = 1_000_000_000
for _ in 0..<t {
    let kc = readLine()!.split(separator: " ").map{CLongLong(String($0))!}
    let k = kc[0], c = kc[1]
    let result = calc(a: k, b: c)
    if c == 1 {
        if k+1 <= MAX {
            print(k+1)
        }
        else {
            print("IMPOSSIBLE")
        }
    }
    else if k == 1 {
        print(1)
    }
    else if result != -1 {
        print(result)
    }
    else {
        print("IMPOSSIBLE")
    }
}

백준 11402 이항 계수 4

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11402

nCk mod m을 구하는 문제로 뤼카의 정리를 실제로 활용해보는 문제이다.
알고리즘 설명하면서 다뤘던 내용을 한번 더 복습해보는 차원에서 풀어보았다.
변형할 것 없이 뤼카의 정리를 그대로 사용하면 되는 문제이다.

전체 코드

let nkm = readLine()!.split(separator: " ").map{CLongLong(String($0))!}
var n = nkm[0], k = nkm[1], m = nkm[2]
let IntM = Int(m)
var comb:[[Int]] = Array(repeating: Array(repeating: 0, count: 2001), count: 2001)
comb[0][0] = 1
for i in 1...IntM {
    comb[i][0] = 1
    for j in 1...i {
        comb[i][j] = (comb[i-1][j-1] + comb[i-1][j])%IntM
    }
}

var result = 1
while n != 0 && k != 0 {
    result *= comb[Int(n%m)][Int(k%m)]
    result %= IntM
    n /= m
    k /= m
}
print(result)

백준 3878 점 분리

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/3878

흰 점과 검은 점이 주어졌을 때 두 점을 분리할 수 있는 직선을 그을 수 있는지를 파악하는 문제이다. 만약 흰 점으로 이루어진 컨벡스헐과 검은 점으로 이루어진 컨벡스헐을 각각 구한다고 하자.

그렇다면 두 점들을 분리할 수 없는 경우는 위의 2가지로 나타난다. 첫번째는 하나의 컨벡스헐 집합 내부에 다른 색깔 점이 존재하는 경우이다. 생각해보면 다각형 내부에 점이 존재할 경우 시계반대방향으로 다각형의 선분들에 대해서 내부의 점과 ccw를 하게되면 그 값은 항상 양수가 나올 것이다. 따라서 흰색 컨벡스 헐에 대해 검은색 컨벡스 헐에 속하는 점들을 모두 확인해주고 마찬가지로 색깔을 바꿔서 동일하게 진행하면 내부에 다른 색깔 점이 존재하는지 확인할 수 있다.

두번째는 점이 컨벡스 헐 선분 위에 존재하는 경우이다. 이 경우 ccw 결과가 0이 나오기 때문에 위에서 확인할 수 없다. 만약 ccw결과가 0이 나올 경우에도 분리할 수 없도록 하라! 라고 설정을 하게 되면 세번째 그림과 같은 상황에서 틀린 결과를 얻게 된다. 실제로는 분리할 수 있는데 같은 직선상에 존재한다고 판단해서 ccw값이 0이 나타나게 되기 때문이다. 이를 방지하기 위해 검은색 컨벡스 헐의 모든 선분과 하얀색 컨벡스 헐의 모든 선분 각각에 대해서 충돌여부를 확인해준다.

전체 코드

func ccw(a: (Int, Int), b: (Int, Int), c: (Int, Int)) -> Int {
    let result = (b.0-a.0)*(c.1-a.1) - (b.1-a.1)*(c.0-a.0)
    return result > 0 ? 1 : (result == 0 ? 0 : -1)
}

func dist(a: (Int, Int), b: (Int, Int)) -> Int {
    let dx = a.0 - b.0, dy = a.1-b.1
    return dx*dx + dy*dy
}

func check(a: (Int, Int), set: [(Int, Int)]) -> Bool {
    let count = set.count
    for i in 0..<count {
        if ccw(a: set[i], b: set[(i+1)%count], c: a) <= 0 {
            return false
        }
    }
    return true
}

func notCrash(a1: (Int, Int), a2: (Int, Int), b1: (Int, Int), b2: (Int, Int)) -> Bool {
    var A = a1, B = a2, C = b1, D = b2
    if A > B {
        swap(&A, &B)
    }
    if C > D {
        swap(&C, &D)
    }
    let abc = ccw(a: A, b: B, c: C)
    let abd = ccw(a: A, b: B, c: D)
    let cda = ccw(a: C, b: D, c: A)
    let cdb = ccw(a: C, b: D, c: B)
    if abc == 0 && abd == 0 && cda == 0 && cdb == 0 {
         return B < C || D < A
    }
    return !(abc*abd <= 0 && cda*cdb <= 0)
}

func makeHul(input: [(Int, Int)]) -> [(Int, Int)] {
    var arr = input
    arr.sort(by: {$0.1 < $1.1})
    arr.sort(by: {$0.0 < $1.0})
    let S = arr[0]
    arr[1..<arr.count].sort(by: {
        ccw(a: S, b: $0, c: $1) == 0 && (dist(a: S, b: $0) < dist(a: S, b: $1))
    })
    arr[1..<arr.count].sort(by: {
        ccw(a: S, b: $0, c: $1) > 0
    })
    var stack:[(Int, Int)] = []
    for next in arr {
        while stack.count >= 2 && (ccw(a: stack[stack.count-2], b: stack[stack.count-1], c: next) <= 0) {
            stack.removeLast()
        }
        stack.append(next)
    }
    return stack
}

let t = Int(readLine()!)!
var str = ""
for _ in 0..<t {
    let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
    let n = nm[0], m = nm[1]
    var black:[(Int, Int)] = Array(repeating: (0, 0), count: n)
    var white:[(Int, Int)] = Array(repeating: (0, 0), count: m)
    for i in 0..<n {
        let line = readLine()!.split(separator: " ").map{Int(String($0))!}
        black[i] = (line[0], line[1])
    }
    for i in 0..<m {
        let line = readLine()!.split(separator: " ").map{Int(String($0))!}
        white[i] = (line[0], line[1])
    }
    let blackHul = makeHul(input: black)
    let whiteHul = makeHul(input: white)
    let p = blackHul.count, q = whiteHul.count
    var result = true
    for i in blackHul {
        if check(a: i, set: whiteHul) {
            result = false
            break
        }
    }
    for i in whiteHul {
        if check(a: i, set: blackHul) {
            result = false
            break
        }
    }
    loop: for i in 0..<p {
        for j in 0..<q {
            if !notCrash(a1: blackHul[i], a2: blackHul[(i+1)%p], b1: whiteHul[j], b2: whiteHul[(j+1)%q]) {
                result = false
                break loop
            }
        }
    }
    str += result ? "YES\n" : "NO\n"
}
print(str)

백준 10254 고속도로

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/10254

2차원 평면 위에 n개의 도시들이 주어지면 n개의 도시 중 유클리드 거리가 가장 먼 두 도시를 찾는 문제이다. 컨벡스 헐로 점들을 감쌌을 때 점 사이의 최대 거리는 컨벡스 헐 꼭지점 사이에서만 존재할 수 있다는 개념을 활용한 문제이다.

여기서 로테이팅 캘리퍼스라는 알고리즘이 사용된다. 컨벡스 헐 상의 점들에 대해서 가장 먼 거리는 마치 캘리퍼스를 돌리듯이 확인하는 과정을 통해 쉽게 구할 수 있다는 알고리즘이다. 신기하게도 모든 점들간의 거리를 확인해주면 O(n²)의 시간이 걸리지만 로테이팅 캘리퍼스를 활용하면 O(n)만에 해결이 가능하다.

핵심 아이디어는 임의의 점을 잡았을 때 가장 먼 거리는 임의의 점과 맞다는 상태로 캘리퍼스로 도형을 돌린다고 했을 때 만나게 되는 점들 중에 하나라는 점이다.

위의 그림은 로테이팅 캘리퍼스를 하는 과정 중 일부이다. 실제로 오각형 중 최하단 좌측에 위치한 점으로부터 가장 멀리있는 점의 거리는 첫번째 그림과 두번째 그림의 경우 중 하나에 해당한다. 자세히 보면 최하단 좌측 점은 항상 캘리퍼스 양 끝 선에 맞닿은 채로 확인하고 있다는 것을 알 수 있다.

최종적으로 모든 점들간의 거리를 확인해 줄 필요없이 임의의 점을 기준으로 본인과 가장 멀리있는 점들만 확인하게 된다. 따라서 한 점당 한번씩 방문을 하게되기 때문에 O(n)의 시간이 걸리게 된다.

파일의 입력이 크기때문에 fread를 해줘야 시간초과가 안난다. 관련 코드는 JCSooHwanCho님의 FileIO.swift 를 참조하였다. <출처 : https://gist.github.com/JCSooHwanCho/30be4b669321e7a135b84a1e9b075f88>

전체 코드

/*
 fread 코드는 JCSooHwanCho님의 FileIO.swift 를 참조하였습니다.
 <출처 : https://gist.github.com/JCSooHwanCho/30be4b669321e7a135b84a1e9b075f88>
*/

import Foundation

final class FileIO {
    private let buffer:[UInt8]
    private var index: Int = 0

    init(fileHandle: FileHandle = FileHandle.standardInput) {
        buffer = Array(try! fileHandle.readToEnd()!)+[UInt8(0)] // 인덱스 범위 넘어가는 것 방지
    }

    @inline(__always) private func read() -> UInt8 {
        defer { index += 1 }
        return buffer[index]
    }

    @inline(__always) func readInt() -> Int {
        var sum = 0
        var now = read()
        var isPositive = true

        while now == 10
                || now == 32 { now = read() } // 공백과 줄바꿈 무시
        if now == 45 { isPositive.toggle(); now = read() } // 음수 처리
        while now >= 48, now <= 57 {
            sum = sum * 10 + Int(now-48)
            now = read()
        }

        return sum * (isPositive ? 1:-1)
    }

    @inline(__always) func readString() -> String {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return String(bytes: Array(buffer[beginIndex..<(index-1)]), encoding: .ascii)!
    }

    @inline(__always) func readByteSequenceWithoutSpaceAndLineFeed() -> [UInt8] {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return Array(buffer[beginIndex..<(index-1)])
    }
}

func ccw(a: (Int, Int), b: (Int, Int), c: (Int, Int)) -> Int {
    let result:CLongLong = CLongLong(b.0-a.0)*CLongLong(c.1-a.1) - CLongLong(b.1-a.1)*CLongLong(c.0-a.0)
    return result > 0 ? 1 : (result == 0 ? 0 : -1)
}

func ccw2(a: (Int, Int), b: (Int, Int), c: (Int, Int), d: (Int, Int)) -> Bool {
    let u = (b.0-a.0, b.1-a.1)
    let v = (d.0-c.0, d.1-c.1)
    return ccw(a: (0, 0), b: u, c: v) >= 0
}

func dist(a: (Int, Int), b: (Int, Int)) -> CLongLong {
    let dx = CLongLong(a.0-b.0)
    let dy = CLongLong(a.1-b.1)
    return dx*dx+dy*dy
}

func convecs(arr: inout [(Int, Int)]) {
    var tmp = arr
    tmp.sort(by: {$0.1 < $1.1})
    tmp.sort(by: {$0.0 < $1.0})
    let startP = tmp[0]
    tmp[1..<tmp.count].sort(by: {
        ccw(a: startP, b: $0, c: $1) == 0 && (dist(a: startP, b: $0) < dist(a: startP, b: $1))
    })
    tmp[1..<tmp.count].sort(by: {ccw(a: startP, b: $0, c: $1) > 0})
    var stack:[(Int, Int)] = []
    for i in 0..<tmp.count {
        let next = tmp[i]
        while stack.count >= 2 && (ccw(a: stack[stack.count-2], b: stack[stack.count-1], c: next) <= 0) {
            stack.removeLast()
        }
        stack.append(next)
    }
    arr = stack
}

func calipers(arr: [(Int, Int)]) {
    let count = arr.count
    var pt = 0
    var ret:CLongLong = 0
    var xx = (0, 0), yy = (0, 0)
    for i in 0..<count {
        var now:CLongLong = 0
        while (pt+1 < count) && ccw2(a: arr[i], b: arr[i+1], c: arr[pt], d: arr[pt+1]) {
            now = dist(a: arr[i], b: arr[pt])
            if now > ret {
                ret = now
                xx = arr[i]
                yy = arr[pt]
            }
            pt += 1
        }
        now = dist(a: arr[i], b: arr[pt])
        if now > ret {
            ret = now
            xx = arr[i]
            yy = arr[pt]
        }
    }
    print(xx.0, xx.1, yy.0, yy.1)
}

let fIO = FileIO()
let t = fIO.readInt()
for _ in 0..<t {
    let n = fIO.readInt()
    var arr:[(Int, Int)] = Array(repeating: (0, 0), count: n)
    for i in 0..<n {
        arr[i] = (fIO.readInt(), fIO.readInt())
    }
    convecs(arr: &arr)
    calipers(arr: arr)
}

백준 1069 집으로

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1069

(x, y)위치에서 (0, 0)으로 가능한 빨리 가는 방법을 찾는 문제이다. 이 때 1초에 1만큼 움직이거나 T초에 D만큼 점프하는 방법을 선택할 수 있다. 좌표상에서 기하학적인 사고방식을 요구하는 문제라서 한번 정리를 해봤다. 먼저 D/T > 1이 아닌경우 무조건 걷는것이 빠르다는 것을 유의하자.

이제 점프가 걷는것보다 빠르다는 경우를 가정하고 문제를 접근하겠다. (x, y)위치에서 영점으로 향하는 가장 빠른 길은 영점과 (x, y)를 이은 직선을 따라 점프하는 것이다. 따라서 점프하는 방법을 통해 원점에서 2D 이하인 지점에 도달할때까지 반복해서 점프하자. 남은 거리에 따라서 2가지 방법이 존재한다.

원점까지 거리가 D이상 남았을 경우
2가지의 방법이 존재한다. 녹색 선분을 따라 1번 점프하고 남은 거리를 걸어가는 경우와 빨간색 선분을 따라 2번 점프해 가는 방법이 존재한다. 따라서 두 방법 중 시간이 덜 걸리는 방법을 택해주면 된다.
원점까지 거리가 D보다 작을 경우
3가지의 방법이 존재한다. 검은색 선분을 따라 걸어가는 경우와 녹색 선분을 따라 1번 점프하고 원점을 지나친 거리만큼 걸어서 돌아가는 방법, 마지막으로 빨간 선분을 따라 2번 점프하는 방법이다. 마찬가지로 세 방법 중 시간이 덜 걸리는 방법을 택해주면 된다.

쉽게 착각하는 오류로 원점과 (x, y)를 이은 직선상에서만 이동을 할 수 있다고 착각하는 것이다. 하지만 여기는 기하가 적용되는 2차원이기 때문에 삼각형을 이루듯이 이동하는 방법이 존재한다는 것을 명심하자.

전체 코드

import Foundation
let line = readLine()!.split(separator: " ").map{Double(String($0))!}
let x = line[0], y = line[1], D = line[2], T = line[3]
let d = sqrt(x*x + y*y)
if D <= T {
    print(d)
}
else {
    var spentTime:Double = 0
    var lastLeng = d
    while lastLeng >= 2*D {
        lastLeng -= D
        spentTime += T
    }
    if lastLeng <= D {
        spentTime += min(2*T, lastLeng, D-lastLeng+T)
    }
    else {
        spentTime += min(2*T, T+lastLeng-D)
    }
    print(spentTime)
}

백준 2162 선분 그룹

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2162

2차원 평면상에 여러 선분들이 주어졌을 때 두 선분이 만나는 경우에는 같은 그룹에 속한다고 정의한다고 하자. 총 몇 개의 그룹으로 선분들이 이루어져 있는지 또 가장 크기가 큰 그룹의 선분의 갯수는 몇 개인지 구하는 문제이다.

먼저 선분들간에 충돌 여부를 확인해줘야하기 때문에 ccw알고리즘이 활용된다는 것을 짐작할 수 있다. 그런데 선분들을 그룹에 포함시키는 일을 어떻게 처리해줘야 할까? 바로 union-find 알고리즘을 활용할 것이다. 만약 두 선분이 충돌한다면 두 선분을 union 시켜주는 행위를 통해 하나의 그룹으로 만들 수 있다.

단 구현자체는 간단한 알고리즘이지만 한가지 union-find 알고리즘에 변형을 시켜줘야한다. 가장 크기가 큰 그룹의 선분의 갯수를 파악해줘야 하기 때문에 각각의 집합마다 포함된 선분의 갯수를 저장해주도록 하자. 또한 마지막에 그룹의 갯수를 파악하기 위해서 그룹의 root에 해당하는 선분마다 표시를 해줘서 root인 선분이 몇개 있는지 세는 것으로 그룹의 갯수를 파악할 수 있도록 구현하였다.

전체 코드

func ccw(x1: Int, x2: Int, x3: Int, y1: Int, y2: Int, y3: Int) -> Int {
    let result = (x2-x1)*(y3-y1) - (y2-y1)*(x3-x1)
    if result > 0 {
        return 1
    }
    else if result == 0 {
        return 0
    }
    else {
        return -1
    }
}

func meet(x1: Int, x2: Int, x3: Int, x4: Int, y1: Int, y2: Int, y3: Int, y4: Int) -> Bool {
    var A = (x1, y1), B = (x2, y2), C = (x3, y3), D = (x4, y4)
    let ABC = ccw(x1: x1, x2: x2, x3: x3, y1: y1, y2: y2, y3: y3)
    let ABD = ccw(x1: x1, x2: x2, x3: x4, y1: y1, y2: y2, y3: y4)
    let CDA = ccw(x1: x3, x2: x4, x3: x1, y1: y3, y2: y4, y3: y1)
    let CDB = ccw(x1: x3, x2: x4, x3: x2, y1: y3, y2: y4, y3: y2)
    if ABC == 0 && ABD == 0 {
        if A > B {
            swap(&A, &B)
        }
        if C > D {
            swap(&C, &D)
        }
        if B >= C && D >= A {
            return true
        }
        else {
            return false
        }
    }
    else if ABC*ABD <= 0 && CDA*CDB <= 0 {
        return true
    }
    else {
        return false
    }
}

struct DisjointSet {
    var arr:[Int]
    var child:[Int]
    var isRoot:[Bool]
    var setCount:Int {
        get {
            var tmp = 0
            for i in 1...isRoot.count-1 {
                if isRoot[i] {
                    tmp += 1
                }
            }
            return tmp
        }
    }
    var maxSet:Int? {
        return child.max()
    }
    init(_ n: Int) {
        arr = [Int](0...n)
        child = Array(repeating: 1, count: n+1)
        isRoot = Array(repeating: true, count: n+1)
    }
    mutating func findRoot(_ n: Int) -> Int {
        if arr[n] == n {
            return n
        }
        else {
            let root = findRoot(arr[n])
            arr[n] = root
            return root
        }
    }
    mutating func union(_ a: Int, _ b: Int) {
        let rootA = findRoot(a), rootB = findRoot(b)
        if rootA == rootB {
            return
        }
        else if rootB > rootA {
            arr[rootB] = rootA
            child[rootA] += child[rootB]
            isRoot[rootB] = false
        }
        else {
            arr[rootA] = rootB
            child[rootB] += child[rootA]
            isRoot[rootA] = false
        }
    }
}

let n = Int(readLine()!)!
var line:[(x1:Int, y1:Int, x2:Int, y2:Int)] = [(0, 0, 0, 0)]
var disjoint = DisjointSet(n)
for _ in 1...n {
    let l = readLine()!.split(separator: " ").map{Int(String($0))!}
    line.append((x1:l[0], y1:l[1], x2:l[2], y2:l[3]))
}
for i in 1..<n {
    for j in i+1...n {
        let line1 = line[i], line2 = line[j]
        if meet(x1: line1.x1, x2: line1.x2, x3: line2.x1, x4: line2.x2, y1: line1.y1, y2: line1.y2, y3: line2.y1, y4: line2.y2) {
            disjoint.union(i, j)
        }
    }
}

print(disjoint.setCount)
print(disjoint.maxSet!)

백준 20149 선분 교차 3

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/20149

두 선분 L1, L2가 교차하는 지 아닌지, 만약 한점에서 교차한다면 그 점은 무엇인지를 파악하는 문제이다.

1. 두 선분이 교차하지 않는 경우

먼저 두 선분이 교차하지 않는 경우를 생각해보자. 두 선분 중 하나를 기반으로 평면을 둘로 나눈다고 생각해보자. 두 선분이 교차하지 않으려면 나머지 선분이 한쪽에만 위치해 있어야 한다.

그림을 보면 알 수 있듯이 L1을 기반으로 L2는 아래쪽에 모두 위치해 있기 때문에 두 선분은 교차하지 않는다. 이를 만족시키려면 선분 L1과 L2상의 점에 대해서 CCW를 하면 항상 같은 부호가 나타나야한다.

이 때 L2를 기반으로 L1상의 점을 확인하면 CCW값의 부호가 서로 다르다는 것을 주목하라. 따라서 L1과 L2 선분 각각을 기반으로 CCW를 확인해주고 두 경우 중 하나라도 부호가 항상 같은 경우가 등장할 경우 충돌하지 않는다. A, B를 L1의 양 끝점 C, D를 L2의 양 끝점이라 했을 때 다음의 형태로 코드를 작성했다.

두 선분이 만나지 않을 경우

let calc1 = ccw(A: A, B: B, C: C)
let calc2 = ccw(A: A, B: B, C: D)
let calc3 = ccw(A: C, B: D, C: A)
let calc4 = ccw(A: C, B: D, C: B)
var result = -1
if calc1*calc2 > 0 || calc3*calc4 > 0 {
    result = 0 //not crash
}

2. 두 선분이 교차하는 경우

그림을 보면 알 수 있듯이 크게 3가지 경우를 생각해 볼 수 있다.

서로 교차하는 경우 앞에서 적용했던 ccw를 생각해보자. 한 선분을 기준으로 양쪽에 끝점이 위치해있기 때문에 ccw의 부호가 서로 다르다. 따라서 CCW(A, B, C)∗CCW(A, B, D) < 0 && CCW(C, D, A)∗CCW(C, D, B) < 0이 된다.
한 쪽 선분의 끝이 다른 선분 위에 위치하는 경우 L2를 기준으로 ccw를 구하게 되면 ccw의 부호가 서로 다르다. 하지만 L1을 기준으로 ccw를 구하게 되면 L2의 한 점은 선분위에 존재하기 때문에 ccw의 값이 0이 나타나게 된다. 따라서 CCW(C, D, A)∗CCW(C, D, B) < 0 이지만 CCW(A, B, C)∗CCW(A, B, D) = 0 이 된다.
두 선분의 끝 중 하나가 일치하는 경우 이번에는 L1, L2 모두 ccw의 값이 0이 나타나게 된다. 따라서 CCW(A, B, C)∗CCW(A, B, D) = 0 && CCW(C, D, A)∗CCW(C, D, B) = 0이 된다.

두 선분이 교차하는 경우

if calc1 == 0 && calc2 == 0 && calc3 == 0 && calc4 == 0 {
    //두 선분이 한 직선위에 있는 경우로 아래에서 다룰 예정
}
else if calc1*calc2 <= 0 && calc3*calc4 <= 0 {
    result = 1 //crash
    inter = intersection(A, B, C, D)
}

만약 intersection을 계산해줘야 하는 경우에는 다음의 관계식을 활용해서 구해주도록 하자.

intersection Function

func intersection(A: (Int, Int), B: (Int, Int), C: (Int, Int), D: (Int, Int)) -> (Double, Double) {
    let x1 = A.0, y1 = A.1, x2 = B.0, y2 = B.1, x3 = C.0, y3 = C.1, x4 = D.0, y4 = D.1
    let px = (x1*y2-y1*x2)*(x3-x4) - (x1-x2)*(x3*y4 - y3*x4)
    let py = (x1*y2-y1*x2)*(y3-y4) - (y1-y2)*(x3*y4 - y3*x4)
    let p = (x1-x2)*(y3-y4) - (y1-y2)*(x3-x4)
    return (Double(px)/Double(p), Double(py)/Double(p))
}

3. 두 선분이 같은 직선 위인 경우

앞에서 다룬 두 case는 모두 두 선분이 한 직선 위에 존재하지 않는다는 가정을 하고 접근한 경우였다. 이번에는 두 선분이 한 직선위에 있는 경우를 생각해보자. 마찬가지로 2가지 경우를 생각해볼 수 있다. 여기서는 L1, L2에 대해서 항상 A < B, C < D가 되도록 A, B, C, D를 설정하고 시작한다는 것을 유의하자.

두 선분이 만나는 경우 B가 C보다 크거나 같고 D가 A보다 크거나 같은 경우를 생각해보자. 그 범위 내에서는 두 선분이 항상 만난다는 것을 생각해볼 수 있다. 실제로 첫번째 그림과 두번째 그림을 보면 알 수 있다. 여기에는 두 선분이 일치하는 경우도 포함된다. 유의할 것은 우리는 한점에서 만나는 경우 그 좌표를 출력해야 한다. 만약 B = C 혹은 A = D인 경우를 생각해보자. 이 경우 두 선분이 끝점끼리만 만나기 때문에 그 좌표를 출력해주도록 구현해야 한다.
두 선분이 만나지 않는 경우 이 경우는 위와 반대의 조건을 가지면 된다. B < C 혹은 D < A인 경우가 이에 해당한다.

두 선분이 한 직선 위에 있는 경우

if calc1 == 0 && calc2 == 0 && calc3 == 0 && calc4 == 0 {
    if B < A {swap(&A, &B)}
    if D < C {swap(&C, &D)}
    if C <= B && A <= D { //if crash
        result = 1
        if B == C {
            inter = B
        }
        else if A == D {
            inter = D
        }
    }
    else {
        result = 0 //not crash
    }
}

전체 코드

import Foundation
func ccw(A: (Int, Int), B: (Int, Int), C: (Int, Int)) -> Int {
    let P = (B.0-A.0, B.1-A.1)
    let Q = (C.0-A.0, C.1-A.1)
    let S:CLongLong = CLongLong(P.0)*CLongLong(Q.1) - CLongLong(Q.0)*CLongLong(P.1)
    if S > 0 {
        return 1
    }
    else if S < 0 {
        return -1
    }
    else {
        return 0
    }
}

func intersection(A: (Int, Int), B: (Int, Int), C: (Int, Int), D: (Int, Int)) -> (Double, Double) {
    let x1 = A.0, y1 = A.1, x2 = B.0, y2 = B.1, x3 = C.0, y3 = C.1, x4 = D.0, y4 = D.1
    let px = (x1*y2-y1*x2)*(x3-x4) - (x1-x2)*(x3*y4 - y3*x4)
    let py = (x1*y2-y1*x2)*(y3-y4) - (y1-y2)*(x3*y4 - y3*x4)
    let p = (x1-x2)*(y3-y4) - (y1-y2)*(x3-x4)
    return (Double(px)/Double(p), Double(py)/Double(p))
}

let line1 = readLine()!.split(separator: " ").map{Int(String($0))!}
let line2 = readLine()!.split(separator: " ").map{Int(String($0))!}
var result = -1
var inter:(Double, Double) = (1000001, 1000001)

var A = (line1[0], line1[1])
var B = (line1[2], line1[3])
var C = (line2[0], line2[1])
var D = (line2[2], line2[3])
let calc1 = ccw(A: A, B: B, C: C)
let calc2 = ccw(A: A, B: B, C: D)
let calc3 = ccw(A: C, B: D, C: A)
let calc4 = ccw(A: C, B: D, C: B)
if calc1 == 0 && calc2 == 0 && calc3 == 0 && calc4 == 0 {
    if B < A {swap(&A, &B)}
    if D < C {swap(&C, &D)}
    if C <= B && A <= D {
        result = 1
        if B == C {
            inter = (Double(B.0), Double(B.1))
        }
        else if A == D {
            inter = (Double(D.0), Double(D.1))
        }
    }
    else {
        result = 0
    }
}
else if calc1*calc2 <= 0 && calc3*calc4 <= 0 {
    result = 1
    inter = intersection(A: A, B: B, C: C, D: D)
}
else {
    result = 0
}
print(result)
if result == 1 && inter.0 <= 1000000 {
    print(inter.0, inter.1)
}

백준 2166 다각형의 면적

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2166

n개의 점으로 이루어진 다각형의 면적을 구하는 문제이다.

다각형을 한점을 중심으로 선분을 그어서 삼각형 형태로 나누면 각각의 삼각형의 넓이를 모두 구하면 다각형의 면적을 구할 수 있다. 놀랍게도 외적은 두 벡터로 이루어진 삼각형의 넓이의 2배와 같다. 이를 이용해서 다각형의 면적을 구한다.

다만 위의 그림처럼 외적 값이 음수가 나타나는 경우가 있다. 하지만 두번째 삼각형의 빨간 부분에서 세번째 삼각형의 빨간 부분을 빼면 우리가 구하고자 하는 다각형의 넓이를 구할 수 있다는 것을 볼 수 있다. 실제로 외적값이 음수가 나오는 경우는 빼줘야하는 부분에 해당하기 때문에 이를 고려해서 연산하면 된다.

전체 코드

import Foundation
func ccw(x1: Int, x2: Int, x3: Int, y1: Int, y2: Int, y3: Int, z1: Int, z2: Int, z3:Int) -> (Int, Int, Int){
    let A = (x:x2-x1, y:y2-y1, z:z2-z1)
    let B = (x:x3-x1, y:y3-y1, z:z3-z1)
    let AxB = (A.y*B.z - A.z*B.y, A.z*B.x - A.x*B.z, A.x*B.y - A.y*B.x)
    return AxB
}

let n = Int(readLine()!)!
var point:[(Int, Int, Int)] = []
for _ in 1...n {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    point.append((line[0], line[1], 0))
}

let A = point[0]
var result:Double = 0
for i in 1..<n-1 {
    let B = point[i], C = point[i+1]
    let calculate = ccw(x1: A.0, x2: B.0, x3: C.0, y1: A.1, y2: B.1, y3: C.1, z1: A.2, z2: B.2, z3: C.2)
    result += Double(calculate.2)
}
result = abs(result)/2
print(String(format: "%.1f", result))

백준 9020 골드바흐의 추측

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/9020

골드바흐의 추측이란 2보다 큰 모든 짝수는 두 소수의 합으로 나타낼 수 있다는 것이다. 이 때 짝수를 두 소수의 합으로 나타내는 표현을 그 수의 골드바흐 파티션이라고 부를 때 2보다 큰 짝수 n에 대해서 골드바흐 파티션을 출력하는 문제이다. 만약 파티션이 여러가지일 경우 두 소수의 차이가 가장 작은 것을 출력한다.

여러개의 테스트 케이스가 주어지기 때문에 범위내의 숫자에 대해 소수 여부를 미리 파악하고 있으면 좋겠다는 생각이 든다. 따라서 에라토스테네스의 체를 활용해 숫자 10000까지 소수 여부를 확인해주자. 우리는 두 소수의 차이가 가장 작은 것을 출력하고 싶기 때문에 n/2부터 시작해서 하나는 1씩 감소시키고 하나는 1씩 증가시키면서 두 숫자 모두 소수일 경우를 찾아주면 된다. 소수 여부는 에라토스테네스의 체로 만들어둔 배열을 확인한다.

전체 코드

readLine()
var arr = [Bool](repeating: true, count: 10001)
for i in 2...10000 {
    if !arr[i] {continue}
    for j in stride(from: 2*i, through: 10000, by: i) {arr[j] = false}
}
while let line = readLine() {
    var compare1 = Int(line)!/2
    var compare2 = Int(line)!/2
    while compare1 > 1 {
        if arr[compare1] && arr[compare2] {
            print("\(compare1) \(compare2)")
            break
        }
        else {
            compare1 -= 1
            compare2 += 1
        }
    }
}

백준 1010 다리 놓기

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1010

n개의 서쪽 지점과 m개의 동쪽 지점의 점들을 잇는 다리를 짓는 경우의 수를 찾는 문제이다. 이 때 다리는 서로 교차할 수 없다고 주어졌기 때문에 문제를 간단히 풀 수 있다.

생각해보면 m개의 동쪽 지점에서 n개를 선택하게 되면 자동적으로 가장 위에 지점부터 서쪽 지점의 가장 위쪽 지점과 연결해야 다리가 교차하지 않는다는 것을 알 수 있다. 따라서 mCn을 구하는 문제로 바꿀 수 있고 간단히 이항계수를 구해주면 해결된다.

전체 코드

let n = Int(readLine()!)!
for i in 1...n {
    let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
    var arr = Array(repeating: 1, count: 31)
    for p in 1...nm[1] {
        let tmp = arr
        for q in 1..<p {
            arr[q] = tmp[q] + tmp[q-1]
        }
    }
    print(arr[nm[0]])
}

백준 2981 검문

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2981

n개의 숫자를 m으로 나누었을 때 나머지가 모두 같게 되는 m을 모두 찾는 문제이다. n개의 숫자를 m으로 나누었을 때 나머지가 모두 같으려면 다음의 형태로 숫자들이 나타날 것이다.

x_i = mq(x_i) + r

이 때 임의의 두 숫자를 빼면 나머지가 같기 때문에 m|(x_i - x_j)인 m이 존재하게 된다. 따라서 이를 활용하여 숫자들을 오름차순 정렬을 시킨 후 이웃한 숫자끼리의 차들에 대해서 gcd를 계산해주면 m을 찾을 수 있다.

num.sort()
var bm = num[1]-num[0]
for i in 2..<n {
    bm = gcd(a: bm, b: num[i]-num[i-1])
}

만약 m이 여러개가 존재한다하면 gcd는 최대 공약수를 찾아주는 것이기 때문에 m값들의 최소 공배수를 얻게 된다. 따라서 최종적으로 얻어낸 bm값에 대해서 1과 본인을 제외한 모든 인수를 구해주면 원하는 결과를 얻을 수 있다.

전체 코드

let n = Int(readLine()!)!
var num:[Int] = []
for _ in 1...n {
    num.append(Int(readLine()!)!)
}
num.sort()

var bm = num[1]-num[0]
for i in 2..<n {
    bm = gcd(a: bm, b: num[i]-num[i-1])
}

var index = 2
var result:[Int] = [bm]
while index*index <= bm {
    if bm%index == 0 {
        result.append(index)
        if index*index != bm {
            result.append(bm/index)
        }
    }
    index += 1
}
result.sort()
var str = ""
for i in result {
    str += "\(i) "
}
print(str)

func gcd(a: Int, b: Int) -> Int {
    if a%b == 0 {return b}
    else {return gcd(a: b, b: a%b)}
}

백준 11479 서로 다른 부분 문자열의 개수 2

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11479

문자열 S의 부분 문자열 중에서 서로 다른 것의 갯수를 구하는 문제이다. 예시를 들어서 이해해보자. 먼저 ababc라는 문자열이 주어진다고 했을 때 5개의 접두사를 얻어낼 수 있다.

a
ab
aba
abab
ababc

그런데 맨 앞에 a를 탈락시킨 babc에 대해서도 접두사를 구하면 4개의 접두사를 얻을 수 있다.

b
ba
bab
babc

이런식으로 접미사들의 모든 접두사를 구하면 우리가 구하고자 하는 부분 문자열을 모두 나타낼 수 있다. 그런데 이중에서 겹치지않는 것을 찾고자하려면 어떻게 해야할까? 생각해보면 접미사들의 접두사를 구하는 것으로 부분 문자열을 나타낸다고 했었다. 만약 두 접미사의 앞부분이 일치한다면 접두사를 구하는 과정에서 부분 문자열이 중복해서 나타날 것이다. 예시로 ababc를 다시 보자.

Suffix Array	i	LCP
ababc	0	x
abc	2	2
babc	1	0
bc	3	1
c	4	0

ababc에 대한 접두사들을 모두 구하고 다음 suffix에 대해 새로운 접두사를 구하려고 한다고 하자. abc가 ababc와 중복되지않는 부분문자열의 갯수는 abc의 길이 - LCP[abc] 로 3-2가 되어서 1이 나온다. 실제로도 a와 ab는 이미 등장했기 때문에 abc만 세주면 된다.

만약 abc라는 부분 문자열이 다시 등장하려면 abcd와 같이 abc 뒤에 무언가 이어진 형태가 나타나야할 것이고 이는 suffix상에서 인접해있기 때문에 lcp를 구하는 과정에서 포함이 된다. 따라서 abc는 두번 카운트 되지 않는다. 또한 dabc와 같은 형태는 무조건 접두사를 구하는 과정에서 앞에 d를 포함시키게 된다. 따라서 abc는 두번 카운트 되지 않는다.

최종적으로 LCP와 Suffix Array를 구해서 다음의 작업을 해주면 서로 다른 부분 문자열의 개수를 구할 수 있다. 이 때 LCP[0]의 값을 0으로 설정해주도록 하자. n-sa[i]를 하면 i번째 suffix의 길이가 나온다는 것을 명심하자.

for i in 0..<n {
    result += n-sa[i]-lcp[i]
}

전체 코드

func compare(g: [Int], a: Int, b: Int, t: Int) -> Bool {
    if g[a] == g[b] {
        return g[a+t] < g[b+t]
    }
    else {
        return g[a] < g[b]
    }
}

func suffix(str: [Character]) -> [Int] {
    let n = str.count
    var g = Array(repeating: -1, count: n+1)
    var ng = Array(repeating: -1, count: n+1)
    var sfx = Array(repeating: -1, count: n)
    var t = 1
    
    for i in 0..<n {
        g[i] = Int(str[i].asciiValue!-96)
        sfx[i] = i
    }
    while t < n {
        sfx.sort(by: {compare(g: g, a: $0, b: $1, t: t)})
        ng[sfx[0]] = 0
        for i in 1..<n {
            if compare(g: g, a: sfx[i-1], b: sfx[i], t: t) {
                ng[sfx[i]] = ng[sfx[i-1]] + 1
            }
            else {
                ng[sfx[i]] = ng[sfx[i-1]]
            }
        }
        g = ng
        t <<= 1
    }
    return sfx
}

func LCP(str: [Character], SA: [Int]) -> [Int] {
    let n = str.count
    var strArr = str
    strArr.append("#")
    var lcp = Array(repeating: 0, count: n)
    var rank = Array(repeating: 0, count: n)
    for i in 0..<n {
        rank[SA[i]] = i
    }
    
    var len = 0
    for i in 0..<n {
        let k = rank[i]
        if k > 0 {
            while strArr[SA[k-1]+len] == strArr[i+len] {
                len += 1
            }
            lcp[k] = len
            if len > 0 {
                len -= 1
            }
        }
    }
    return lcp
}

let line = readLine()!.map{Character(String($0))}
let sa = suffix(str: line)
let lcp = LCP(str: line, SA: sa)
let n = line.count
var result:UInt64 = 0
for i in 0..<n {
    result += UInt64(n-sa[i]-lcp[i])
}
print(result)

백준 1605 반복 부분문자열

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1605

길이 L의 문자열이 주어지면 이 문자열의 부분문자열 중 적어도 한 번은 반복되는 부분문자열을 반복 부분문자열이라고 부르기로 했을 때 가장 긴 반복 부분문자열의 길이를 구하는 문제이다.

반복 부분문자열은 결국에는 suffix array상에서 가장 가까운 두 suffix 문자열이 갖는 접두사의 길이와 같다는 것을 알아야한다. A라는 반복 부분문자열이 존재하고 가장 길다고 했을 때, A라는 부분 문자열을 맨앞에 포함하는 두 suffix는 suffix array상에서 인접할 수밖에 없다.

예를들어 문자열 aabcaabcd가 존재한다고 했을 때.

aabcd
aabcaabcd

두 suffix는 suffix array상에서 바로 옆에 위치한다.

문제가 어려워보였지만 결국에는 LCP를 구하는 문제로 바꿔볼 수 있다.
최종적으로는 LCP값 중에서 최댓값을 구하면 되는 문제이다.

전체 코드

func compare(g: [Int], a: Int, b: Int, t: Int) -> Bool {
    if g[a] == g[b] {
        return g[a+t] < g[b+t]
    }
    else {
        return g[a] < g[b]
    }
}

func suffix(str: [Character]) -> [Int] {
    let n = str.count
    var g = Array(repeating: -1, count: n+1)
    var ng = Array(repeating: -1, count: n+1)
    var sfx = Array(repeating: -1, count: n)
    var t = 1
    
    for i in 0..<n {
        g[i] = Int(str[i].asciiValue!-96)
        sfx[i] = i
    }
    while t < n {
        sfx.sort(by: {compare(g: g, a: $0, b: $1, t: t)})
        ng[sfx[0]] = 0
        for i in 1..<n {
            if compare(g: g, a: sfx[i-1], b: sfx[i], t: t) {
                ng[sfx[i]] = ng[sfx[i-1]] + 1
            }
            else {
                ng[sfx[i]] = ng[sfx[i-1]]
            }
        }
        g = ng
        t <<= 1
    }
    return sfx
}

func LCP(str: [Character], SA: [Int]) -> [Int] {
    let n = str.count
    var strArr = str
    strArr.append("#")
    var lcp = Array(repeating: 0, count: n)
    var rank = Array(repeating: 0, count: n)
    for i in 0..<n {
        rank[SA[i]] = i
    }
    
    var len = 0
    for i in 0..<n {
        let k = rank[i]
        if k > 0 {
            while strArr[SA[k-1]+len] == strArr[i+len] {
                len += 1
            }
            lcp[k] = len
            if len > 0 {
                len -= 1
            }
        }
    }
    return lcp
}

readLine()
let line = readLine()!.map{Character(String($0))}
let sa = suffix(str: line)
let lcp = LCP(str: line, SA: sa)
print(lcp.max()!)

백준 13713 문자열과 쿼리

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/13713

문자열 S = S₁S₂…S_N이 주어질 때 F(i)는 S와 S₁S₂…S_i의 가장 긴 공통 접미사의 길이로 정의된다. S와 i가 주어졌을 때 F(i)를 구하는 문제이다. 앞에서 배웠던 Z알고리즘을 활용하려고 보니 뭔가 이상하다. Z알고리즘은 S_i~S_N의 가장 긴 공통 접두사였는데 이번에는 형태가 조금 다르다.

하지만 해법은 간단하다. 문자열 S를 뒤집어서 S_N~S₁의 형태가 된다고 생각하자. Z[N-i]은 뒤집힌 S와 S_i~S₁의 가장 긴 공통 접두사의 길이 로 정의된다. 이는 우리가 구하고자 했던 S와 S₁~S_i의 공통 접미사 길이와 같다. 따라서 문자열을 뒤집어서 Z알고리즘을 적용시킨 후에 다시한번 뒤집어서 출력해주면 되는 문제이다.

전체 코드

/*
 fread 코드는 JCSooHwanCho님의 FileIO.swift 를 참조하였습니다.
 <출처 : https://gist.github.com/JCSooHwanCho/30be4b669321e7a135b84a1e9b075f88>
*/

import Foundation

final class FileIO {
    private let buffer:[UInt8]
    private var index: Int = 0

    init(fileHandle: FileHandle = FileHandle.standardInput) {
        buffer = Array(try! fileHandle.readToEnd()!)+[UInt8(0)] // 인덱스 범위 넘어가는 것 방지
    }

    @inline(__always) private func read() -> UInt8 {
        defer { index += 1 }
        return buffer[index]
    }

    @inline(__always) func readInt() -> Int {
        var sum = 0
        var now = read()
        var isPositive = true

        while now == 10
                || now == 32 { now = read() } // 공백과 줄바꿈 무시
        if now == 45 { isPositive.toggle(); now = read() } // 음수 처리
        while now >= 48, now <= 57 {
            sum = sum * 10 + Int(now-48)
            now = read()
        }

        return sum * (isPositive ? 1:-1)
    }

    @inline(__always) func readString() -> String {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return String(bytes: Array(buffer[beginIndex..<(index-1)]), encoding: .ascii)!
    }

    @inline(__always) func readByteSequenceWithoutSpaceAndLineFeed() -> [UInt8] {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return Array(buffer[beginIndex..<(index-1)])
    }
}

func Z(str: [Character]) -> [Int] {
    let n = str.count
    var l = -1, r = -1
    var F = Array(repeating: -1, count: n)
    F[0] = n-1
    for i in 1..<n {
        if i <= r {
            F[i] = min(F[i-l], r-i)
        }
        while i+F[i]+1 < n && str[i+F[i]+1] == str[F[i]+1] {
            F[i] += 1
        }
        if r < i+F[i] {
            r = i+F[i]
            l = i
        }
    }
    return F
}
    
let fIO = FileIO()
var line = fIO.readString().reversed().map{Character(String($0))}
var result = Z(str: line)
result.reverse()
let m = fIO.readInt()
var str = ""
for _ in 0..<m {
    let q = fIO.readInt()-1
    str += "\(result[q]+1)\n"
}
print(str)

백준 16163

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/16163

문자열이 주어지면 주어진 문자열 속의 모든 회문의 갯수를 구하는 문제이다. 회문 관련 문제이기 때문에 Manacher 알고리즘을 활용해서 풀 것이다.

기존의 manacher알고리즘을 사용하면 문자열 속 각 자리를 중심으로하는 회문의 길이를 구할 수 있다. 그런데 회문의 길이가 3인 DCBABCD와 같은 회문을 생각해보자. 이때 회문의 양끝을 제거해나간 것도 하나의 회문이 되기 때문에 회문의 길이가 3이면 총 4개의 회문을 얻을 수 있다. 즉 manacher 알고리즘으로 구한 회문의 길이를 통해 회문의 갯수를 파악할 수 있게 된다.

따라서 모든 index의 회문의 길이를 훑으면서 갯수에 더해주면 된다. 유의할 것은 짝수 길이의 회문을 파악하기 위해서 문자열에 #과 같은 문자가 사이사이에 삽입되어있다는 것이다. 이를 고려하여 짝수길이 회문과 홀수길이 회문 case로 나누어서 갯수를 파악해주자.

전체 코드

func manacher(str: [Character]) -> [Int] {
    let n = str.count
    var r = -1, p = -1
    var A = Array(repeating: 0, count: n)
    for i in 0..<n {
        if i <= r {
            A[i] = min(A[2*p-i], r-i)
        }
        while i-A[i]-1 >= 0 && i+A[i]+1 < n && str[i-A[i]-1] == str[i+A[i]+1] {
            A[i] += 1
        }
        if i+A[i] > r {
            r = i+A[i]
            p = i
        }
    }
    return A
}

let line = readLine()!
var str = [Character]()
str.append("#")
for c in line {
    str.append(c)
    str.append("#")
}
let pe = manacher(str: str)
var result = 0
for i in 0..<pe.count {
    if i%2 == 0 {
        result += pe[i]/2
    }
    else {
        result += (pe[i]+1)/2
    }
}
print(pe)
print(result)

백준 14725 개미굴

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/14725

trie의 구조를 root부터 leaf 노드까지 하나씩 나열한 결과들이 주어진다고 했을 때 trie를 시각화된 구조로 출력하는 문제이다. 유의할 것은 앞에서 했던 trie와는 다르게 문자열이 하나의 노드가 될 수 있다는 점이다.

따라서 trie의 노드별로 Dictionary<String, Int> 구조체를 갖고있도록 설정해주었다. 만약 해당 String이 현재 노드에서 자식 노드로 연결되어 있다면 현재 노드의 Dictionary에서 자식 노드의 Trie index을 return 해주도록 설정했다.

var trie = Array(repeating: Dictionary<String, Int>(), count: 1)
//trie는 딕셔너리의 배열로 나타내주었다.
func maketrie(str: [String], trie: inout [Dictionary<String, Int>], check: inout [Bool]) {
    var node = 0
    for i in 1...Int(str[0])! {
        let tmp = str[i]
        if trie[node][tmp] == nil {
        // 현재 trie 노드에서 tmp 문자열로의 경로가 없을 때
            trie[node][tmp] = trie.count
            node = trie.count
            trie.append(Dictionary<String, Int>())
            check.append(false)
        }
        else {
        // 경로가 있다면 노드를 자식 노드로 이동!
            node = trie[node][tmp]!
        }
    }
    check[node] = true
}

위의 코드는 maketrie 함수의 일부로 만약 현재 node에 tmp라는 문자열이 입력된 적이 없다면 dictionary는 nil을 return해 줄 것이고 trie 배열에 새롭게 노드를 추가시켜주도록 구현했다. 이 때 각 노드의 index 번호는 생성되는 순서로 매겨주어 부모 노드의 dictinary에 해당 index 번호를 저장시켜두는 형태로 구현했다.

최종적으로 모든 입력에 대해 trie를 구축하고 나면 dfs를 통해 출력해주면 된다. 유의할 점은 사전 순으로 먼저 나오게 해야하기 때문에 dictionary를 정렬시켜서 dfs를 적용시키자. 출력 형태에 맞게 depth에 맞게 –를 반복적으로 사용해야 하는 것도 잊지말자.

전체 코드

func maketrie(str: [String], trie: inout [Dictionary<String, Int>], check: inout [Bool]) {
    var node = 0
    for i in 1...Int(str[0])! {
        let tmp = str[i]
        if trie[node][tmp] == nil {
            trie[node][tmp] = trie.count
            node = trie.count
            trie.append(Dictionary<String, Int>())
            check.append(false)
        }
        else {
            node = trie[node][tmp]!
        }
    }
    check[node] = true
}

func dfs(d: Int, n: Int, arr: [Dictionary<String, Int>]) -> String {
    var str = ""
    for i in arr[n].sorted(by: {$0.key < $1.key}) {
        for _ in 0..<d {
            str += "--"
        }
        str += "\(i.key)\n"
        str += dfs(d: d+1, n: i.value, arr: arr)
    }
    return str
}

var trie = Array(repeating: Dictionary<String, Int>(), count: 1)
var check = Array(repeating: false, count: 1)
let n = Int(readLine()!)!
for _ in 1...n {
    let line = readLine()!.split(separator: " ").map{String($0)}
    maketrie(str: line, trie: &trie, check: &check)
}
print(dfs(d: 0, n: 0, arr: trie))

백준 10266 시계 사진들

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/10266

n개의 동일한 시계 바늘의 위치가 찍힌 사진이 두 장 주어졌을 때 두 사진이 동일한 시각을 나타내는지 알아내는 문제이다. 시계에는 시계 바늘간의 위치만 구분할 수 있기 때문에 사진을 돌려서 일치하면 같은 시각을 나타내는 것이라 생각한다.

시계 바늘간의 위치가 중요한 것이기 때문에 바늘들간의 각도차를 중심으로 문제를 풀 것이다. 이 때 첫번째 바늘과 마지막 바늘간의 각도 역시 계산해줘야한다는 것을 명심하자.

예시로 4개의 바늘이 존재한다고 했을 때 각각의 사잇각을 ABCD라고 나타내보자. 그런데 두번재 사진은 각이 희한하게 주어져서 DABC 순으로 우리가 각도를 확인했다고 하자.

첫번째 사진의 각도 순서를 2번 이어붙여보자. 그러면 ABCDABCD가 될 것이고 이 안에는 ABCD, BCDA, CDAB, DABC 네 패턴이 모두 존재할 수 있게 된다. 이제 DABC에 해당했던 두번째 사진의 각도 순서가 ABCDABCD 속에 존재하는지 확인하면 두 사진은 동일한 시간이라 판별할 수 있다.

즉 두번째 사진의 각도 순서가 어떻게 나오든 첫번째 사진과 동일한 시간이라면 첫번째 각도순서를 두번 붙인 문자열 속에 해당 패턴이 등장하게 된다. 따라서 KMP알고리즘을 통해 이를 확인해주면 되는 문제이다.

전체 코드

func makepi(str: [Int]) -> [Int] {
    var pi = Array(repeating: 0, count: str.count)
    var j = 0
    for i in 1..<str.count {
        while j > 0 && str[i] != str[j] {
            j = pi[j-1]
        }
        if str[i] == str[j] {
            j += 1
            pi[i] = j
        }
    }
    return pi
}

func makeDiff(str: [Int]) -> [Int] {
    var arr = [Int]()
    for i in 0..<str.count-1 {
        arr.append(str[i+1]-str[i])
    }
    arr.append(360000-str.last!+str[0])
    return arr
}

let n = Int(readLine()!)!
let S = makeDiff(str: readLine()!.split(separator: " ").map{Int(String($0))!}.sorted())
let S1 = S + S
let S2 = makeDiff(str: readLine()!.split(separator: " ").map{Int(String($0))!}.sorted())
let pi = makepi(str: S2)
var i = 0
var j = 0
var result = false
while i+j < S1.count && i < S2.count {
    let curr = i+j
    while j > 0 && S1[curr] != S2[j] {
        j = pi[j-1]
        i = curr - j
    }
    if S1[curr] == S2[j] {
        j += 1
        if j == S2.count {
            result = true
            break
        }
    }
    else {
        i += 1
    }
}
print(result ? "possible" : "impossible")

백준 1305 광고

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1305

전광판 길이 L이 주어졌을 때 그곳에 광고 문자열이 한칸씩 옆으로 이동하면서 보여준다고하자. 이 때 광고는 길이 N인 문자열이 무한히 붙여져서 광고된다고 했을 때 어느 순간 전광판을 봤을 때 쓰여 있는 문자가 입력으로 주어졌을 때 가능한 광고의 최소 길이를 구하는 문제이다.

마찬가지로 fail함수를 활용해서 접두사와 접미사가 같은 지점을 활용해주는 문제이다. 생각해보면 AB라는 두 패턴으로 구성된 광고가 주어졌다고 했을 때 ABABA로 B지점이 짤렸다고하자. 그러면 마지막 문자의 접두사와 접미사가 같은 지점을 찾아주면 ABA로 전체 길이에서 해당 길이를 빼주면 AB의 길이가 정상적으로 나타나게 된다. 한칸씩 옆으로 이동하게 되면 달라지는 것이 아닌가 생각할 수 있지만 A, B를 새로운 패턴으로 인식하기만 하면 되기 때문에 똑같은 광고의 길이를 얻게 된다.

예시로 aab라는 광고를 한다고 생각해보자. 길이가 7인 전광판에 광고를 한다고 했을 때 시작은 다음과 같다.

aabaaba

이 때 a를 A패턴 ab를 B패턴이라고 생각하면 결국에는 ABABA 형태로 볼 수 있다. 옆으로 한칸 이동했을 때는 다음과 같다.

abaabaa

이 때는 a를 A패턴 ba를 B패턴이라고 생각하면 결국에는 ABABA 형태가 나타나게 된다. 따라서 주어진 문자열 S에서 마지막 문자의 pi값을 찾아주고 전체 광고판 길이 L에서 빼주게되면 광고의 가장 짧은 길이를 구할 수 있다.

전체 코드

func makepi(str: [Character]) -> Int {
    var pi = Array(repeating: 0, count: str.count)
    var j = 0
    for i in 1..<str.count {
        while j > 0 && str[i] != str[j] {
            j = pi[j-1]
        }
        if str[i] == str[j] {
            j += 1
            pi[i] = j
        }
    }
    return pi.last!
}

let L = Int(readLine()!)!
let S = readLine()!.map{Character(String($0))}
let last = makepi(str: S)
print(L-last)

백준 4354 문자열 제곱

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/4354

문자열 s를 s = a^n의 형태로 표현한다고 했을 때 이는 문자열 a가 n번 반복해서 나오면 s가 된다는 뜻이다. 이때 임의의 문자열이 주어지면 s = a^n을 만족하는 가장 큰 n을 찾는 문제이다.

KMP 알고리즘에 대해 제대로 배워왔다면 쉽게 풀 수 있는 문제이다. 문자열의 실패함수를 이용한다면 해결할 수 있다. 실패함수를 거치면 pi속에는 접두사와 접미사가 같은 부분의 길이가 나타나있다.

만약 특정 패턴 A가 4번 반복된 문자열 S = AAAA 가 주어진다고 생각해보자. AAA라는 패턴으로 접두사와 접미사가 같기 때문에 마지막 문자의 pi값은 AAA가 끝나는 지점을 나타내줄 것이다. 따라서 A 패턴의 길이는 Length of A = string.count - pi[last]가 된다.

이제 A의 길이를 알았으니 전체 문자열 S에서 A의 길이를 뺐을 때 나머지가 A의 길이로 나뉜다면 S-A가 A패턴의 제곱으로 이루어져있다는 것을 알 수 있다. 최종적으로는 S가 A패턴의 제곱으로 이루어져있다면 n = string.count / Length of A로 n을 구할 수 있다.

전체 코드

func makepi(str: [Character]) -> [Int] {
    var j = 0
    var pi = Array(repeating: 0, count: str.count)
    for i in 1..<str.count {
        while j > 0 && str[i] != str[j] {
            j = pi[j-1]
        }
        if str[i] == str[j] {
            j += 1
            pi[i] = j
        }
    }
    return pi
}

while let line = readLine() {
    if line == "." {
        break
    }
    let S = line.map{Character(String($0))}
    let pi = makepi(str: S)
    let last = pi.last!
    let length = S.count - last
    if last == 0 || (S.count-length)%length != 0{
        print(1)
    }
    else {
        print(S.count / length)
    }
}

백준 11493 동전 교환

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11493

정점이 주어지고 정점간의 간선들이 주어진다고 하자. 각 정점마다 B/W 색깔이 존재하고 각 정점마다 동전이 하나씩 존재한다고 했을 때 동전 역시 색깔이 B/W로 존재한다고 하자. 만약 동전과 정점의 색깔이 일치하지 않을 경우 동전을 주위 정점과 바꾸어가면서 모든 정점과 동전의 색깔을 일치하게 만든다고 할 때 최소 동전 교환 횟수를 구하는 문제이다.

굉장히 풀기 어려운 문제…. 동전 교환 문제를 MCMF 그래프로 전환시키기 매우 어려운 문제이다. 먼저 우리는 동전을 교환하는 최솟값을 구해야하기 때문에 cost값이 동전 교환 횟수가 되야함을 알 수 있다. 따라서 각 간선마다 cost 비용을 1로 설정해주면 해당 간선을 따라 동전을 교환할 시 횟수만큼 cost 값이 증가함을 알 수 있다.

cost[u][v] = 1

그렇다면 간선을 따라서 동전을 교환하는 행위를 flow라고 했을 때 동일한 간선에서 몇번이고 일어날 수 있기 때문에 capacity를 INF로 설정해줘야 함을 짐작할 수 있다.

capacity[u][v] = INF

최종적으로 동전과 정점의 색깔이 다른 정점들만을 골라내서 동전이 흑색일 경우 source와 capacity = 1, cost = 0의 연결을 하고 백색일 경우 sink와 동일하게 연결해 준다. 생각해보면 흑색 동전이 백색 동전의 위치로 이동하는 문제이기 때문에 이렇게 설정해 주었다. Flow/Capacity를 표기해서 문제에 주어진 예시의 그래프를 다시 그려보면 다음과 같다.

따라서 흑색 동전을 따라 flow가 흐르면 그래프 내부에서 여러 정점을 돌아다니면서 flow가 흘러가고 그 때 최소 횟수만에 백색 동전의 위치에 도착하는 경우는 MCMF 알고리즘으로 minimum cost를 구해내는 것과 같다는 것을 알 수 있다.

전체 코드

let INF = 1_000_000_007

struct MCMF {
    struct Edge {
        var to:Int
        var rev:Int
        var cap:Int
        var cst:Int
    }
    var edge:[[Edge]]
    var parent:[(Int, Int)]
    var n:Int
    var src:Int
    var snk:Int
    init(n: Int, src: Int, snk: Int) {
        self.n = n
        self.src = src
        self.snk = snk
        edge = Array(repeating: [], count: n+5)
        parent = Array(repeating: (-1, -1), count: n+5)
    }
    
    mutating func addEdge(a: Int, b: Int, capa: Int, cost: Int) {
        edge[a].append(Edge(to: b, rev: edge[b].count, cap: capa, cst: cost))
        edge[b].append(Edge(to: a, rev: edge[a].count-1, cap: 0, cst: -cost))
    }
    
    mutating func SPFA() -> Bool {
        var inq = Array(repeating: false, count: n+5)
        var dst = Array(repeating: INF, count: n+5)
        var q = [Int]()
        q.append(src)
        dst[src] = 0
        inq[src] = true
        while !q.isEmpty {
            let curr = q.removeFirst()
            inq[curr] = false
            for i in 0..<edge[curr].count {
                let currEdge = edge[curr][i]
                if currEdge.cap <= 0 {
                    continue
                }
                if dst[curr] < INF && dst[currEdge.to] > dst[curr] + currEdge.cst {
                    dst[currEdge.to] = dst[curr] + currEdge.cst
                    parent[currEdge.to] = (curr, i)
                    if !inq[currEdge.to] {
                        inq[currEdge.to] = true
                        q.append(currEdge.to)
                    }
                }
            }
        }
        return dst[snk] != INF
    }
    
    mutating func flow() -> (Int, Int) {
        var totalFlow = 0, money = 0
        while SPFA() {
            var minFlow = INF, cost = 0, idx = snk
            while idx != src {
                let prevEdge = edge[parent[idx].0][parent[idx].1]
                minFlow = min(minFlow, prevEdge.cap)
                cost += prevEdge.cst
                idx = parent[idx].0
            }
            totalFlow += minFlow
            money += cost*minFlow
            idx = snk
            while idx != src {
                let prevEdge = edge[parent[idx].0][parent[idx].1]
                edge[parent[idx].0][parent[idx].1].cap -= minFlow
                edge[idx][prevEdge.rev].cap += minFlow
                idx = parent[idx].0
            }
        }
        return (totalFlow, money)
    }
}

let t = Int(readLine()!)!
var str = ""
for _ in 0..<t {
    let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
    let N = nm[0], M = nm[1]
    var mcmf = MCMF(n: N, src: N+1, snk: N+2)
    for _ in 0..<M {
        let line = readLine()!.split(separator: " ").map{Int(String($0))!}
        mcmf.addEdge(a: line[0], b: line[1], capa: INF, cost: 1)
        mcmf.addEdge(a: line[1], b: line[0], capa: INF, cost: 1)
    }
    let node = readLine()!.split(separator: " ").map{Int(String($0))!}
    let coin = readLine()!.split(separator: " ").map{Int(String($0))!}
    for i in 0..<N {
        if node[i] != coin[i] {
            if coin[i] == 0 {
                mcmf.addEdge(a: mcmf.src, b: i+1, capa: 1, cost: 0)
            }
            else {
                mcmf.addEdge(a: i+1, b: mcmf.snk, capa: 1, cost: 0)
            }
        }
    }
    str += "\(mcmf.flow().1)\n"
    
}
print(str)

백준 11409 열혈강호 6

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11409

열혈강호 문제의 6번째 확장판. MCMF에서는 그동안 최소 비용 최대 플로우를 구했다면 최대 비용 최대 플로우를 구하는 문제이다. 생각해보면 flow를 구하는 과정은 동일할 것이기 때문에 최소 비용이 아닌 최대 비용으로 경로를 구하는 것이 핵심이다. 따라서 SPFA 알고리즘을 다음과 같이 수정해야 한다.

SPFA 알고리즘 일부

while !queue.isEmpty {
    let curr = queue.removeFirst()
    inq[curr] = false
    for next in edge[curr] {
        if c[curr][next] - f[curr][next] <= 0 {
            continue
            // flow가 흐를 수 없는 경로는 continue
        }
        if dst[curr] < INF && (dst[next] == INF || dst[next] < dst[curr]+d[curr][next]) {
            dst[next] = dst[curr]+d[curr][next]
            parent[next] = curr
            if !inq[next] {
                queue.append(next)
                inq[next] = true
            }
        }
    }
}

그동안은 값이 작다면 업데이트를 시켜주고 queue에 집어넣었다면 이번에는 값이 클 경우에만 업데이트를 시켜주고 queue에 집어넣는 방식으로 구현했다. dst[next]에 값이 입력된 적이 없는 default 상태일 경우 예외처리를 해줘야 함을 확인하자. 나머지 코드는 열혈강호 5의 코드와 동일하게 MCMF 알고리즘을 그대로 동작시키면 된다.

전체 코드

let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nm[0], m = nm[1]
let s = 0, e = n+m+1, INF = 1_000_000_007
var c:[[Int]] = Array(repeating: Array(repeating: 0, count: n+m+2), count: n+m+2)
var f:[[Int]] = Array(repeating: Array(repeating: 0, count: n+m+2), count: n+m+2)
var d:[[Int]] = Array(repeating: Array(repeating: 0, count: n+m+2), count: n+m+2)
var edge:[[Int]] = Array(repeating: [], count: n+m+2)
var parent:[Int] = Array(repeating: -1, count: n+m+2)

func SPFA() -> Bool {
    var dst = Array(repeating: INF, count: n+m+2)
    var inq = Array(repeating: false, count: n+m+2)
    var queue = [Int]()
    queue.append(s)
    inq[s] = true
    dst[s] = 0
    while !queue.isEmpty {
        let curr = queue.removeFirst()
        inq[curr] = false
        for next in edge[curr] {
            if c[curr][next] - f[curr][next] <= 0 {
                continue
            }
            if dst[curr] < INF && (dst[next] == INF || dst[next] < dst[curr]+d[curr][next]) {
                dst[next] = dst[curr]+d[curr][next]
                parent[next] = curr
                if !inq[next] {
                    queue.append(next)
                    inq[next] = true
                }
            }
        }
    }
    return dst[e] != INF
}

func flow() -> (Int, Int) {
    var totalFlow = 0, money = 0
    while SPFA() {
        var idx = e, cost = 0, minF = INF
        while idx != s {
            let prev = parent[idx]
            minF = min(minF, c[prev][idx]-f[prev][idx])
            cost += d[prev][idx]
            idx = prev
        }
        idx = e
        while idx != s {
            let prev = parent[idx]
            f[prev][idx] += minF
            f[idx][prev] -= minF
            idx = prev
        }
        money += cost*minF
        totalFlow += minF
    }
    return (totalFlow, money)
}

func addEdge(s: Int, e: Int, val: Int) {
    edge[s].append(e)
    edge[e].append(s)
    c[s][e] += val
}

for i in 1...n {
    addEdge(s: s, e: i, val: 1)
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    for j in 0..<line[0] {
        let workIdx = n+line[2*j+1], cost = line[2*j+2]
        addEdge(s: i, e: workIdx, val: 1)
        d[i][workIdx] = cost
        d[workIdx][i] = -cost
    }
}
for i in n+1...n+m {
    addEdge(s: i, e: e, val: 1)
}
let result = flow()
print(result.0)
print(result.1)

백준 11408 열혈강호 5

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11408

열혈강호 문제의 MCMF 확장판. 문제 자체는 MCMF 알고리즘을 그대로 쓰면 되기때문에 어렵지 않다.

source에서 각 사원에게 1 capacity의 edge를 추가시켜주고 각 사원마다 할 수 있는 일에게 1 capacity의 edge를 추가시켜준다. 이 때 사원에서 일의 정점으로 edge를 추가할 때 cost값도 업데이트를 해줘야 한다는 것을 기억하자. 최종적으로 일에서 sink로 1 capacity의 edge를 추가해준뒤 MCMF 알고리즘을 돌리면 끝이다.

전체 코드

let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nm[0], m = nm[1]
let s = 0, e = n+m+1, INF = 1_000_000_007
var c:[[Int]] = Array(repeating: Array(repeating: 0, count: n+m+2), count: n+m+2)
var f:[[Int]] = Array(repeating: Array(repeating: 0, count: n+m+2), count: n+m+2)
var d:[[Int]] = Array(repeating: Array(repeating: 0, count: n+m+2), count: n+m+2)
var edge:[[Int]] = Array(repeating: [], count: n+m+2)
var parent:[Int] = Array(repeating: -1, count: n+m+2)

func SPFA() -> Bool {
    var dst = Array(repeating: INF, count: n+m+2)
    var inq = Array(repeating: false, count: n+m+2)
    var queue = [Int]()
    queue.append(s)
    inq[s] = true
    dst[s] = 0
    while !queue.isEmpty {
        let curr = queue.removeFirst()
        inq[curr] = false
        for next in edge[curr] {
            if c[curr][next] - f[curr][next] <= 0 {
                continue
            }
            if dst[curr] < INF && dst[next] > dst[curr]+d[curr][next] {
                dst[next] = dst[curr]+d[curr][next]
                parent[next] = curr
                if !inq[next] {
                    queue.append(next)
                    inq[next] = true
                }
            }
        }
    }
    return dst[e] != INF
}

func flow() -> (Int, Int) {
    var totalFlow = 0, money = 0
    while SPFA() {
        var idx = e, cost = 0, minF = INF
        while idx != s {
            let prev = parent[idx]
            minF = min(minF, c[prev][idx]-f[prev][idx])
            cost += d[prev][idx]
            idx = prev
        }
        idx = e
        while idx != s {
            let prev = parent[idx]
            f[prev][idx] += minF
            f[idx][prev] -= minF
            idx = prev
        }
        money += cost*minF
        totalFlow += minF
    }
    return (totalFlow, money)
}

func addEdge(s: Int, e: Int, val: Int) {
    edge[s].append(e)
    edge[e].append(s)
    c[s][e] += val
}

for i in 1...n {
    addEdge(s: s, e: i, val: 1)
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    for j in 0..<line[0] {
        let workIdx = n+line[2*j+1], cost = line[2*j+2]
        addEdge(s: i, e: workIdx, val: 1)
        d[i][workIdx] = cost
        d[workIdx][i] = -cost
    }
}
for i in n+1...n+m {
    addEdge(s: i, e: e, val: 1)
}
let result = flow()
print(result.0)
print(result.1)

백준 13161 분단의 슬픔

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/13161

n 명의 사람이 A진영과 B진영으로 나뉘어 들어갈 때 각 사람이 서로 다른 진영에 들어갈 때 슬픔 정도 w가 주어진다고 하자. 슬픔 정도의 합이 최소가 되도록 사람들을 A진영과 B진영으로 나누는 방법을 구하는 문제이다. 문제를 풀기전에 다음 이론 하나만 보고 가자.

1. Max Flow Min Cut

그래프의 선분들을 잘라내어 정점들을 2개의 서로 다른 집합으로 나누는 방법 중 가중치의 합이 최소일 때를 min cut이라고 하면 그 값은 max flow와 같다.

생각해보면 min cut에 포함된 간선들을 따라서 유량이 흐른다고 했을 때 min cut의 값은 간선들의 capacity의 합과 같다. 모든 유량은 결국 min cut에 포함된 간선들의 capacity합을 넘을 수 없게 된다. 따라서 해당 그래프의 최대 유량은 min cut과 같은 값을 갖게 되는 것이다.

2. 문제 풀이

다시 문제로 돌아와서 우리는 A진영에 속한 사람과 B진영에 속한 사람들의 슬픔 정도의 합의 최소를 찾고싶다. 모든 사람들을 하나의 정점으로 보고 서로간의 슬픔 정도를 capacity로 갖는 간선을 그린다고 하자. 이 경우 최대 유량을 구하면 capacity의 최소컷을 구할 수 있게 되고 이는 사람들을 A진영과 B진영으로 나누는 슬픔정도의 합과 같게 된다.

source와 sink는 어떻게 처리해야 할지에 대해 고민이 될 수 있다. 만약 A진영에 속한 사람과 source간에 capacity를 INF로 주고 B진영에 속한 사람과 sink간에 capacity를 INF로 준다고 하자. 그러면 A진영에 속해야 하는 사람은 INF를 min cut에 포함시킬 순 없기 때문에 무조건 A진영에 속하게 되고 B진영에 속해야 하는 사람은 무조건 B진영에 속할 수 있게 된다.

모든 V간에 edge가 연결되어 있는 형태이기 때문에 E의 갯수가 굉장히 크게 된다. 따라서 edmond 알고리즘을 쓰면 시간 초과가 나타나서 dinic 알고리즘을 활용하였다.

파일의 입력이 크기때문에 fread를 해줘야 시간초과가 안난다. 관련 코드는 JCSooHwanCho님의 FileIO.swift 를 참조하였다.
<출처 : https://gist.github.com/JCSooHwanCho/30be4b669321e7a135b84a1e9b075f88>

전체 코드

/*
 fread 코드는 JCSooHwanCho님의 FileIO.swift 를 참조하였습니다.
 <출처 : https://gist.github.com/JCSooHwanCho/30be4b669321e7a135b84a1e9b075f88>
*/
import Foundation

final class FileIO {
    private let buffer:[UInt8]
    private var index: Int = 0

    init(fileHandle: FileHandle = FileHandle.standardInput) {
        buffer = Array(try! fileHandle.readToEnd()!)+[UInt8(0)] // 인덱스 범위 넘어가는 것 방지
    }

    @inline(__always) private func read() -> UInt8 {
        defer { index += 1 }
        return buffer[index]
    }

    @inline(__always) func readInt() -> Int {
        var sum = 0
        var now = read()
        var isPositive = true

        while now == 10
                || now == 32 { now = read() } // 공백과 줄바꿈 무시
        if now == 45 { isPositive.toggle(); now = read() } // 음수 처리
        while now >= 48, now <= 57 {
            sum = sum * 10 + Int(now-48)
            now = read()
        }

        return sum * (isPositive ? 1:-1)
    }

    @inline(__always) func readString() -> String {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return String(bytes: Array(buffer[beginIndex..<(index-1)]), encoding: .ascii)!
    }

    @inline(__always) func readByteSequenceWithoutSpaceAndLineFeed() -> [UInt8] {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return Array(buffer[beginIndex..<(index-1)])
    }
}

let fIO = FileIO()
let n = fIO.readInt()
let INF = 1_000_000_007
let s = 501, e = 502
var level:[Int] = Array(repeating: -1, count: 555)
var edge:[[Int]] = Array(repeating: [], count: 555)
var c:[[Int]] = Array(repeating: Array(repeating: 0, count: 555), count: 555)
var f:[[Int]] = Array(repeating: Array(repeating: 0, count: 555), count: 555)
var work:[Int] = Array(repeating: 0, count: 555)

func addEdge(s: Int, e: Int, val: Int) {
    edge[s].append(e)
    edge[e].append(s)
    c[s][e] += val
}

func bfs() -> Bool {
    level = Array(repeating: -1, count: 555)
    var q = [Int]()
    level[s] = 1
    q.append(s)
    while !q.isEmpty {
        let curr = q.removeFirst()
        for i in edge[curr] {
            if level[i] == -1 && c[curr][i] - f[curr][i] > 0 {
                level[i] = level[curr] + 1
                q.append(i)
            }
        }
    }
    return level[e] != -1
}

func dfs(curr: Int, flow: Int) -> Int {
    if curr == e {
        return flow
    }
    let nextVertex = work[curr]
    for i in nextVertex..<edge[curr].count {
        let next = edge[curr][i]
        if level[next] == level[curr] + 1 && c[curr][next] - f[curr][next] > 0 {
            let tmp = dfs(curr: next, flow: min(flow, c[curr][next] - f[curr][next]))
            if tmp > 0 {
                f[curr][next] += tmp
                f[next][curr] -= tmp
                return tmp
            }
        }
        work[curr] += 1
    }
    return 0
}

func dinic() -> Int {
    var totalFlow = 0
    while bfs() {
        work = Array(repeating: 0, count: 555)
        while true {
            let tmpflow  = dfs(curr: s, flow: INF)
            if tmpflow == 0 {
                break
            }
            totalFlow += tmpflow
        }
    }
    return totalFlow
}

for i in 1...n {
    let v = fIO.readInt()
    if v == 1 {
        addEdge(s: s, e: i, val: INF)
    }
    else if v == 2 {
        addEdge(s: i, e: e, val: INF)
    }
}
for i in 1...n {
    for j in 1...n {
        let w = fIO.readInt()
        if i == j {
            continue
        }
        addEdge(s: i, e: j, val: w)
    }
}

print(dinic())
var a = "", b = ""
for i in 1...n {
    if level[i] != -1 {
        a += "\(i) "
    }
    else {
        b += "\(i) "
    }
}
print(a)
print(b)

백준 2316 도시 왕복하기 2

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2316

1번 도시와 2번 도시 사이를 왔다 가려는데 이 때 한번 방문한 도시는 두 번 이상 거치지 않으려고 한다고 한다. 1번 도시와 2번 도시를 왔다 갔다 하는 최대 횟수를 구하는 문제이다. 신기하게도 정점을 1번만 방문하도록 설정해줘야 하는 문제이다.

정점 분할 이라는 개념을 사용할 것인데 정점을 in과 out으로 분할하여 둘 사이의 용량을 1로 설정해주는 기법이다. 이렇게 되면 해당 정점은 1만큼의 flow를 흘릴 수 있기 때문에 최대 1번만 방문이 가능해진다. 이 때 양방향 간선인지 단방향 간선인지에 따라 정점 분할의 형태가 달라진다.

단방향 간선

양방향 간선

따라서 만약 A 도시에서 B 도시간에 양방향 길이 있다면 A_out과 B_in 간에 capacity 1을 설정해주고 B_out과 A_in 간에도 마찬가지로 설정해준다. 이 때 모든 도시 내부의 in 노드와 out 노드 간에도 1의 capacity를 부여해줘야한다. edge 설정이 끝났다면 1번 도시와 2번 도시 사이의 최대 유량을 구해주면 된다.

전체 코드

let np = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = np[0], p = np[1]
var c:[[Int]] = Array(repeating: Array(repeating: 0, count: 2*n+1), count: 2*n+1)
var f:[[Int]] = Array(repeating: Array(repeating: 0, count: 2*n+1), count: 2*n+1)
var edge:[[Int]] = Array(repeating: [], count: 2*n+1)
for _ in 0..<p {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    makeEdge(s: 2*line[0], e: 2*line[1]-1, val: 1)
    makeEdge(s: 2*line[1], e: 2*line[0]-1, val: 1)
}
for i in 1...n {
    edge[2*i-1].append(2*i)
    c[2*i-1][2*i] = 1
}
print(edward(s: 2, e: 3))

func makeEdge(s: Int, e: Int, val: Int) {
    edge[s].append(e)
    edge[e].append(s)
    c[s][e] += val
}

func edward(s: Int, e: Int) -> Int {
    var result = 0
    while true {
        var parent:[Int] = Array(repeating: -1, count: 2*n+1)
        var q:[Int] = []
        parent[s] = s
        q.append(s)
        loop: while !q.isEmpty {
            let curr = q.removeFirst()
            for next in edge[curr] {
                if c[curr][next]-f[curr][next] > 0 && parent[next] == -1 {
                    parent[next] = curr
                    q.append(next)
                    if next == e {
                        break loop
                    }
                }
            }
        }
        if parent[e] == -1 {
            break
        }
        var idx = e
        var minF = 1_000_000_000
        while idx != s {
            let prev = parent[idx]
            minF = min(minF, c[prev][idx]-f[prev][idx])
            idx = prev
        }
        idx = e
        while idx != s {
            let prev = parent[idx]
            f[prev][idx] += minF
            f[idx][prev] -= minF
            idx = prev
        }
        result += minF
    }
    return result
}

백준 14750 Jerry and Tom

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/14750

집의 코너 수 n, 각 구멍마다 쥐를 숨길 수 있는 마리 수 k, 구멍의 수 h, 쥐의 수 m이 주어지고 이어서 코너 정보와 구멍 위치와 쥐의 위치가 주어진다고 하자. 쥐는 눈에 보이는 구멍에만 숨을 수 있다고 했을 때 모든 쥐를 숨길 수 있는지 여부를 나타내는 문제이다.

핵심이 되는 네트워크 플로우 알고리즘은 기존 것을 사용하면 되는데 edge와 capacity 설정이 어려운 문제이다. 일단 각각의 쥐들과 구멍들을 하나의 정점으로 보자. 모든 구멍은 source와 k만큼의 capacity를 갖도록 연결시키고 구멍에서 쥐로 1의 capacity를 갖는 edge로 연결시키자. 마지막으로 쥐와 sink간에는 1의 capacity를 갖는 edge로 연결한다고 하자.

이렇게 되면 source부터 sink까지 최대 유량이 m이 나오게 되면 모든 쥐를 통해 flow가 1씩 흐른다는 소리이므로 구멍에 쥐들을 숨기는 것이 가능하다는 의미가 된다. 따라서 에드몬드 알고리즘을 활용해서 구현이 가능하다.

Edge&Capacity Set Code

for i in 0..<h {
    for j in 0..<m {
        if !crash(hole: hole[i], mouse: mouse[j]) {
            makeEdge(s: i+1, e: h+j+1, val: 1)
        }
    }
    makeEdge(s: s, e: i+1, val: k)
}
for i in h+1...h+m {
    makeEdge(s: i, e: e, val: 1)
}

단 유의할 것은 쥐의 좌표와 구멍의 좌표가 주어졌을 때 둘이 벽에 의해 가로막히지 않을 경우에만 edge를 연결시켜준다는 것이다. 따라서 기하학적인 함수들이 사용되는데 선분간의 만남 여부를 확인해주는 파트는 공부를 하고 보는 것을 추천드린다.

쥐와 구멍의 좌표가 하나씩 주어지면 집의 모든 벽에 대해서 쥐와 구멍을 이은 선분과 모든 벽 선분이 만나는 적이 있는지 확인해주고 만난다면 쥐가 구멍을 볼 수 없다는 뜻이므로 edge 추가를 해주지 않는다.

전체 코드

let nkhm = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nkhm[0], k = nkhm[1], h = nkhm[2], m = nkhm[3]
var corner = Array(repeating: (0, 0), count: n)
var hole = Array(repeating: (0, 0), count: h)
var mouse = Array(repeating: (0, 0), count: m)
let s = 0, e = h+m+1
var c:[[Int]] = Array(repeating: Array(repeating: 0, count: e+1), count: e+1)
var f:[[Int]] = Array(repeating: Array(repeating: 0, count: e+1), count: e+1)
var edge:[[Int]] = Array(repeating: [], count: e+1)

for i in 0..<n {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    corner[i] = (line[0], line[1])
}
for i in 0..<h {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    hole[i] = (line[0], line[1])
}
for i in 0..<m {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    mouse[i] = (line[0], line[1])
}

for i in 0..<h {
    for j in 0..<m {
        if !crash(hole: hole[i], mouse: mouse[j]) {
            makeEdge(s: i+1, e: h+j+1, val: 1)
        }
    }
    makeEdge(s: s, e: i+1, val: k)
}
for i in h+1...h+m {
    makeEdge(s: i, e: e, val: 1)
}
if edward(s: 0, e: e) == m {
    print("Possible")
}
else {
    print("Impossible")
}

func makeEdge(s: Int, e: Int, val: Int) {
    edge[s].append(e)
    edge[e].append(s)
    c[s][e] += val
}

func ccw(a: (Int, Int), b: (Int, Int), c: (Int, Int)) -> Int {
    let result:CLongLong = CLongLong(b.0-a.0)*CLongLong(c.1-a.1) - CLongLong(b.1-a.1)*CLongLong(c.0-a.0)
    return result > 0 ? 1 : (result == 0 ? 0 : -1)
}

func meet(a1: (Int, Int), a2: (Int, Int), b1: (Int, Int), b2: (Int, Int)) -> Bool {
    let ccw1 = ccw(a: a1, b: a2, c: b1)
    let ccw2 = ccw(a: a1, b: a2, c: b2)
    let ccw3 = ccw(a: b1, b: b2, c: a1)
    let ccw4 = ccw(a: b1, b: b2, c: a2)
    if ccw1 == 0 && ccw2 == 0 && ccw3 == 0 && ccw4 == 0 {
        var A = a1, B = a2, C = b1, D = b2
        if A > B {
            swap(&A, &B)
        }
        if C > D {
            swap(&C, &D)
        }
        return C <= B && A <= D
    }
    return ccw1*ccw2 <= 0 && ccw3*ccw4 <= 0
}

func crash(hole: (Int, Int), mouse: (Int, Int)) -> Bool {
    for i in 0..<n {
        let j = (i+1)%n
        if hole.0 == corner[i].0 && hole.0 == corner[j].0 {
            continue
        }
        if hole.1 == corner[i].1 && hole.1 == corner[j].1 {
            continue
        }
        if meet(a1: hole, a2: mouse, b1: corner[i], b2: corner[j]) {
            return true
        }
    }
    return false
}

func edward(s: Int, e: Int) -> Int {
    var result = 0
    while true {
        var parent:[Int] = Array(repeating: -1, count: e+1)
        var q:[Int] = []
        parent[s] = s
        q.append(s)
        loop: while !q.isEmpty {
            let curr = q.removeFirst()
            for next in edge[curr] {
                if c[curr][next]-f[curr][next] > 0 && parent[next] == -1 {
                    parent[next] = curr
                    q.append(next)
                    if next == e {
                        break loop
                    }
                }
            }
        }
        if parent[e] == -1 {
            break
        }
        var idx = e
        var minF = 1_000_000_000
        while idx != s {
            let prev = parent[idx]
            minF = min(minF, c[prev][idx]-f[prev][idx])
            idx = prev
        }
        idx = e
        while idx != s {
            let prev = parent[idx]
            f[prev][idx] += minF
            f[idx][prev] -= minF
            idx = prev
        }
        result += minF
    }
    return result
}

백준 11378 열혈강호 4

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11378

열혈강호 문제의 확장판으로 K라는 벌점이 주어지는데 이만큼 직원들이 추가로 일을 해낼 수 있다. 이분 매칭에서만보다가 네트워크 플로우로 적용시키려니 난감할 수 있지만 K라는 벌점을 부과해주는 새로운 정점을 하나 생성한다. 만약 해당 정점과 모든 사람들의 정점을 각각 K capacity를 갖는 edge로 연결해주면 손쉽게 구할 수 있다.

단 source에서 K 정점으로도 K capacity를 갖는 edge로 연결해주어 모든 사람들이 추가로 하는 일의 양이 K를 넘지 않도록 해준다.

그 외에는 source와 사람간에는 1 capacity로 사람과 일에도 1capacity로 일과 sink간에 1 capacity로 연결해준 뒤 최대 유량을 구해주면 된다. 앞에서 배운 에드몬드 카프 알고리즘을 활용했다.

전체 코드

let nmk = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nmk[0], m = nmk[1], k = nmk[2]
let s = 0, bridge = n+m+1, e = n+m+2
var c:[[Int]] = Array(repeating: Array(repeating: 0, count: e+1), count: e+1)
var f:[[Int]] = Array(repeating: Array(repeating: 0, count: e+1), count: e+1)
var edge:[[Int]] = Array(repeating: [], count: e+1)

// 0이 스타트 n+m+1이 bridge n+m+2가 end
for i in 1...n {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    for j in 0..<line[0] {
        let mIdx = n+line[j+1]
        addEdge(s: i, e: mIdx, val: 1)
    }
    addEdge(s: s, e: i, val: 1)
    addEdge(s: bridge, e: i, val: k)
}
addEdge(s: s, e: bridge, val: k)
for i in n+1...n+m {
    addEdge(s: i, e: e, val: 1)
}
print(edward(s: s, e: e))


func addEdge(s: Int, e: Int, val: Int) {
    edge[s].append(e)
    edge[e].append(s)
    c[s][e] += val
}

func edward(s: Int, e: Int) -> Int {
    var result = 0
    while true {
        var parent:[Int] = Array(repeating: -1, count: e+1)
        var q:[Int] = []
        parent[s] = s
        q.append(s)
        while !q.isEmpty && parent[e] == -1 {
            let curr = q.removeFirst()
            for i in edge[curr] {
                if c[curr][i] - f[curr][i] > 0 && parent[i] == -1 {
                    parent[i] = curr
                    q.append(i)
                }
            }
        }
        if parent[e] == -1 {
            break
        }
        var idx = e
        var minF = 1_000_000_000
        while idx != s {
            let prev = parent[idx]
            minF = min(minF, c[prev][idx] - f[prev][idx])
            idx = prev
        }
        idx = e
        while idx != s {
            let prev = parent[idx]
            f[prev][idx] += minF
            f[idx][prev] -= minF
            idx = prev
        }
        result += minF
    }
    return result
}

백준 11014 컨닝 2

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11014

NxM의 배열이 주어지면 x표시가 아닌 자리에 학생들을 배치시킨다고 하자. 이 때 학생이 좌측, 우측, 좌측상단, 우측상단에 다른 학생이 위치하면 컨닝을 할 수 있다고 했을 때 아무도 컨닝을 할 수 없도록 하면서 배치할 수 있는 학생의 최대 수를 구하는 문제이다.

핵심 포인트는 바로 옆 열에 위치한 학생들끼리만 컨닝이 가능하는 것이다. 따라서 홀수 열에 해당하는 자리는 그룹 A로 짝수 열에 해당하는 자리를 그룹 B로 나누어 이분매칭 그래프를 그려보자.

우리는 되도록 홀수열에 학생을 무조건 앉히고 만약 짝수열에도 자리를 앉힐 수 있다면 앉히도록 할 것이다. 이 때 구해지는 최대 매칭은 홀수열에 학생들을 배치 시켰을 때 앉을 수 없는 짝수열 자리의 수와 같다는 것이다. 이 때 그래프를 그릴 때 x표시가 된 자리는 그래프에 그려주지 않도록 한다. 최종적으로 구하는 결과는 전체 자리의 수에서 x표시가 된 자리의 갯수와 최대 매칭으로 구한 자리의 수를 빼주면 된다.

전체 코드

var left:[(Int, Int)] = []
var right:[(Int, Int)] = []
var left2right:[[Int]] = []
var check:[Bool] = []
var right2left:[Int] = []

func isNear(a: (Int, Int), b: (Int, Int)) -> Bool {
    let dx = a.0 - b.0
    let dy = a.1 - b.1
    return dx*dx+dy*dy <= 2
}

func dfs(leftIdx: Int) -> Bool {
    for rightIdx in left2right[leftIdx] {
        if check[rightIdx] {
            continue
        }
        check[rightIdx] = true
        if right2left[rightIdx] == -1 || dfs(leftIdx: right2left[rightIdx]) {
            right2left[rightIdx] = leftIdx
            return true
        }
    }
    return false
}

let t = Int(readLine()!)!
var str = ""
for _ in 0..<t {
    let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
    let n = nm[0], m = nm[1]
    var xCount = 0, result = 0
    left = []
    right = []
    for i in 0..<n {
        let line = readLine()!.map{Character(String($0))}
        for j in 0..<line.count {
            if line[j] == "." {
                if j%2 == 0 {left.append((i, j))}
                else {right.append((i, j))}
            }
            else {xCount += 1}
        }
    }
    let rcount = right.count, lcount = left.count
    left2right = Array(repeating: [], count: lcount)
    check = Array(repeating: false, count: rcount)
    right2left = Array(repeating: -1, count: rcount)
    for i in 0..<lcount {
        for j in 0..<rcount {
            if isNear(a: left[i], b: right[j]) {
                left2right[i].append(j)
            }
        }
    }
    
    for idx in 0..<lcount {
        check = Array(repeating: false, count:rcount)
        if dfs(leftIdx: idx) {
            result += 1
        }
    }
    str += "\(n*m-xCount-result)\n"
}
print(str)

백준 1867 돌멩이 제거

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1867

n행 n열로 나뉜 운동장이 주어졌을 때 k개의 돌멩이가 있다고 하자. 한번에 1개의 행 혹은 1개의 열에 있는 돌멩이를 모두 치울 수 있다고 했을 때 최소한의 횟수로 돌멩이를 모두 치우는 방법을 구하는 문제이다. 쾨닉의 정리라는 기법을 사용해야 하는데 쾨닉의 정리에 대해 알아보기 전에 Vertex Cover에 대해 알아보자.

1. Vertex Cover

Vertex Cover : 정점 집합 S가 있을 때, 모든 간선의 양 끝점 중 하나가 S에 포함되어 있는 집합 S

예를 들어 다음 그래프의 경우 Vertex Cover 중 하나는 {A, B}에 해당한다.

Minimum Vertex Cover란 Vertex Cover 중 최소 길이의 집합을 의미한다. 위 그림의 경우 Vertex Cover로는 여러가지가 있겠지만 {A, B}가 최소의 길이를 갖는다.

2. 쾨닉의 정리

자 이제 쾨닉의 정리에 대해 알아보자. 증명까지는 안다루지만 이분 그래프의 최대 매칭을 구하면 모든 간선을 cover할 수 있다는 의미가 된다.

쾨닉의 정리 : 이분 그래프에서의 최대 매칭은 minimum vertex cover와 같다.

자 그러면 우리의 문제를 이분매칭 그래프로 표현해보자.

먼저 행과 열을 각각의 집합으로 생각하고 돌멩이가 위치한 행과 열 사이에 간선을 그려준다. 그렇게 되면 간선 하나당 돌멩이 하나를 의미하게 된다. 모든 돌멩이(간선)를 cover 할 수 있는 최소한의 정점은 달리기를 해야하는 행과 열을 각각 의미하게 된다. 따라서 쾨닉의 정리에 의해 최대 매칭을 구해주면 달리기 횟수를 구할 수 있다.

전체 코드

let nk = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nk[0], k = nk[1]
var row2col:[Int] = Array(repeating: -1, count: n+1)
var edge:[[Int]] = Array(repeating: [], count: n+1)
var visited:[Bool] = Array(repeating: false, count: n+1)
for _ in 0..<k {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    edge[line[0]].append(line[1])
}
func dfs(col: Int) -> Bool {
    for row in edge[col] {
        if visited[row] {
            continue
        }
        visited[row] = true
        if row2col[row] == -1 || dfs(col: row2col[row]) {
            row2col[row] = col
            return true
        }
    }
    return false
}
var r = 0
for i in 1...n {
    visited = Array(repeating: false, count: n+1)
    if dfs(col: i) {
        r += 1
    }
}
print(r)

백준 1671 상어의 저녁식사

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1671

상어가 본인보다 능력치가 낮거나 같은 다른 상어를 2마리까지 잡어먹을 수 있다고 했을 때 살아남을 수 있는 상어의 최솟값을 구하는 문제이다. 지금까지는 이분 매칭에서 두 그룹이 서로 다른 경우를 풀었었다면 이번 문제의 경우는 두 그룹이 같은 경우의 문제이다. 까다로워 보이지만 2가지만 유의해서 문제를 풀어보자.

두마리를 잡아먹을 수 있다는 부분은 같은 상어에 대해 2번의 dfs를 해주면 된다.
능력치가 같다면 서로를 잡아먹을 수 있기 때문에 이 경우 index가 낮은 상어가 높은 상어를 잡아먹도록 한다.

그 외에는 일반적인 이분매칭 문제와 똑같기 때문에 두가지만 유의해주면 된다.

전체 코드

let n = Int(readLine()!)!
var shark:[(Int, Int, Int)] = []
var visited:[Bool] = Array(repeating: false, count: n)
var eater:[Int] = Array(repeating: -1, count: n)
for _ in 0..<n {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    shark.append((line[0], line[1], line[2]))
}

func dfs(idx: Int) -> Bool {
    for i in 0..<n where i != idx {
        if visited[i] {
            continue
        }
        if shark[i].0 <= shark[idx].0 && shark[i].1 <= shark[idx].1 && shark[i].2 <= shark[idx].2 {
            if shark[i] == shark[idx] && idx >= i {
                continue
            }
            visited[i] = true
            if eater[i] == -1 || dfs(idx: eater[i]) {
                eater[i] = idx
                return true
            }
        }
    }
    return false
}

var result = 0
for i in 0..<n {
    visited = Array(repeating: false, count: n)
    if dfs(idx: i) {
        result += 1
    }
    visited = Array(repeating: false, count: n)
    if dfs(idx: i) {
        result += 1
    }
}
print(n-result)

백준 1017 소수 쌍

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1017

수의 리스트가 주어졌을 때 각 쌍의 합이 소수가 되게 하려고한다. 이 때 모든 수를 다 짝지을 수 있는 경우 중에서 첫번째 원소가 짝지은 수를 오름차순으로 나타내는 문제이다.

두 수의 합이 소수가 되려면 2를 제외하고는 모두 소수가 홀수라는 점을 이용해야한다. 리스트 내의 수는 중복이 될 수 없으므로 2가 소수 쌍으로 나타날 수는 없다. 따라서 모든 소수 쌍은 짝수 1개와 홀수 1개의 합으로 이루어져야 한다. 이렇게 되니 주어지는 수들을 홀수 짝수 그룹으로 나누는데 첫번째 원소가 A 그룹의 첫번째 원소가 되도록 그룹을 나누자.

Group Divide Code

for i in num {
    if num[0]%2 == i%2 {
        numA.append(i)
    }
    else {
        numB.append(i)
    }
}

이제 A그룹과 B그룹 간의 이분 매칭을 해서 전체의 절반에 해당하는 매칭이 이루어지는지 확인하면 된다. 이 때 유의할 점으로는 A그룹의 첫번째 원소의 매칭은 dfs 함수 내에서 고정시켜주고 진행해야 한다. 또한 두 수의 합이 소수인 경우에만 간선이 존재한다고 생각하고 진행해야한다.

DFS Function

func dfs(nodeA: Int) -> Bool {
    for nodeB in 0..<n/2 where nodeB != pick { 
    // pick은 첫번째 원소와 매칭된 정점을 의미한다.
        if visited[nodeB] {
            continue
        }
        if Prime[numA[nodeA] + numB[nodeB]] {
        // 두 수의 합이 소수인 경우에만 진행
            visited[nodeB] = true
            if matchB[nodeB] == -1 || dfs(nodeA: matchB[nodeB]) {
                matchB[nodeB] = nodeA
                return true
            }
        }
    }
    return false
}

전체 코드

let n = Int(readLine()!)!
let num = readLine()!.split(separator: " ").map{Int(String($0))!}
var matchB:[Int] = Array(repeating: -1, count: n/2)
var visited:[Bool] = Array(repeating: false, count: n/2)
var numA:[Int] = []
var numB:[Int] = []
var Prime:[Bool] = Array(repeating: true, count: 2001)
var pick = 0

func dfs(nodeA: Int) -> Bool {
    for nodeB in 0..<n/2 where nodeB != pick {
        if visited[nodeB] {
            continue
        }
        if Prime[numA[nodeA] + numB[nodeB]] {
            visited[nodeB] = true
            if matchB[nodeB] == -1 || dfs(nodeA: matchB[nodeB]) {
                matchB[nodeB] = nodeA
                return true
            }
        }
    }
    return false
}


for i in 2...50 {
    if Prime[i] {
        var idx = 2*i
        while idx <= 2000 {
            Prime[idx] = false
            idx += i
        }
    }
}

for i in num {
    if num[0]%2 == i%2 {
        numA.append(i)
    }
    else {
        numB.append(i)
    }
}

if numA.count != numB.count {
    print(-1)
}
else {
    var success:[Int] = []
    for j in 0..<n/2 {
        if Prime[numA[0] + numB[j]] {
            pick = j
            matchB = Array(repeating: -1, count: n/2)
            var count = 1
            for i in 1..<n/2 {
                visited = Array(repeating: false, count: n/2)
                if dfs(nodeA: i) {
                    count += 1
                }
            }
            if count == n/2 {
                success.append(numB[j])
            }
        }
    }
    success.sort{$0 < $1}
    var str = ""
    for i in success {
        str += "\(i) "
    }
    print(success.count > 0 ? str : "-1")
}

백준 11376 열혈강호 2

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11376

N명의 직원이 있고 M개의 일이 있다고 했을 때 각 직원별로 최대 2개의 일을 할 수 있다고 하자. 해낼 수 있는 최대 일의 갯수를 구하는 문제이다. 전형적인 이분매칭의 문제로 열혈강호 1에서 새로운 규칙 하나가 추가된 문제이다.

어려워 보일수도 있지만 사람의 수를 2배로 만들어 버리면 되는 간단한 문제이다. 이 후 최대 매칭의 갯수를 구해주면 된다.

전체 코드

let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nm[0], m = nm[1]
var work:[[Int]] = []
var visited:[Bool] = Array(repeating: false, count: m+1)
var work2Worker:[Int] = Array(repeating: -1, count: m+1)
var maxWork = 0

func dfs(worker: Int) -> Bool {
    let workCount = work[worker][0]
    for i in 1..<workCount+1 {
        let currWork = work[worker][i]
        if visited[currWork] {
            continue
        }
        visited[currWork] = true
        if work2Worker[currWork] == -1 || dfs(worker: work2Worker[currWork]) {
            work2Worker[currWork] = worker
            return true
        }
    }
    return false
}

for i in 0..<n {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    work.append(line)
    work.append(line)
    visited = Array(repeating: false, count: m+1)
    if dfs(worker: 2*i) {
        maxWork += 1
    }
    visited = Array(repeating: false, count: m+1)
    if dfs(worker: 2*i+1) {
        maxWork += 1
    }
}
print(maxWork)

백준 16367 TV Show Game

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/16367

문제를 간략히 해석해보자면 k 개의 램프와 n 명의 참가자가 있을 때 각 참가자는 최대 3개 까지 램프의 색깔을 예측한다. 이 때 램프의 색깔은 R, B 2가지로 각 참가자는 정답을 모른 채 예측을 해야한다. 만약 한 참가자가 2개 이상의 정답을 맞춘다면 경품을 받을 수 있을 때 모든 참가자가 경품을 받는 k 개의 램프 색깔을 순서대로 출력하는 문제이다.

3-SAT을 사용해야 하나 하고 착각할 수 있으나 2-SAT만으로 해결이 가능한 문제이다. 만약 참가자가 예측한 것을 각각 A B C 라고 하자. 이 때 2개 이상 예측 결과가 맞기 위해서는 (AVB), (BVC), (CVA) 세 묶음이 모두 참이 되야한다. 따라서 모든 사람에 대해 2-SAT 간선 연결을 해주고 2-SAT 알고리즘을 사용해 구해주면 된다.

Edge Set Code

N1 = (C1 == "R" ? 2*N1-1 : 2*N1-2)
N2 = (C2 == "R" ? 2*N2-1 : 2*N2-2)
N3 = (C3 == "R" ? 2*N3-1 : 2*N3-2)
edge[NotOper(n: N1)].append(N2)
edge[NotOper(n: N2)].append(N1)
edge[NotOper(n: N2)].append(N3)
edge[NotOper(n: N3)].append(N2)
edge[NotOper(n: N1)].append(N3)
edge[NotOper(n: N3)].append(N1)

전체 코드

var edge:[[Int]] = []
var visited:[Int] = []
var finished:[Bool] = []
var index = 1
var SCC:[[Int]] = []
var NodeSCC:[Int] = []
var stack:[Int] = []

func dfs(n: Int) -> Int {
    visited[n] = index
    index += 1
    stack.append(n)
    var parent = visited[n]
    for e in edge[n] {
        if visited[e] == 0 {
            parent = min(parent, dfs(n: e))
        }
        else if !finished[e] {
            parent = min(parent, visited[e])
        }
    }
    if parent == visited[n] {
        var tmpScc:[Int] = []
        let count = SCC.count
        while !stack.isEmpty {
            let tmpNode = stack.popLast()!
            tmpScc.append(tmpNode)
            finished[tmpNode] = true
            NodeSCC[tmpNode] = count
            if tmpNode == n {
                break
            }
        }
        SCC.append(tmpScc)
    }
    return parent
}

func NotOper(n: Int) -> Int {
    return (n%2 == 0 ? n+1 : n-1)
}


let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nm[0], m = nm[1]
edge = Array(repeating: [], count: 2*n)
visited = Array(repeating: 0, count: 2*n)
finished = Array(repeating: false, count: 2*n)
NodeSCC = Array(repeating: 0, count: 2*n)
index = 1
SCC = []
stack = []

for _ in 0..<m {
    let line = readLine()!.split(separator: " ").map{String($0)}
    var N1 = Int(line[0])!, C1 = line[1]
    var N2 = Int(line[2])!, C2 = line[3]
    var N3 = Int(line[4])!, C3 = line[5]
    N1 = (C1 == "R" ? 2*N1-1 : 2*N1-2)
    N2 = (C2 == "R" ? 2*N2-1 : 2*N2-2)
    N3 = (C3 == "R" ? 2*N3-1 : 2*N3-2)
    edge[NotOper(n: N1)].append(N2)
    edge[NotOper(n: N2)].append(N1)
    edge[NotOper(n: N2)].append(N3)
    edge[NotOper(n: N3)].append(N2)
    edge[NotOper(n: N1)].append(N3)
    edge[NotOper(n: N3)].append(N1)
}
for i in 0..<2*n {
    if visited[i] == 0 {
        dfs(n: i)
    }
}
var possible = true
for i in 0..<n {
    if NodeSCC[2*i] == NodeSCC[2*i+1] {
        possible = false
        break
    }
}
if possible {
    var result = Array(repeating: -1, count: n)
    for i in 0..<SCC.count {
        let currentSCC = SCC[SCC.count-1-i]
        for x in currentSCC {
            if result[x/2] == -1 {
                result[x/2] = x%2 // 0일떄 Red인쇄 1일떄 Blue인쇄
            }
        }
    }
    var str = ""
    for r in result {
        str += (r == 0 ? "R" : "B")
    }
    print(str)
}
else {
    print(-1)
}

백준 3648 아이돌

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/3648

심사위원들이 두 사람에 대해 찬성 혹은 반대의 의견을 낸다고 했을 때 적어도 하나의 의견은 투표 결과에 영향을 미쳐야한다고 하자. 이 때 상근이가 진출하도록 투표결과를 조작했을 때 심사위원들이 의심하지 않도록 할 수 있는지 여부를 알아내는 문제이다.

두 개의 의견 중 하나가 결과에 영향을 미쳐야 한다는 소리는 2-sat에서 두 개의 의견을 하나로 묶는 것과 같다. 즉 최소한 둘 중 하나가 참이 되도록 해야한다는 소리이다. 따라서 모든 심사위원의 의견에 대해 2-sat 그래프를 만들어주고 상근이를 합격이 되게 했을 때 2-sat 그래프가 참이 될 수 있는지를 알아내면 된다.

앞에서 쓴 2-SAT 알고리즘에 상근이가 불합격 한 경우에서 합격한 경우로 edge 하나만 추가해주자.

edge[NotOper(n: 0)].append(0)

2-sat 해를 구할 때 먼저 등장하는 케이스에 대해 false가 되도록 해를 구한다는 것을 기억할 것이다. 따라서 탈락하는 경우가 위상상 먼저 등장하게 되면 탈락이 false가 되기 때문에 상근이를 합격시킬 수 있게 된다. 최종적으로 그래프의 해가 존재하는지만 파악해주면 문제를 해결할 수 있다.

전체 코드

var edge:[[Int]] = []
var visited:[Int] = []
var finished:[Bool] = []
var index = 1
var SCC:[[Int]] = []
var NodeSCC:[Int] = []
var stack:[Int] = []

func dfs(n: Int) -> Int {
    visited[n] = index
    index += 1
    stack.append(n)
    var parent = visited[n]
    for e in edge[n] {
        if visited[e] == 0 {
            parent = min(parent, dfs(n: e))
        }
        else if !finished[e] {
            parent = min(parent, visited[e])
        }
    }
    if parent == visited[n] {
        var tmpScc:[Int] = []
        let count = SCC.count
        while !stack.isEmpty {
            let tmpNode = stack.popLast()!
            tmpScc.append(tmpNode)
            finished[tmpNode] = true
            NodeSCC[tmpNode] = count
            if tmpNode == n {
                break
            }
        }
        SCC.append(tmpScc)
    }
    return parent
}

func NotOper(n: Int) -> Int {
    return (n%2 == 0 ? n+1 : n-1)
}


while let l = readLine() {
    let nm = l.split(separator: " ").map{Int(String($0))!}
    let n = nm[0], m = nm[1]
    edge = Array(repeating: [], count: 2*n)
    visited = Array(repeating: 0, count: 2*n)
    finished = Array(repeating: false, count: 2*n)
    NodeSCC = Array(repeating: 0, count: 2*n)
    index = 1
    SCC = []
    stack = []

    for _ in 0..<m {
        let line = readLine()!.split(separator: " ").map{Int(String($0))!}
        var N1 = line[0], N2 = line[1]
        N1 = (N1 < 0 ? -(2*N1)-1 : 2*(N1-1))
        N2 = (N2 < 0 ? -(2*N2)-1 : 2*(N2-1))
        edge[NotOper(n: N1)].append(N2)
        edge[NotOper(n: N2)].append(N1)
    }
    edge[NotOper(n: 0)].append(0)
    for i in 0..<2*n {
        if visited[i] == 0 {
            dfs(n: i)
        }
    }
    var possible = true
    for i in 0..<n {
        if NodeSCC[2*i] == NodeSCC[2*i+1] {
            possible = false
            break
        }
    }
    print(possible ? "yes" : "no")
}

백준 4013 ATM

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/4013

어떤 출발장소에서 레스토랑 정점을 가려고 하는데 그래프 상의 모든 정점마다 현금 액수가 적혀있다고 하자. 레스토랑은 여러 곳의 정점에 위치해 있으며 그 중 어떤 것을 가든 상관이 없다. 이 때 정점에서 두번 이상 현금을 얻어낼 수 없다고 했을 때 레스토랑으로 이동하면서 얻어낼 수 있는 현금의 최대 액수를 구하는 문제이다.

입력도 엄청나게 많고 문제 조건도 많아서 복잡하지만 하나하나 살펴보도록하자. 먼저 그래프 상에는 사이클이 존재할 수 있기 때문에 사이클에 속하는 정점이라면 해당 사이클을 방문하면 사이클 내의 모든 돈을 챙길 수 있다. 그렇다면 사이클을 나타내기 위해서 SCC 알고리즘을 사용해 표현해보자. 나의 SCC 집합에는 다음과 같은 정보들이 들어있다.

var SCCTotalCash:[Int] = Array(repeating: 0, count: n+1) 
//해당 SCC집합의 모든 현금 액수
var SCCRestExist:[Bool] = Array(repeating: false, count: n+1) 
//SCC 집합 내에 레스토랑 존재여부
var SCCEdge:[Set<Int>] = Array(repeating: [], count: n+1) 
//SCC 집합 간의 edge관계
var SCCDP:[Int] = Array(repeating: -1, count: n+1) 
//현재 SCC집합에서 임의의 레스토랑을 방문할 떄 얻어낼 수 있는 현금의 최댓값

그렇다면 우리는 이제 이를 이용하여 문제를 풀어낼 것이다. SCC 집합을 구하고 해당 정보를 활용하기 위해 코사라주 알고리즘을 사용했다. 이때 dfsBack 함수를 다음과 같이 수정하도록 하자.

DFSBack Function

func dfsB(n: Int, sNum: Int) {
    SCC[n] = sNum
    SCCTotalCash[sNum] += atm[n]
    if rest[n] {
        SCCRestExist[sNum] = true
    }
    for e in edgeB[n] {
        if SCC[e] == 0 {
            dfsB(n: e, sNum: sNum)
        }
        else if SCC[e] != sNum {
            SCCEdge[SCC[e]].insert(sNum)
        }
    }
}

먼저 SCCTotalCash는 dfs 과정중 방문하는 정점의 현금 액수를 더해주고 방문 정점 중 하나라도 레스토랑에 해당한다면 SCCRestExist 값을 true로 설정해준다. 위상 관계상 먼저 와야 하는 SCC를 먼저 방문할 것이기 때문에 본인의 SCC와 SCC번호가 다른 집합을 발견한다면 본인의 SCC집합으로 들어오는 edge를 만들어준다.

DFS DP Function

func dfsSCC(n: Int) -> Int {
    if SCCDP[n] != -1 {
        return SCCDP[n]
    }
    else {
        var tmp = 0
        for e in SCCEdge[n] {
            tmp = max(tmp, dfsSCC(n: e))
        }
        if tmp != 0 || SCCRestExist[n] {
            tmp += SCCTotalCash[n]
        }
        SCCDP[n] = tmp
        return tmp
    }
}

이제 해당 정보들을 가지고 SCCDP 배열을 채워 줄 것이다. 유의할 것은 dp과정에서 restaurant 존재여부를 고려해주는 부분이다. 본인의 영역에 레스토랑이 존재한다면 본인의 영역의 total cash를 더해준다.

만약 edge로 이동해 다른 영역에서 구해낸 tmp값이 0이 아니라면 해당 경로로 이동하면 무조건 레스토랑에 도달할 수 있기 때문에 본인 영역의 total cash 값을 더해줄 수 있다. SCCDP의 의미는 현재 SCC집합에서 임의의 레스토랑을 방문할 떄 얻어낼 수 있는 현금의 최댓값이기 때문에 시작 정점이 포함된 SCC의 DP값을 알아내면 원하는 답을 구할 수 있게 된다.

전체 코드

let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nm[0], m = nm[1]
var edgeF:[[Int]] = Array(repeating: [], count: n+1)
var edgeB:[[Int]] = Array(repeating: [], count: n+1)
var check:[Bool] = Array(repeating: false, count: n+1)
var ft:[Int] = Array(repeating: 0, count: n+1)
var index = 1

var SCC:[Int] = Array(repeating: 0, count: n+1)
var SCCTotalCash:[Int] = Array(repeating: 0, count: n+1)
var SCCRestExist:[Bool] = Array(repeating: false, count: n+1)
var SCCEdge:[Set<Int>] = Array(repeating: [], count: n+1)
var SCCDP:[Int] = Array(repeating: -1, count: n+1)
var sNum = 0
var atm:[Int] = Array(repeating: 0, count: n+1)
var rest:[Bool] = Array(repeating: false, count: n+1)
for _ in 0..<m {
    let road = readLine()!.split(separator: " ").map{Int(String($0))!}
    let A = road[0], B = road[1]
    edgeF[A].append(B)
    edgeB[B].append(A)
}
for i in 1...n {
    atm[i] = Int(String(readLine()!))!
}
let SP = readLine()!.split(separator: " ").map{Int(String($0))!}
let Restaurant = readLine()!.split(separator: " ").map{Int(String($0))!}
for i in Restaurant {
    rest[i] = true
}
for i in 1...n {
    if !check[i] {
        dfsF(n: i)
    }
}
for i in 1...n {
    let node = ft[n+1-i]
    if SCC[node] == 0 {
        sNum += 1
        dfsB(n: node, sNum: sNum)
    }
}
print(dfsSCC(n: SCC[SP[0]]))

func dfsF(n: Int) {
    check[n] = true
    for e in edgeF[n] {
        if !check[e] {
            dfsF(n: e)
        }
    }
    ft[index] = n
    index += 1
}

func dfsB(n: Int, sNum: Int) {
    SCC[n] = sNum
    SCCTotalCash[sNum] += atm[n]
    if rest[n] {
        SCCRestExist[sNum] = true
    }
    for e in edgeB[n] {
        if SCC[e] == 0 {
            dfsB(n: e, sNum: sNum)
        }
        else if SCC[e] != sNum {
            SCCEdge[SCC[e]].insert(sNum)
        }
    }
}

func dfsSCC(n: Int) -> Int {
    if SCCDP[n] != -1 {
        return SCCDP[n]
    }
    else {
        var tmp = 0
        for e in SCCEdge[n] {
            tmp = max(tmp, dfsSCC(n: e))
        }
        if tmp != 0 || SCCRestExist[n] {
            tmp += SCCTotalCash[n]
        }
        SCCDP[n] = tmp
        return tmp
    }
}

백준 4196 도미노

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/4196

도미노 블럭 하나가 정점 하나에 해당한다고 했을 때 모든 도미노를 쓰러뜨리기 위해 넘어뜨려야 하는 최소 횟수를 구하는 문제이다. 도미노 블록간에 위상관계를 세우고 위상정렬을 하면 좋겠다는 생각이 들 것이다.

하지만 주의할 것은 앞에서와는 다르게 사이클이 존재한다는 것이다. 사이클이 있는 그래프에서는 위상정렬을 할 수 없기 때문에 약간의 변화가 필요하다. SCC를 생각해보면 SCC 집합들 간에는 사이클이 존재할 수 없다고 설명했었다. 따라서 SCC집합으로 그래프를 바꾸고 SCC 집합간에 위상정렬을 실행하면 간단히 해결할 수 있다.

코사라주 DFSBack Function

func dfsB(n: Int, scc: Int) {
    SCC[n] = scc
    for e in edgeB[n] {
        if SCC[e] == 0 {
            dfsB(n: e, scc: scc)
        }
        else if SCC[e] != SCC[n] {
            indegree[scc] += 1
        }
    }
}

여기서는 코사라주로 구현을 했는데 그 중 dfsBack Function의 마지막 else if 구문을 보자. 코사라주에서 SCC 집합을 만들면 위상 관계가 있다면 위상 관계상 먼저 와야하는 SCC 집합이 먼저 만들어진다고 했었다. 따라서 본인과 SCC집합이 다른 정점을 만나게된다면 이는 본인의 SCC집합을 향하는 edge가 있다는 뜻이고 indegree값이 증가해야 함을 의미한다. 최종적으로는 indegree값이 0인 SCC집합들의 갯수를 새서 출력해주면 된다.

전체 코드

var edgeF:[[Int]] = []
var edgeB:[[Int]] = []
var check:[Bool] = []
var SCC:[Int] = []
var indegree:[Int] = []
var ft:[Int] = []
var index = 1

func dfsF(n: Int) {
    check[n] = true
    for e in edgeF[n] {
        if !check[e] {
            dfsF(n: e)
        }
    }
    ft[index] = n
    index += 1
}

func dfsB(n: Int, scc: Int) {
    SCC[n] = scc
    for e in edgeB[n] {
        if SCC[e] == 0 {
            dfsB(n: e, scc: scc)
        }
        else if SCC[e] != SCC[n] {
            indegree[scc] += 1
        }
    }
}

let t = Int(readLine()!)!
for _ in 0..<t {
    let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
    let n = nm[0], m = nm[1]
    var scc = 0, result = 0
    edgeF = Array(repeating: [], count: n+1)
    edgeB = Array(repeating: [], count: n+1)
    check = Array(repeating: false, count: n+1)
    SCC = Array(repeating: 0, count: n+1)
    indegree = Array(repeating: 0, count: n+1)
    ft = Array(repeating: 0, count: n+1)
    index = 1
    for _ in 0..<m {
        let line = readLine()!.split(separator: " ").map{Int(String($0))!}
        let N1 = line[0], N2 = line[1]
        edgeF[N1].append(N2)
        edgeB[N2].append(N1)
    }
    
    for i in 1...n {
        if !check[i] {
            dfsF(n: i)
        }
    }
    for i in 1...n {
        let node = ft[n+1-i]
        if SCC[node] == 0 {
            scc += 1
            dfsB(n: node, scc: scc)
        }
    }

    for i in 1...scc {
        if indegree[i] == 0 {
            result += 1
        }
    }
    print(result)
}

백준 1766 문제집

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1766

모든 문제를 다음 조건을 가지고 푸려고 한다.

먼저 푸는 것이 좋은 문제가 있는 문제는, 먼저 푸는 것이 좋은 문제를 반드시 먼저 풀어야 한다.
가능하면 쉬운 문제부터 풀어야 한다.

숫자가 낮을 수록 쉬운 문제라고 했을 때 모든 문제를 푸는 순서를 출력하는 문제이다.

선행 조건이 있기 때문에 위상정렬을 사용해야 한다는 것을 알아차릴 수 있다. 1번의 경우 위상정렬을 쓰기만 하면 해결되는데 2번의 경우는 어떻게 해야할지 난감할 수 있다.

위상이 0인 정점을 저장하는 큐를 우선순위큐로 구현을 해보면 간단하다. 위상이 0인 정점간에서 정점 index가 낮은 것이 먼저 나올 것이기 때문에 2번 조건을 만족시킬 수 있다.

전체 코드

struct PriorityQueue<T>{
    private var arr:[T]
    private var compare:(T, T) -> Bool
    public var isEmpty:Bool {
        return arr.isEmpty
    }
    public var count:Int {
        return arr.count
    }
    mutating func shiftUp(_ a: Int) {
        var i = a
        while i > 0 {
            let p = (i-1)/2
            if compare(arr[i], arr[p]) {
                arr.swapAt(i, p)
                i = p
            }
            else {
                break
            }
        }
    }
    mutating func shiftDown(_ a: Int) {
        var i = a
        var c = 2*i+1
        while c < arr.count {
            if c+1 < arr.count && compare(arr[c+1], arr[c]) {
                c = c+1
            }
            if compare(arr[c], arr[i]) {
                arr.swapAt(c, i)
                i = c
                c = 2*i+1
            }
            else {
                break
            }
        }
    }
    mutating func insert(_ a: T) {
        arr.append(a)
        shiftUp(arr.count-1)
    }
    mutating func pop() -> T? {
        if arr.isEmpty {
            return nil
        }
        else {
            arr.swapAt(0, arr.count-1)
            let result = arr.popLast()
            shiftDown(0)
            return result
        }
    }
    init(arr: [T] = [], compare: @escaping (T, T) -> Bool) {
        self.arr = arr
        self.compare = compare
    }
}

let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nm[0], m = nm[1]
var edge:[[Int]] = Array(repeating: [], count: n+1)
var inedge:[Int] = Array(repeating: 0, count: n+1)
var pq = PriorityQueue<Int>(compare: <)
for _ in 0..<m {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    let S1 = line[0], S2 = line[1]
    edge[S1].append(S2)
    inedge[S2] += 1
}
for i in 1...n {
    if inedge[i] == 0 {
        pq.insert(i)
    }
}

var str = ""
while !pq.isEmpty {
    let curr = pq.pop()!
    str += "\(curr) "
    for e in edge[curr] {
        inedge[e] -= 1
        if inedge[e] == 0 {
            pq.insert(e)
        }
    }
}
print(str)

백준 3665 최종 순위

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/3665

작년 순위가 주어지고 올해 상대적인 등수가 바뀐 쌍의 수가 주어지면 올해의 새로운 순위를 출력하는 문제이다. 문제 자체에서 혼동이 와서 헤깔리기 쉬운 문제이니 유의하기 바란다.

모든 정점은 자신보다 순위가 높은 정점에서 작은 정점으로 간선이 존재한다고 하자. 예시로 ABCD 순의 등수가 주어졌다고 했을 때 그림은 다음과 같다. 위상정렬 순으로 하나씩 정점을 뽑아내면 등수 순으로 뽑아내는 것과 같다는 것을 명심하자.

이 때 C와 A의 순위가 바뀌었다고 공개가 된다면 그림은 다음처럼 바뀔 것이다.

해당 그림에서 위상정렬을 해보려고 보면 A, B, C 간에 사이클이 생겨서 만들어 낼 수가 없다. 일부 사람들은 하지만 C A 순위가 바뀌면 CBAD의 결과가 나와야하는것이 아닌가요? 할 수 있다. 단순히 생각하면 ABCD 에서 CBAD가 된다고 생각하기 쉽지만 그렇게 될 경우 A와 B, C와 B의 관계도 바뀌게 되는 것이므로 상대 순위 변동이 추가적으로 공개가 되야한다.

이번에는 A B의 순위와 C B 순위도 바뀌었다고 공개가 되었다고 하자. 그럴 경우 그래프는 위와 같이 변하며 위상 정렬 순으로 뽑았을 때 정상적으로 CBAD가 나오는 것을 확인할 수 있다.

이제 이를 활용하여 순위에 따른 그래프를 설정해주고 위상정렬 알고리즘을 사용해주면 된다. 한가지 유의할 점으로는 정상적으로 순위가 나오려면 위상이 0이 되는 정점이 한번에 하나씩 등장해야 한다는 것이다. 만약 위상이 0이 되는 정점이 2개 이상이 된다면 둘 간의 순위 파악이 안된다는 의미이다. 또한 사이클이 생겨 위상정렬이 더이상 불가능해진다면 상대 순위 공개가 덜 됐다는 의미이므로 순위를 뽑아내는 것이 불가능 하다는 것을 알아야한다.

전체 코드

let t = Int(readLine()!)!
for _ in 1...t {
    let n = Int(String(readLine()!))!
    var priCount = Array(repeating: 0, count: n+1)
    var edge:[[Int]] = Array(repeating: [], count: n+1)
    let order = readLine()!.split(separator: " ").map{Int(String($0))!}
    for i in 0..<order.count {
        for j in 0..<i {
            edge[order[j]].append(order[i])
        }
        priCount[order[i]] = i
    }
    let m = Int(String(readLine()!))!
    for _ in 0..<m {
        let line = readLine()!.split(separator: " ").map{Int(String($0))!}
        let S1 = line[0], S2 = line[1]
        if edge[S1].contains(S2) {
            edge[S2].append(S1)
            edge[S1].remove(at: edge[S1].firstIndex(of: S2)!)
            priCount[S1] += 1
            priCount[S2] -= 1
        }
        else {
            edge[S1].append(S2)
            edge[S2].remove(at: edge[S2].firstIndex(of: S1)!)
            priCount[S2] += 1
            priCount[S1] -= 1
        }
    }
    
    var result = 0
    var str = ""
    var queue:[Int] = []
    for i in 1...n {
        if priCount[i] == 0 {
            queue.append(i)
        }
    }
    if queue.count > 1 {
        result = -1
    }
    else if queue.count == 0 {
        result = -2
    }
    else {
        while !queue.isEmpty {
            let curr = queue.removeFirst()
            str += "\(curr) "
            result += 1
            for k in edge[curr] {
                priCount[k] -= 1
                if priCount[k] == 0 {
                    queue.append(k)
                }
            }
            if queue.count > 1 {
                result = -1
                break
            }
        }
    }
    switch result {
    case -1:
        print("?")
    case n:
        print(str)
    default:
        print("IMPOSSIBLE")
    }
}

백준 13511 트리와 쿼리 2

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/13511

n개의 정점으로 이루어진 트리가 주어지면 각 간선에 이동하는 비용이 적혀있다고 하자. 이 때 u에서 v 정점으로 가는 비용 혹은 u에서 v로가는 경로의 k번째 정점을 출력하는 문제이다. 트리상에서 u에서 v로 이동하는 최단 경로는 lca를 거쳐 가는 경로이다. 따라서 우리는 lca알고리즘을 활용해야 함을 알 수 있다.

먼저 cost의 경우 root부터 각 정점까지 이동 비용을 dfs하면서 저장시켜둔다. 그 후 u에서 v로 이동하는 cost는 root -> u까지의 cost와 root -> v 로의 cost를 합친 뒤 root -> lca(u, v) 로의 cost를 2배해서 빼준 것과 같다. 직접 그래프를 그려보면 쉽게 알 수 있다.

cost(u, v) = cost(root, u) + cost(root, v) - 2*cost(root, lca(u, v))

자 그러면 k 번째 경로에 대해서 알아내야 할 것이다. cost와 마찬가지로 u, v간의 lca값을 먼저 알아내야 할 것이다. u -> lca(u, v) 까지의 최대 이동 횟수는 lca가 u의 부모이기 때문에 depth 차이만큼 이동한다는 것을 알 수 있다. 따라서 lca에서부터 두 정점까지의 depth차이를 구해주고 k번째에 해당하는 위치를 찾아주면 된다. 그런데 일일히 경로를 따라가면서 k번째 위치를 찾는 행위는 최대 O(n) 이 걸리게된다.

LCAPath Function

func LCAPath(x: Int, y: Int, z: Int) -> Int {
    let lca = LCA(x: x, y: y)
    let leftdist = depth[x] - depth[lca]
    let rightdist = depth[y] - depth[lca]
    var k = z - 1
    if k > leftdist {
    // lca에서 y로의 경로에 위치시
        k = leftdist + rightdist + 1 - z
        var index = y
        var i = 0
        while k != 0 {
            if k&1 != 0 {
            //비트마스크를 활용해 해당 영역을 찾아간다, logn으로 시간 단축!
                index = parent[index][i]
            }
            k = k >> 1
            i += 1
        }
        return index
    }
    else {
    // lca에서 x로의 경로에 위치시
        var index = x
        var i = 0
        while k != 0 {
            if k&1 != 0 {
                index = parent[index][i]
            }
            k = k >> 1
            i += 1
        }
        return index
    }
}

코드를 보면 알 수 있듯이 먼저 leftDist와 rightDist를 k와 비교해 k번째 정점이 lca부터 u로의 경로에 위치할 것인지 lca부터 v로의 경로에 위치할 것인지를 찾아준다. 찾았다면 해당 영역 u 혹은 v 정점으로부터 부모를 거슬러올라가면서 경로를 찾아주면 된다.

전체 코드

var edge:[[(n:Int, c:Int)]] = []
var check:[Bool] = []
var depth:[Int] = []
var dist:[Int] = []
var parent:[[Int]] = []
let maxK = 18

func dfs(n: (n:Int, c:Int), p: Int) {
    depth[n.n] = depth[p] + 1
    check[n.n] = true
    parent[n.n][0] = p
    dist[n.n] = dist[p] + n.c
    for i in 1...maxK {
        parent[n.n][i] = parent[parent[n.n][i-1]][i-1]
    }
    for e in edge[n.n] {
        if !check[e.n] {
            dfs(n: e, p: n.n)
        }
    }
}

func LCA(x: Int, y: Int) -> Int {
    var a = x, b = y
    if depth[a] > depth[b] {
        swap(&a, &b)
    }
    for i in 0...maxK {
        if depth[a] <= depth[parent[b][maxK-i]] {
            b = parent[b][maxK-i]
        }
    }
    if a == b {
        return a
    }
    for i in 0...maxK {
        let currentA = parent[a][maxK-i]
        let currentB = parent[b][maxK-i]
        if currentA != currentB {
            a = currentA
            b = currentB
        }
    }
    return parent[a][0]
}

func LCACost(x: Int, y: Int) -> Int {
    let lca = LCA(x: x, y: y)
    return dist[x] + dist[y] - 2*dist[lca]
}

func LCAPath(x: Int, y: Int, z: Int) -> Int {
    let lca = LCA(x: x, y: y)
    let leftdist = depth[x] - depth[lca]
    let rightdist = depth[y] - depth[lca]
    var k = z - 1
    if k > leftdist {
        k = leftdist + rightdist + 1 - z
        var index = y
        var i = 0
        while k != 0 {
            if k&1 != 0 {
                index = parent[index][i]
            }
            k = k >> 1
            i += 1
        }
        return index
    }
    else {
        var index = x
        var i = 0
        while k != 0 {
            if k&1 != 0 {
                index = parent[index][i]
            }
            k = k >> 1
            i += 1
        }
        return index
    }
}

let n = Int(readLine()!)!
edge = Array(repeating: [], count: n+1)
check = Array(repeating: false, count: n+1)
depth = Array(repeating: 0, count: n+1)
parent = Array(repeating: Array(repeating: 0, count: maxK+1), count: n+1)
dist = Array(repeating: 0, count: n+1)
for _ in 0..<n-1 {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    let A = line[0], B = line[1], C = line[2]
    edge[A].append((B, C))
    edge[B].append((A, C))
}
dfs(n: (1, 0), p: 0)
let m = Int(readLine()!)!
var str = ""
for _ in 0..<m {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    if line[0] == 1 {
        str += "\(LCACost(x: line[1], y: line[2]))\n"
    }
    else {
        str += "\(LCAPath(x: line[1], y: line[2], z: line[3]))\n"
    }
}
print(str)

백준 3176 도로 네트워크

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/3176

n개의 정점들로 이루어진 트리가 주어질 때 정점 쌍이 주어지면 두 정점을 연결하는 경로에서 가장 짧은 도로와 긴 도로의 길이를 출력하는 문제이다. 얼핏보면 세그먼트를 써야할 것도 같고 하지만 lca를 활용하는 문제이다.

먼저 lca에서 그동안은 공통 조상이 무엇인지 알아내는 문제를 주로 풀었다. 그런데 부모 정보 뿐만 아니라 값을 저장시켜 세그먼트 트리처럼 트리의 주어진 구간에서 원하는 값을 얻어낼 수도 있다.

var parent:[[(n:Int, minc: Int, maxc: Int)]] = []

만약 parent 배열을 위 처럼 정의한다고 하자. min cost와 max cost가 함께 정의된 형태이다.

func dfs(n: (Int, Int), p: Int) {
    depth[n.0] = depth[p] + 1
    check[n.0] = true
    parent[n.0][0] = (n: p, minc: n.1, maxc: n.1)
    for i in 1...maxK {
        let midParent = parent[n.0][i-1]
        let finalParent = parent[midParent.n][i-1]
        parent[n.0][i] = (n:finalParent.n, minc:min(midParent.minc, finalParent.minc), maxc:max(midParent.maxc, finalParent.maxc))
    }
    for e in edge[n.0] {
        if !check[e.0] {
            dfs(n: e, p: n.0)
        }
    }
}

그러면 기존의 lca처럼 부모 정보를 각 정점마다 저장시키기 위해 dfs를 돌려줄 것이다. 기존의 parent[n][i]의 의미는 n번 정점의 2ⁱ번째 부모였지만 이제는 부모가 무엇인지 뿐만아니라 n번 정점부터 2ⁱ번째 부모까지의 경로 중 거리의 최댓값과 최솟값을 같이 포함하고 있는 것이다.

위의 그림을 보면 알 수 있듯이 주황색 즉 E의 2²번째 부모를 구하려고한다. 그렇다면 우리는 dfs 구현에 의해 E의 2¹번째 부모로 가서 해당 정점의 2¹를 반환시켜줄 것이다. 그런데 자세히보면 E의 2¹번째 부모로 가는 도로의 최솟값과 최댓값을 이미 구해놨었고 C에서도 2¹번째 부모로의 최솟값과 최댓값을 이미 구해놨다. 따라서 E의 2²부모로 가는 도로의 최솟값과 최댓값은 이 두 정보를 비교하기만 하면 되는 것이다.

이제 우리는 부모의 정보에 해당 부모까지 가는 도로의 최솟값과 최댓값을 알고있기 때문에 lca 알고리즘을 돌리는 과정에서 정점을 부모로 옮기는 순간마다 최솟값과 최댓값을 불러 비교해주기만 하면 된다.

전체 코드

var edge:[[(Int, Int)]] = []
var check:[Bool] = []
var depth:[Int] = []
var parent:[[(n:Int, minc: Int, maxc: Int)]] = []
let maxK = 18

func dfs(n: (Int, Int), p: Int) {
    depth[n.0] = depth[p] + 1
    check[n.0] = true
    parent[n.0][0] = (n: p, minc: n.1, maxc: n.1)
    for i in 1...maxK {
        let midParent = parent[n.0][i-1]
        let finalParent = parent[midParent.n][i-1]
        parent[n.0][i] = (n:finalParent.n, minc:min(midParent.minc, finalParent.minc), maxc:max(midParent.maxc, finalParent.maxc))
    }
    for e in edge[n.0] {
        if !check[e.0] {
            dfs(n: e, p: n.0)
        }
    }
}

func LCA(x: Int, y: Int) -> (Int, Int) {
    var a = x, b = y
    var maximum = 0, minimum = 1_000_001
    if depth[a] > depth[b] {
        swap(&a, &b)
    }
    for i in 0...maxK {
        let current = parent[b][maxK-i]
        if depth[a] <= depth[current.n] {
            maximum = max(maximum, current.maxc)
            minimum = min(minimum, current.minc)
            b = current.n
        }
    }
    if a == b {
        return (minimum, maximum)
    }
    for i in 0...maxK {
        let currentA = parent[a][maxK-i]
        let currentB = parent[b][maxK-i]
        if currentA.n != currentB.n {
            maximum = max(maximum, currentA.maxc, currentB.maxc)
            minimum = min(minimum, currentA.minc, currentB.minc)
            a = currentA.n
            b = currentB.n
        }
    }
    let LCANodeA = parent[a][0], LCANodeB = parent[b][0]
    maximum = max(maximum, LCANodeA.maxc, LCANodeB.maxc)
    minimum = min(minimum, LCANodeA.minc, LCANodeB.minc)
    return (minimum, maximum)
}

let n = Int(readLine()!)!
edge = Array(repeating: [], count: n+1)
check = Array(repeating: false, count: n+1)
depth = Array(repeating: 0, count: n+1)
parent = Array(repeating: Array(repeating: (n:0, minc: 0, maxc: 0), count: maxK+1), count: n+1)
for _ in 0..<n-1 {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    let A = line[0], B = line[1], C = line[2]
    edge[A].append((B, C))
    edge[B].append((A, C))
}
dfs(n: (1, 0), p: 0)
let m = Int(readLine()!)!
var str = ""
for _ in 0..<m {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    let result = LCA(x: line[0], y: line[1])
    str += "\(result.0) \(result.1)\n"
}
print(str)

백준 17472 다리 만들기 2

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/17472

NxM의 격자가 주어지고 격자 위에 섬에 해당하는 부분은 1로 표시가 된다. 이어져 있는 땅 끼리는 하나의 섬이 된다고 했을 때 섬들 간에 다리를 연결해서 모든 섬을 이르려고 한다. 이 때 다리는 가로 또는 세로 한쪽 방향으로만 지을 수 있고 길이는 최소 2 이상이여야 한다. 다리간에 교차는 가능하다고 했을 때 모든 섬을 잇는 다리를 짓는 최소 비용을 구하는 문제이다.

먼저 섬들을 분리해서 각각의 섬에 번호를 매겨줘야하기 때문에 DFS나 BFS를 사용해서 전체 격자를 탐색해야함을 알 수 있다. 이 때 각각의 섬의 번호를 1번부터 다르게 매겨주었다.

Island Number DFS Code

var islandCount = 1
for i in 0..<n {
    for j in 0..<m {
        if island[i][j] == 1 && !check[i][j] {
            dfs(x: j, y: i, islandNum: islandCount)
            islandCount += 1
        }
    }
}
islandCount -= 1

이제 각 섬마다 다리를 연결하기 위해서 섬 사이의 간선을 설정해주어야 할 것이다. 이를 어떻게 할까 고민을 해보면 각 섬마다 섬의 내륙이 아닌 바다와 연결된 땅에 대해서 바다쪽으로 쭉 나아갔을 때 다른 섬이 등장하면 두 섬간에는 다리를 지을 수 있다고 판단할 수 있다. 이를 그대로 알고리즘에 적용해서 모든 섬의 땅에 대해서 상하좌우로 뻗어나갈 수 있는 만큼 뻗어서 다른 섬을 만난다면 두 섬간에 다리를 지을 수 있다고 판단하고 edge 연결을 해주는 식으로 구현했다.

Bridge Add Code

if nextX < 0 || nextX >= m || nextY < 0 || nextY >= n {
    return
}
else {
    let next = island[nextY][nextX]
    if next == 0 {
        bridgeAdd(x: x, y: y, count: count+1, direction: direction)
    }
    else if next != island[y][x] && count > 2 {
        node.append((n: island[y][x], m: next, d: count-1))
    }
}

해당 함수 내부를 보면 count라는 것이 사용되는데 해당 방향으로 얼마만큼 떨어진 땅을 봤는지를 나타내주는 역할을 한다. 따라서 새로운 땅을 만났을 때 거리가 2 이상이 되는지를 확인해 조건에 부합하다면 배열에 추가시켜준다.

간선을 모두 설정했다면 크루스칼 알고리즘으로 MST를 찾아주면 된다. edge를 설정하는 부분이 어려운 문제였지만 그 외에는 기본 알고리즘을 사용해주면 된다.

전체 코드

struct DisjointSet {
    var arr:[Int]
    init(_ n: Int) {
        arr = [Int](0...n)
    }
    mutating func findRoot(_ n:Int) -> Int {
        if arr[n] == n {
            return n
        }
        else {
            let root = findRoot(arr[n])
            arr[n] = root
            return root
        }
    }
    mutating func union(_ n: Int, _ m: Int) -> Bool {
        let rootN = findRoot(n), rootM = findRoot(m)
        if rootN == rootM {
            return false
        }
        else if rootN < rootM {
            arr[rootM] = rootN
        }
        else {
            arr[rootN] = rootM
        }
        return true
    }
}

let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nm[0], m = nm[1]
var island:[[Int]] = []
var check:[[Bool]] = Array(repeating: Array(repeating: false, count: m), count: n)
for _ in 1...n {
    island.append(readLine()!.split(separator: " ").map{Int(String($0))!})
}

var islandCount = 1
for i in 0..<n {
    for j in 0..<m {
        if island[i][j] == 1 && !check[i][j] {
            dfs(x: j, y: i, islandNum: islandCount)
            islandCount += 1
        }
    }
}
islandCount -= 1

var node:[(n: Int, m: Int, d: Int)] = []
for i in 0..<n {
    for j in 0..<m {
        if island[i][j] != 0 {
            for d in 1...4 {
                bridgeAdd(x: j, y: i, count: 1, direction: d)
            }
        }
    }
}

node.sort(by: {$0.d < $1.d})
var disjoint = DisjointSet(islandCount)
var index = 0
var result = 0
var visited = 1
let count = node.count
while visited < islandCount && index < count {
    let current = node[index]
    index += 1
    if disjoint.union(current.n, current.m) {
        result += current.d
        visited += 1
    }
}
print(visited == islandCount ? result : -1)

func dfs(x: Int, y: Int, islandNum: Int) {
    check[y][x] = true
    island[y][x] = islandNum
    let dx = [-1, 1, 0, 0]
    let dy = [0, 0, -1, 1]
    for k in 0...3 {
        let nextX = x + dx[k], nextY = y + dy[k]
        if nextX < 0 || nextX >= m || nextY < 0 || nextY >= n {
            continue
        }
        if island[nextY][nextX] == 1 && !check[nextY][nextX] {
            dfs(x: nextX, y: nextY, islandNum: islandNum)
        }
    }
}

func bridgeAdd(x: Int, y: Int, count: Int, direction: Int) {
    var nextX = x, nextY = y
    switch direction {
    case 1:
        nextY = y-count
    case 2:
        nextY = y+count
    case 3:
        nextX = x+count
    case 4:
        nextX = x-count
    default:
        print("error")
    }
    if nextX < 0 || nextX >= m || nextY < 0 || nextY >= n {
        return
    }
    else {
        let next = island[nextY][nextX]
        if next == 0 {
            bridgeAdd(x: x, y: y, count: count+1, direction: direction)
        }
        else if next != island[y][x] && count > 2 {
            node.append((n: island[y][x], m: next, d: count-1))
        }
    }
}

백준 2887 행성 터널

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2887

3차원 상의 행성들의 좌표들이 주어졌을 때 행성간 연결을 통해 MST를 구축하려고 한다. 이 때 행성을 터널로 연결할 때의 비용은 min(X값의 차, Y값의 차, Z 값의 차)이다. 모든 행성에 대해 서로를 연결하는 간선 비용을 구하게 되면 n이 최대 100000이므로 대략 10¹⁰의 시간이 걸리게 된다. 따라서 주어진 시간 안에 edge설정조차 할 수 없게된다.

터널간의 연결 비용은 자세히 보면 각 축에 따른 길이 차이로 되어 있다. 만약 A, B, C라는 행성이 순서대로 x축을 따라 존재한다고 하자. A - C 를 연결하고 B - C 를 연결하는 것보다 A - B 와 B - C 를 연결하는 것이 길이가 더 짧을 것이다. 따라서 모든 행성들의 경우 본인 바로 옆에 있는 행성끼리만 edge를 고려해주면 된다. 이 때 x, y, z 각각에 대해 행성들을 정렬시켜 edge를 만들어주면 된다.

Edge 설정 코드

X.sort(by: {$0.1 < $1.1})
Y.sort(by: {$0.1 < $1.1})
Z.sort(by: {$0.1 < $1.1})
for i in 0..<n-1 {
    let currX = X[i], nextX = X[i+1]
    let currY = Y[i], nextY = Y[i+1]
    let currZ = Z[i], nextZ = Z[i+1]
    edge.append((n: currX.n, m: nextX.n, d: abs(currX.x - nextX.x)))
    edge.append((n: currY.n, m: nextY.n, d: abs(currY.y - nextY.y)))
    edge.append((n: currZ.n, m: nextZ.n, d: abs(currZ.z - nextZ.z)))
}

최종적으로 edge를 d 순으로 정렬해서 크루스칼 알고리즘을 적용시키면 해답을 구할 수 있다.

전체 코드

struct DisjointSet {
    var arr:[Int]
    init(_ n: Int) {
        arr = [Int](0...n)
    }
    mutating func findRoot(_ n:Int) -> Int {
        if arr[n] == n {
            return n
        }
        else {
            let root = findRoot(arr[n])
            arr[n] = root
            return root
        }
    }
    mutating func union(_ n: Int, _ m: Int) -> Bool {
        let rootN = findRoot(n), rootM = findRoot(m)
        if rootN == rootM {
            return false
        }
        else if rootN < rootM {
            arr[rootM] = rootN
        }
        else {
            arr[rootN] = rootM
        }
        return true
    }
}

let n = Int(readLine()!)!
var X:[(n:Int, x:Int)] = []
var Y:[(n:Int, y:Int)] = []
var Z:[(n:Int, z:Int)] = []
var edge:[(n:Int, m:Int, d:Int)] = []
for i in 1...n {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    X.append((n:i, x:line[0]))
    Y.append((n:i, y:line[1]))
    Z.append((n:i, z:line[2]))
}
X.sort(by: {$0.1 < $1.1})
Y.sort(by: {$0.1 < $1.1})
Z.sort(by: {$0.1 < $1.1})
for i in 0..<n-1 {
    let currX = X[i], nextX = X[i+1]
    let currY = Y[i], nextY = Y[i+1]
    let currZ = Z[i], nextZ = Z[i+1]
    edge.append((n: currX.n, m: nextX.n, d: abs(currX.x - nextX.x)))
    edge.append((n: currY.n, m: nextY.n, d: abs(currY.y - nextY.y)))
    edge.append((n: currZ.n, m: nextZ.n, d: abs(currZ.z - nextZ.z)))
}
edge.sort(by: {$0.2 < $1.2})

var disjoint = DisjointSet(n)
var index = 0
var result = 0
let count = edge.count
while index < count {
    let curr = edge[index]
    index += 1
    if disjoint.union(curr.n, curr.m) {
        result += curr.d
    }
}
print(result)

백준 1774 우주신과의 교감

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1774

정점들의 좌표가 주어지고 이미 연결된 정점들의 번호가 주어졌을 때 MST를 구성하기 위해 추가적으로 이어야하는 간선의 최단 비용을 찾으면 된다. MST를 구하는 방법에는 여러가지가 있으나 여기서는 크루스칼을 사용하였다.

크루스칼의 경우 같은 집합에 속한다면 edge연결을 하지 않는다. 따라서 이미 통로가 연결되어 있는 정점들 간에는 disjoint set에서 하나의 집합으로 union해주었다. 또한 edge를 설정할 때 모든 정점간에 하는 것이 아닌 같은 집합에 속해있지 않은 경우에만 edge를 생성해주어 시간을 단축했다.

Edge 설정 코드

for i in 1..<n+1 {
    for j in i+1..<n+1 {
    //i -> j 나 j -> i는 같은 간선이기 때문에 한번만 추가하도록 했다.
        if disjoint.findRoot(i) == disjoint.findRoot(j) {continue}
        let dx = node[i].0 - node[j].0
        let dy = node[i].1 - node[j].1
        let dist = sqrt(dx*dx + dy*dy)
        edge.append((i, j, dist))
    }
}

그 외에는 크루스칼 알고리즘과 동일하다. 문제에서 요구하는 출력 형식에 맞게 출력하는 것 잊지말자.

전체 코드

import Foundation
struct DisjointSet {
    var arr:[Int]
    init(_ n: Int) {
        arr = [Int](0...n)
    }
    mutating func findRoot(_ n:Int) -> Int {
        if arr[n] == n {
            return n
        }
        else {
            let root = findRoot(arr[n])
            arr[n] = root
            return root
        }
    }
    mutating func union(_ n: Int, _ m: Int) -> Bool {
        let rootN = findRoot(n), rootM = findRoot(m)
        if rootN == rootM {
            return false
        }
        else if rootN < rootM {
            arr[rootM] = rootN
        }
        else {
            arr[rootN] = rootM
        }
        return true
    }
}

let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nm[0], m = nm[1]
var disjoint = DisjointSet(n)
var node:[(Double, Double)] = [(0, 0)]
var edge:[(Int, Int, Double)] = []
for _ in 1...n {
    let line = readLine()!.split(separator: " ").map{Double(String($0))!}
    node.append((line[0], line[1]))
}
for _ in 1...m {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    disjoint.union(line[0], line[1])
}
for i in 1..<n+1 {
    for j in i+1..<n+1 {
        if disjoint.findRoot(i) == disjoint.findRoot(j) {continue}
        let dx = node[i].0 - node[j].0
        let dy = node[i].1 - node[j].1
        let dist = sqrt(dx*dx + dy*dy)
        edge.append((i, j, dist))
    }
}
edge.sort(by: {$0.2 < $1.2})
var result:Double = 0
var index = 0
var count = edge.count
while index < count {
    let current = edge[index]
    index += 1
    if disjoint.union(current.0, current.1) {
        result += current.2
    }
}
print(String(format: "%.2f", result))

백준 1956 운동

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1956

각 마을간 도로의 길이가 주어졌을 때 시작점에서 다시 시작점으로 돌아오는 사이클의 최소 비용을 찾는 문제이다. 여지껏은 사이클을 최대한 배척하면서 문제를 풀었다면 이번 문제는 오히려 사이클을 구하는 문제이다.

만약 시작지점에서 a라는 정점을 거쳐 오는 최단 사이클은 s -> a 로 가는 최단 경로에 a -> s로 가는 최단 경로를 합친 것과 같다. 따라서 모든 정점에 대해서 이를 반복해주면 모든 사이클 중에서 최단 경로를 찾을 수 있을 것이다. 플로이드 와샬 알고리즘을 활용하면 이를 효과적으로 구할 수 있다.

플로이드 와샬 코드

for i in 1...V {
    for j in 1...V {
        for k in 1...V {
        //j와 k가 같은 경우도 고려해주도록 해서 cycle을 찾는다!!
            DP[j][k] = min(DP[j][k], DP[j][i] + DP[i][k])
        }
    }
}

만약 자기 자신으로의 최단 경로를 INF로 설정해놓고 시작과 끝이 같은 경우에도 플로이드 와샬 알고리즘이 동작하도록 구현한다면 손쉽게 구할 수 있다. 시작 지점은 정해져있지 않으므로 모든 사이클 중에서 최솟값을 출력해주면 된다.

전체 코드

let VE = readLine()!.split(separator: " ").map{Int(String($0))!}
let V = VE[0], E = VE[1]
var DP:[[Int]] = Array(repeating: Array(repeating: 4_000_001, count: V+1), count: V+1)
for _ in 0..<E {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    DP[line[0]][line[1]] = line[2]
}
for i in 1...V {
    for j in 1...V {
        for k in 1...V {
            DP[j][k] = min(DP[j][k], DP[j][i] + DP[i][k])
        }
    }
}

var result = 4_000_001
for i in 1...V {
    result = min(result, DP[i][i])
}
print(result == 4_000_001 ? -1 : result)

백준 10217 KCM Travel

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/10217

도시 간의 이동 비용과 이동 시간이 주어진다고 하자. 만약 시작 도시에서 목적지 도시까지 최단 시간을 구하려고 하는데 비용이 주어진 상한선을 넘으면 안되는 문제이다.

기존의 최단 경로는 항상 고려할 요소가 1개였는데 이번에는 2가지로 늘었다. 하지만 이동 비용은 어디까지나 제한 요소일뿐 구하고자하는 최단 경로 값은 시간이기 때문에 시간에 대해서 최단 경로를 진행해줄 것이다. 음의 가중치는 존재하지 않기 때문에 다익스트라를 활용해서 접근할 것이다.

먼저 모든 edge는 비용과 시간을 같이 저장하고 있는 형태로 저장한다. 또한 dist에 대해서 2차원으로 설정해서 도시의 번호와 비용이 주어지면 해당 비용 안에서 최단 시간을 반환하도록 설정하였다.

var PQ = PriorityQueue()
PQ.insert((1, 0, 0))
Dist[1][0] = 0
while !PQ.isEmpty {
    let current = PQ.pop()!
    let currentIndex = current.0, currentCost = current.1, currentTime = current.2
    if currentIndex == N {break}
    for i in 1...N {
        let nextIndex = i
        for edge in Edge[currentIndex][nextIndex] {
        // 현재index에서 다음index로 가는 모든 간선에 대해서
            let nextCost = currentCost + edge.0
            if nextCost > M {continue} // 비용이 M을 넘어서는 경우 continue
            let nextTime = currentTime + edge.1
            if Dist[nextIndex][nextCost] <= nextTime {continue}
            for k in nextCost...M {
            // k 이후에 모든 cost에 대해서도 시간 비교를 해줘 반복 연산을 줄인다.
                if Dist[nextIndex][k] > nextTime {
                    Dist[nextIndex][k] = nextTime
                }
                else {
                    break
                }
            }
            PQ.insert((nextIndex, nextCost, nextTime))
        }
    }
}

기본적으로는 다익스트라의 동작과 동일하기 때문에 어려울 것이 없다. 유의할 점으로는 u -> v로 가는 간선이 여러개가 존재할 수 있다는 것이다. 따라서 Edge 배열이 3차원으로 이루어져 있다는 것을 유의하자.

또 한가지로 현재 index에서 다음 index로 가는 최단 시간이 기존의 배열에 저장된 최단 시간보다 작다면 update가 일어날 것이다. 이 때 Dist배열에서 해당 비용에 대해서만 업데이트를 하는 것이 아니라 그 이후의 모든 비용에 대해서 업데이트를 해준다. 만약 i라는 index를 가지는 도시에 k라는 비용을 써서 최단 시간 d을 찾았다고 하자. 후에 어떤 경로를 거쳐서 다시 i를 방문했는데 k+1의 비용을 써서 최단 시간 d+1이 걸렸다고 하자.

이 소리는 더 많은 비용을 쓰고 더 많은 시간이 걸려서 해당 도시에 도착했다는 소리이고 무조건 k 비용을 써서 d 시간에 도착한 경우가 유효할 것임을 알 수 있다. 따라서 k 이후의 모든 비용에 대해 업데이트를 해주면 쓸데 없는 연산을 줄일 수 있게 된다. 최종적으로는 N번 도시에 대해서 M 이하의 모든 비용값에 대해 최단 시간을 찾아주면 된다.

전체 코드

public struct PriorityQueue {
    private var heap = Heap<(Int, Int, Int)>(compare: {
        return $0.2 < $1.2
    })
    public var isEmpty:Bool {
        return heap.isEmpty
    }
    public var count:Int {
        return heap.count
    }
    public mutating func insert(_ a: (Int, Int, Int)) {
        heap.insert(a)
    }
    public mutating func pop() -> (Int, Int, Int)? {
        return heap.pop()
    }
    
}

public struct Heap<T> {
    private var arr:[T]
    private var compare:(T, T) -> Bool
    public var isEmpty:Bool {
        return arr.isEmpty
    }
    public var count:Int {
        return arr.count
    }
    public mutating func shiftUp(_ a: Int) {
        var i = a
        while i > 0 {
            if compare(arr[i], arr[(i-1)/2]) {
                arr.swapAt(i, (i-1)/2)
                i = (i-1)/2
            }
            else {
                break
            }
        }
    }
    public mutating func shiftDown(_ a: Int) {
        var i = a
        var s = 2*i+1
        while s < arr.count {
            if s+1 < arr.count && compare(arr[s+1], arr[s]) {
                s += 1
            }
            if compare(arr[s], arr[i]) {
                arr.swapAt(s, i)
                i = s
                s = 2*i+1
            }
            else {
                break
            }
        }
    }
    public mutating func insert(_ a: T) {
        arr.append(a)
        shiftUp(arr.count-1)
    }
    public mutating func pop() -> T? {
        if arr.isEmpty {
            return nil
        }
        else {
            arr.swapAt(0, arr.count-1)
            let result = arr.popLast()
            shiftDown(0)
            return result
        }
    }
    init(arr: [T] = [], compare: @escaping (T, T) -> Bool) {
        self.arr = arr
        self.compare = compare
    }
}

let testcase = Int(readLine()!)!
for _ in 1...testcase {
    let NMK = readLine()!.split(separator: " ").map{Int(String($0))!}
    let N = NMK[0], M = NMK[1], K = NMK[2]
    var Edge:[[[(Int, Int)]]] = Array(repeating: Array(repeating: [], count: N+1), count: N+1)
    var Dist:[[Int]] = Array(repeating: Array(repeating: 100001, count: M+1), count: N+1)
    for _ in 1...K {
        let line = readLine()!.split(separator: " ").map{Int(String($0))!}
        let from = line[0], to = line[1], cost = line[2], time = line[3]
        Edge[from][to].append((cost, time))
    }
    
    
    var PQ = PriorityQueue()
    PQ.insert((1, 0, 0))
    Dist[1][0] = 0
    while !PQ.isEmpty {
        let current = PQ.pop()!
        let currentIndex = current.0
        let currentCost = current.1
        let currentTime = current.2
        if currentIndex == N {break}
        for i in 1...N {
            let nextIndex = i
            for edge in Edge[currentIndex][nextIndex] {
                let nextCost = currentCost + edge.0
                if nextCost > M {continue}
                let nextTime = currentTime + edge.1
                if Dist[nextIndex][nextCost] <= nextTime {continue}
                for k in nextCost...M {
                    if Dist[nextIndex][k] > nextTime {
                        Dist[nextIndex][k] = nextTime
                    }
                    else {
                        break
                    }
                }
                PQ.insert((nextIndex, nextCost, nextTime))
            }
        }
    }
    var result = 100001
    for i in 0...M {
        result = min(result, Dist[N][i])
    }
    print(result == 100001 ? "Poor KCM" : result)
}

백준 11404 플로이드

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11404

문제 제목부터 플로이드를 사용하라 말해주는 문제이다. 똑같이 도시 간의 이동 비용을 구하는데 모든 도시에서 다른 모든 도시로의 비용을 구하는 것이 특징이다. 다익스트라를 사용해서 일일히 구해도 되나 시간 상 느리기 때문에 플로이드 와샬 알고리즘을 연습해보자.

플로이드 와샬 코드

for i in 1...n {
    for j in 1...n {
        if j == i {continue}
        for k in 1...n {
            if k == i || k == j {continue}
            Edge[j][k] = min(Edge[j][k], Edge[j][i] + Edge[i][k])
        }
    }
}

코드는 앞에서 봐서 알겠지만 여기서는 cycle이 존재하지 않기 때문에 i와 j가 같은 지점은 건너뛰게 했다. 참고로 i, j, k의 for문 순서는 알고리즘에 영향을 주지 않는다.

전체 코드

let n = Int(readLine()!)!
let m = Int(readLine()!)!
var Edge:[[Int]] = Array(repeating: Array(repeating: 10_000_001, count: n+1), count: n+1)
for _ in 1...m {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    let from = line[0], to = line[1], cost = line[2]
    Edge[from][to] = min(Edge[from][to], cost)
}

for i in 1...n {
    for j in 1...n {
        if j == i {continue}
        for k in 1...n {
            if k == i || k == j {continue}
            Edge[j][k] = min(Edge[j][k], Edge[j][i] + Edge[i][k])
        }
    }
}

var str = ""
for i in 1...n {
    for j in 1...n {
        str += "\(Edge[i][j] > 10_000_000 ? 0 : Edge[i][j]) "
    }
    str += "\n"
}
print(str)

백준 11657 타임머신

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11657

도시 간에 이동 가능한 버스 노선들이 주어졌을 때 1번 도시에서 나머지 도시로 가는 가장 빠른 시간을 구하는 문제이다. 가중치로는 음의 값을 가질 수 있기 때문에 다익스트라가 아닌 벨만포드나 플로이드를 사용해야 할 것이 예상된다.

그 중 한 도시에서 나머지로의 최단 경로를 찾는 문제이기 때문에 벨만포드를 사용해서 구하는 것이 좋다. 벨만포드의 경우 음의 가중치를 갖는 그래프가 현실에서는 많이 없기 때문에 시간과 관련된 문제가 나와서 과거로 돌아간다던지 하는 경우가 대부분이다.

문제 자체는 벨만포드 기본 알고리즘을 그대로 사용하면 되는 문제이기 때문에 어렵지 않게 구현할 수 있다. 음의 사이클이 나오는 경우를 고려해줘야 한다는 것만 유의하면 된다.

전체 코드

let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nm[0], m = nm[1], INF = 60_000_001
var Dist:[Int] = Array(repeating: INF, count: n+1)
var Edge:[[(Int, Int)]] = Array(repeating: [], count: n+1)
for _ in 1...m {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    Edge[line[0]].append((line[1], line[2]))
}

Dist[1] = 0
for _ in 1..<n {
    for i in 1...n {
        if Dist[i] == INF {
            continue
        }
        for e in Edge[i] {
            Dist[e.0] = min(Dist[e.0], Dist[i] + e.1)
        }
    }
}

var change = false
for i in 1...n {
    if Dist[i] == INF {
        continue
    }
    for e in Edge[i] {
        if Dist[e.0] > Dist[i] + e.1 {
            change = true
            break
        }
    }
}
if change {
    print(-1)
}
else {
    for i in 2...n {
        print(Dist[i] == INF ? -1 : Dist[i])
    }
}

백준 9370 미확인 도착지

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/9370

출발지가 주어지고 목적지가 여러개 주어진다고 하자. 이 때 목적지로 향하는 최단 경로의 일부인 간선 하나가 주어졌다고 했을 때 후보로 가능한 목적지들을 오름차순으로 출력하는 문제이다.

일단 도로의 가중치는 양의 값을 가진다고 나와있기 때문에 다익스트라를 사용하면 좋을 것이라는 생각이 든다. 만약에 어떤 중간 간선 (g - h)이 주어진다고 했을 때 s -> d 로의 최단경로는 s -> g -> h -> d 혹은 s -> h -> g -> d 가 될 것이다. 이를 응용하여 우리는 s, g, h로부터 모든 점으로의 최단경로를 찾고 이를 이용해서 정답을 찾을 것이다.

var PQ = PriorityQueue()
calculateMin(start: g, PQ: &PQ, Dist: &Dist, Edge: Edge)
calculateMin(start: h, PQ: &PQ, Dist: &Dist2, Edge: Edge)
calculateMin(start: s, PQ: &PQ, Dist: &Dist3, Edge: Edge)
var str = ""
for goal in Destination {
    let result = min(Dist[s] + Dist[h] + Dist2[goal], Dist2[s] + Dist2[g] + Dist[goal])
    if result == Dist3[goal] {
        str += "\(goal) "
    }
}

코드를 보면 알 수 있듯이 g, h, s 각각에 대해 모든 정점에 대한 최단 경로를 서로 다른 dist 배열에 저장시켜주었다. 최종적으로 모든 destination 후보들에 대해서 s -> g -> h -> d 와 s -> h -> g -> d 최단거리의 최솟값과 s -> d 경로의 최단 거리를 비교해주어서 일치할 시 정답에 추가시켜준다.

전체 코드

struct PriorityQueue {
    private var heap = Heap<(Int, Int)>{
        if $0.1 < $1.1 {
            return true
        }
        else {
            return false
        }
    }
    public var isEmpty: Bool {
        return heap.isEmpty
    }
    mutating func insert(_ a: (Int, Int)) {
        heap.insert(a)
    }
    mutating func delete() -> (Int, Int)? {
        return heap.delete()
    }
}

public struct Heap<T> {
    private var arr:[T]
    private var compare:(T, T) -> Bool
    public var isEmpty:Bool {
        return arr.isEmpty
    }
    public var count:Int {
        return arr.count
    }
    
    init(arr: [T] = [], compare: @escaping (T, T) -> Bool) {
        self.arr = arr
        self.compare = compare
    }
    
    private mutating func shiftUp(_ a: Int) {
        var i = a
        while i > 0 {
            let parent = (i-1)/2
            if compare(arr[i], arr[parent]) {
                arr.swapAt(i, parent)
                i = parent
            }
            else {
                break
            }
        }
    }
    private mutating func shiftDown(_ a: Int) {
        var i = a
        var s = 2*a+1
        while s < arr.count {
            if s+1 < arr.count && compare(arr[s+1], arr[s]) {
                s = s+1
            }
            if compare(arr[s], arr[i]) {
                arr.swapAt(i, s)
                i = s
                s = 2*i+1
            }
            else {
                break
            }
        }
    }
    public mutating func insert(_ a: T) {
        arr.append(a)
        shiftUp(arr.count-1)
    }
    public mutating func delete() -> T? {
        if arr.isEmpty {
            return nil
        }
        else {
            arr.swapAt(0, arr.count-1)
            let result = arr.popLast()
            shiftDown(0)
            return result
        }
    }
}

func calculateMin(start: Int, PQ: inout PriorityQueue, Dist: inout [Int], Edge: [[(Int, Int)]]) {
    PQ.insert((start,0))
    Dist[start] = 0
    while !PQ.isEmpty {
        let current = PQ.delete()!
        let currentIndex = current.0
        let currentDist = current.1
        for i in 0..<Edge[currentIndex].count {
            let nextIndex = Edge[currentIndex][i].0
            let nextWeight = Edge[currentIndex][i].1
            if Dist[nextIndex] > currentDist + nextWeight {
                Dist[nextIndex] = currentDist + nextWeight
                PQ.insert((nextIndex, currentDist + nextWeight))
            }
        }
    }
}

let testcase = Int(readLine()!)!
for _ in 1...testcase {
    let nmt = readLine()!.split(separator: " ").map{Int(String($0))!}
    let sgh = readLine()!.split(separator: " ").map{Int(String($0))!}
    let n = nmt[0], m = nmt[1], t = nmt[2], s = sgh[0], g = sgh[1], h = sgh[2]
    var Edge:[[(Int, Int)]] = Array(repeating: [], count: n+1)
    var Dist = Array(repeating: 50_000_001, count: n+1)
    var Dist2 = Array(repeating: 50_000_001, count: n+1)
    var Dist3 = Array(repeating: 50_000_001, count: n+1)
    var Destination:[Int] = []
    for _ in 1...m {
        let edge = readLine()!.split(separator: " ").map{Int(String($0))!}
        Edge[edge[0]].append((edge[1], edge[2]))
        Edge[edge[1]].append((edge[0], edge[2]))
    }
    for _ in 1...t {
        Destination.append(Int(readLine()!)!)
    }
    Destination.sort()
    var PQ = PriorityQueue()
    calculateMin(start: g, PQ: &PQ, Dist: &Dist, Edge: Edge)
    calculateMin(start: h, PQ: &PQ, Dist: &Dist2, Edge: Edge)
    calculateMin(start: s, PQ: &PQ, Dist: &Dist3, Edge: Edge)
    var str = ""
    for goal in Destination {
        let result = min(Dist[s] + Dist[h] + Dist2[goal], Dist2[s] + Dist2[g] + Dist[goal])
        if result == Dist3[goal] {
            str += "\(goal) "
        }
    }
    print(str)
}

백준 1168 요세푸스 문제 2

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1168

deque 파트에서 다루었던 요세푸스 문제의 심화 파트이다. 시간 제한이 단축되었기 때문에 기존의 deque를 사용하면 시간 초과가 뜨게된다. 만약 우리가 7명의 사람이 있을 때 k=3에 대한 요세푸스를 구한다 생각해보자. 7명의 사람을 각각 배열의 1번부터 7번이라고 하고 원소값을 1을 줘보자. 여기서 1의 의미는 사람이 현재 자리에 앉아있다는 의미이다. 만약 k번째 사람을 골라서 빼낸다면 해당 원소값을 0으로 바꿔버리면 된다. 이렇게 바꾸고 보니 현재 위치한 index로부터 구간합이 k인 지점을 찾는 문제로 바꿀 수 있었다.

그렇다면 구간합에 대한 문제이고 배열 값의 update가 일어나므로 세그먼트 트리나 펜윅 트리를 사용할 수 있겠다. 여기서는 펜윅 트리를 활용하여 문제를 풀었다. 이 때 요세푸스의 핵심은 원으로 되어있어서 처음으로 돌아갈 수 있다는 것이다. 따라서 k번째를 찾을 때 현재 위치부터 end까지의 구간합이 k보다 작다면 다시 start부터 end까지 중 k - (현재 index~end의 구간합)의 구간합을 갖는 위치를 찾아주면 된다.

하지만 구간합이 k인 지점을 찾는 문제는 현재 지점으로부터 하나씩 index를 증가시켜가면서 그 차이를 구하게 되면 매번 O(nlogn) 의 시간이 소요될 것이다. 따라서 이분탐색의 lower bound를 활용하여 시작 지점과 끝 지점을 지정해주고 해당 범위내에서 구간합이 k가 나오는 lower bound를 찾아주면 (logn)² 만에 결과를 얻어낼 수 있다.

func findKth(tree: [Int], start: Int, end: Int, k: Int) -> Int {
    let rst1 = fenwickFind(tree: tree, index: start-1)
    let rst2 = fenwickFind(tree: tree, index: end)
    
    if rst2-rst1 >= k { 
    //end까지의 구간합이 k보다 클 경우
        var s = start, e = end+1
        while s < e {
            let mid = (s+e)/2
            if fenwickFind(tree: tree, index: mid)-rst1 >= k {
                e = mid
            }
            else {
                s = mid+1
            }
        }
        return e
        //lower bound를 통한 구간합 k인 지점 찾기
    }
    else { 
        return findKth(tree: tree, start: 1, end: n, k: k-rst2+rst1)
        //end까지의 구간합이 k보다 작을 경우, 처음으로 돌아가서 다시 구해준다.
    }
}

전체 코드

let nk = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nk[0], k = nk[1]

func fenwickUpdate(tree: inout [Int], index: Int, val: Int) {
    var idx = index
    while idx <= n {
        tree[idx] += val
        idx += (idx & -idx)
    }
}

func fenwickFind(tree: [Int], index: Int) -> Int {
    var idx = index
    var rst = 0
    while idx > 0 {
        rst += tree[idx]
        idx -= (idx & -idx)
    }
    return rst
}

func findKth(tree: [Int], start: Int, end: Int, k: Int) -> Int {
    let rst1 = fenwickFind(tree: tree, index: start-1)
    let rst2 = fenwickFind(tree: tree, index: end)
    if rst2-rst1 >= k {
        var s = start, e = end+1
        while s < e {
            let mid = (s+e)/2
            if fenwickFind(tree: tree, index: mid)-rst1 >= k {
                e = mid
            }
            else {
                s = mid+1
            }
        }
        return e
    }
    else {
        return findKth(tree: tree, start: 1, end: n, k: k-rst2+rst1)
    }
}

var fenwick = Array(repeating: 0, count: n+1)
var str = "<"
for i in 1...n {
    fenwickUpdate(tree: &fenwick, index: i, val: 1)
}
var index = 1
for _ in 1...n {
    index = findKth(tree: fenwick, start: index, end: n, k: k)
    fenwickUpdate(tree: &fenwick, index: index, val: -1)
    str += "\(index), "
}
str.removeLast()
str.removeLast()
str += ">"
print(str)

백준 9345 디지털 비디오 디스크(DVDs)

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/9345

자기 자신의 index를 원소값으로 갖는 배열이 주어진다고 하자. 구간이 주어질 때 구간안에 구간의 시작부터 끝까지 숫자가 전부 들어있는지 아닌지 확인하는 문제이다. 예를들어 3-7 구간을 고르면 그 안에 3, 4, 5, 6, 7이 모두 들어있으면 true 아니면 false인 문제이다. 이 때 배열의 원소들은 swap 될 수 있다.

세그먼트를 써야할 것 같은데 구간안에 모두 존재하는지를 어떻게 판명해야할지 고민되는 문제였다. 먼저 각 원소값들은 중복이 되지 않기 때문에 3-7 구간을 구한다고 하면 총 5개의 원소값이 나타나게 될 것이다. 이를 활용하여 구간의 최솟값과 최댓값을 세그먼트 트리에 저장해놨다고 생각해보자. 3-7 구간에 3-7 원소가 모두 존재하면 최솟값이 결국 3이 나오고 최댓값이 7이 나오게 된다. 만약 다른 숫자가 들어있다고 생각하면 최솟값과 최댓값 중 하나가 다른 숫자가 나타나게 된다.

따라서 앞서 푼 최솟값 최댓값 문제와 동일하게 구현을 해주면 된다. 다만 업데이트가 이번에는 발생하므로 유의하자. 노드에서 양쪽 자식에 대해 업데이트를 호출한 후 양쪽 자식의 값 중 최솟값과 최댓값으로 노드의 값을 변경해주면 된다. 또한 3번과 7번 dvd를 바꾼다고 해도 실제로 dvd 케이스 안에 3번과 7번이 들어있는게 아닐 수 있다. 따라서 현재 dvd 케이스에 몇 번째 dvd가 들어있는지 배열로 관리해줘야 한다.

전체 코드

struct Segment {
    var arr:[Int]
    var tree:[(Int, Int)]
    mutating func update(start: Int, end: Int, node: Int, index: Int, val: Int) {
        if index < start || index > end {
            return
        }
        if start == end {
            tree[node] = (val, val)
            return
        }
        let mid = (start+end)/2
        update(start: start, end: mid, node: 2*node, index: index, val: val)
        update(start: mid+1, end: end, node: 2*node+1, index: index, val: val)
        tree[node] = (min(tree[2*node].0, tree[2*node+1].0), max(tree[2*node].1, tree[2*node+1].1))
    }
    mutating func change(a: Int, b: Int) {
        arr.swapAt(a, b)
        update(start: 0, end: arr.count-1, node: 1, index: a, val: arr[a])
        update(start: 0, end: arr.count-1, node: 1, index: b, val: arr[b])
    }
    func find(start: Int, end: Int, node: Int, left: Int, right: Int) -> (Int, Int) {
        if right < start || end < left {
            return (100000, 0)
        }
        if left <= start && end <= right {
            return tree[node]
        }
        let mid = (start+end)/2
        let l = find(start: start, end: mid, node: 2*node, left: left, right: right)
        let r = find(start: mid+1, end: end, node: 2*node+1, left: left, right: right)
        return (min(l.0, r.0), max(l.1, r.1))
    }
    mutating func makeTree(start: Int, end: Int, node: Int) -> (Int, Int) {
        if start == end {
            tree[node] = (arr[start], arr[start])
            return tree[node]
        }
        let mid = (start+end)/2
        let l = makeTree(start: start, end: mid, node: 2*node)
        let r = makeTree(start: mid+1, end: end, node: 2*node+1)
        tree[node] = (min(l.0, r.0), max(l.1, r.1))
        return tree[node]
    }
    init(n: Int) {
        self.arr = [Int](0..<n)
        self.tree = Array(repeating: (100000, 0), count: 4*n)
        makeTree(start: 0, end: n-1, node: 1)
    }
}
var str = ""
let t = Int(readLine()!)!
for _ in 0..<t {
    let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
    let n = nm[0], m = nm[1]
    var seg = Segment(n: n)
    for _ in 0..<m {
        let query = readLine()!.split(separator: " ").map{Int(String($0))!}
        if query[0] == 0 {
            seg.change(a: query[1], b: query[2])
        }
        else {
            let result = seg.find(start: 0, end: n-1, node: 1, left: query[1], right: query[2])
            if result.0 == query[1] && result.1 == query[2] {
                str += "YES\n"
            }
            else {
                str += "NO\n"
            }
        }
    }
}
print(str)

백준 2357 최솟값과 최댓값

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2357

n개의 정수가 주어지면 순서대로 배열에 집어넣는다. 그 후 구간 쿼리가 주어질 때마다 해당 구간에서의 최댓값과 최솟값을 각각 구해주는 문제이다. 최댓값, 최솟값을 구하는 문제이기 때문에 fenwick tree는 사용할 수 없고 세그먼트 트리를 활용해서 구현해주어야 한다.

업데이트가 없기 때문에 구현이 조금 간편해졌지만 업데이트 구현도 크게 어렵지 않으니 한번 고민해보면 좋다. 세그먼트 트리 2개를 만들어서 하나는 구간의 최댓값, 하나는 구간의 최솟값을 저장하도록 만들자. 세그먼트 트리를 처음 만들 때 좌측 child와 우측 child에 대해서 반환받은 결과를 가지고 둘 중 최댓값 혹은 최솟값으로 구간의 최대 최소를 정해주면 된다. 이 후 구간 쿼리가 주어질 때마다 두 세그먼트 트리에서 각각 결과를 얻어내서 출력하면 된다.

전체 코드

struct Segment {
    var arr:[Int]
    var tree:[Int]
    var isMax:Bool
    init(arr: [Int], isMax: Bool) {
        self.arr = arr
        self.isMax = isMax
        tree = Array(repeating: 0, count: 4*arr.count)
        makeTree(start: 0, end: arr.count-1, node: 1)
    }
    
    mutating func makeTree(start: Int, end: Int, node: Int) -> Int {
        if start == end {
            tree[node] = arr[start]
        }
        else {
            let mid = (start+end)/2
            if isMax {
                tree[node] = max(makeTree(start: start, end: mid, node: 2*node), makeTree(start: mid+1, end: end, node: 2*node+1))
            }
            else {
                tree[node] = min(makeTree(start: start, end: mid, node: 2*node), makeTree(start: mid+1, end: end, node: 2*node+1))
            }
        }
        return tree[node]
    }
    
    func find(start: Int, end: Int, node: Int, left: Int, right: Int) -> Int {
        if end < left || right < start {
            return isMax ? 0 : 1_000_000_001
        }
        if left <= start && end <= right {
            return tree[node]
        }
        let mid = (start+end)/2
        if isMax {
            return max(find(start: start, end: mid, node: 2*node, left: left, right: right), find(start: mid+1, end: end, node: 2*node+1, left: left, right: right))
        }
        else {
            return min(find(start: start, end: mid, node: 2*node, left: left, right: right), find(start: mid+1, end: end, node: 2*node+1, left: left, right: right))
        }
    }
}

let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nm[0], m = nm[1]
var arr = Array(repeating: 0, count: n)
for i in 0..<n {
    arr[i] = Int(String(readLine()!))!
}
var maxTree = Segment(arr: arr, isMax: true)
var minTree = Segment(arr: arr, isMax: false)
var str = ""
for _ in 0..<m {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    str += "\(minTree.find(start: 0, end: n-1, node: 1, left: line[0]-1, right: line[1]-1)) \(maxTree.find(start: 0, end: n-1, node: 1, left: line[0]-1, right: line[1]-1))\n"
}
print(str)

백준 2042 구간 합 구하기

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2042

수열이 주어졌을 때 수열의 부분 구간에 대해 구간 합을 구하는 문제이다. 이 때 수열의 값은 변할 수 있다. 만약 수열의 값이 변하지 않는다면 간단하게 누적합의 차로 구간 합을 구할 수 있다. 하지만 수열의 값이 변하게 될 경우 해당 수를 포함하는 모든 누적합의 값이 변해야해서 update할때마다 O(n) 의 시간이 걸리게 된다.

그렇기 때문에 앞에서 정리한 세그먼트 트리를 활용할 것이다. 구간합을 구하는 문제이기 때문에 fenwick트리와 세그먼트 트리 중 어떤 것을 사용해도 상관은 없다. 유의할 점으로는 정답이 Int64범위이기 때문에 Clonglong으로 타입을 선언해주었다.

전체 코드

struct Segment {
    private var arr:[CLongLong]
    private var seg:[CLongLong]
    public mutating func calcDiff(index: Int, value: CLongLong) -> CLongLong {
        let previous = arr[index]
        arr[index] = value
        return value - previous
    }
    public mutating func update(start: Int, end: Int, node: Int, index: Int, diff: CLongLong) {
        if index < start || index > end {
            return
        }
        seg[node] += diff
        if start == end {
            return
        }
        let mid = (start+end)/2
        update(start: start, end: mid, node: 2*node, index: index, diff: diff)
        update(start: mid+1, end: end, node: 2*node+1, index: index, diff: diff)
    }
    public func sum(start: Int, end: Int, node: Int, left: Int, right: Int) -> CLongLong {
        if left > end || right < start {
            return 0
        }
        if left <= start && end <= right {
            return seg[node]
        }
        let mid = (start+end)/2
        return sum(start: start, end: mid, node: 2*node, left: left, right: right) + sum(start: mid+1, end: end, node: 2*node+1, left: left, right: right)
    }
    private mutating func makeSeg(start: Int, end: Int, node: Int) -> CLongLong {
        if start == end {
            seg[node] = arr[start]
        }
        else {
            let mid = (start+end)/2
            seg[node] = makeSeg(start: start, end: mid, node: 2*node) + makeSeg(start: mid+1, end: end, node: 2*node+1)
        }
        return seg[node]
    }
    init(arr: [CLongLong]) {
        self.arr = arr
        seg = Array(repeating: 0, count: 4*arr.count)
        makeSeg(start: 0, end: arr.count-1, node: 1)
    }
}

let nmk = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nmk[0], m = nmk[1], k = nmk[2]
var arr:[CLongLong] = Array(repeating: -1, count: n)
for i in 0..<n {
    arr[i] = CLongLong(String(readLine()!))!
}
var segtree = Segment(arr: arr)
var str = ""
for _ in 1...m+k {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    if line[0] == 1 {
        let diff = segtree.calcDiff(index: line[1]-1, value: CLongLong(line[2]))
        segtree.update(start: 0, end: n-1, node: 1, index: line[1]-1, diff: diff)
    }
    else {
        str += "\(segtree.sum(start: 0, end: n-1, node: 1, left: line[1]-1, right: line[2]-1))\n"
    }
}
print(str)

백준 20040 사이클 게임

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/20040

총 n개의 정점이 있을 때 두 정점을 잇는 간선들이 m개 주어진다고 하자. 만약 간선을 긋는 과정에서 사이클이 발생했다면 몇번째 차례인지 출력하고 만약 m개를 다 긋는 동안 사이클이 발생하지 않았다면 0을 출력하는 문제이다. 사이클의 여부를 파악할 때는 union find를 사용하면 간단하게 표현할 수 있다. 만약 간선을 그으려고 할 때 양 끝점이 같은 집합에 속해있다면 해당 간선을 긋는 행위는 사이클을 발생시키는 것이 된다. 따라서 간선이 주어질 때마다 union이 성공하는지 실패하는지를 확인해 결과를 출력해주면 된다.

전체 코드

struct DisjointSet {
    var arr:[Int]
    init(_ n: Int) {
        arr = [Int](0..<n)
    }
    mutating func findRoot(_ n: Int) -> Int {
        if arr[n] == n {
            return n
        }
        else {
            let root = findRoot(arr[n])
            arr[n] = root
            return root
        }
    }
    mutating func union(_ a: Int, _ b: Int) -> Bool {
        let rootA = findRoot(a), rootB = findRoot(b)
        if rootA == rootB {
            return false
        }
        else if rootA < rootB {
            arr[rootB] = rootA
        }
        else {
            arr[rootA] = rootB
        }
        return true
    }
}

let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
let n =  nm[0], m = nm[1]
var disjointSet = DisjointSet(n)
var result = 0
for i in 1...m {
    let node = readLine()!.split(separator: " ").map{Int(String($0))!}
    if !disjointSet.union(node[0], node[1]) {
        result = i
        break
    }
}
print(result)

백준 4195 친구 네트워크

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/4195

친구 관계가 생긴 순서대로 주어졌을 때 두사람의 친구 네트워크에 몇 명이 속해있는지 구하는 문제이다. 두 친구가 속한 집합이 하나로 합쳐졌을 때 집합 전체의 크기를 구하는 문제라 할 수 있다.

집합간의 관계를 구하는 문제이기 때문에 union find를 사용할 예정이다. 이 때 각 집합은 번호로 매겨져있는 것이. 아닌 string으로 들어오게 된다. 따라서 dictionary를 이용하여 string을 int 번호로 바꿔주는 작업이 필요하다. 새로운 이름이 나올 때마다 번호를 부여하고 부모로 본인 자신을 가르키는 집합을 추가해주면 된다.

추가로 union할 때 집합 전체의 크기를 알려줘야 하기 때문에 parent 정보를 저장하는 배열 외에 집합의 크기를 저장해두는 배열을 하나 더 사용해야한다.

전체 코드

struct DisjointSet {
    var nameToInt:[String:Int] = [:]
    var arr:[Int] = []
    var memberCount:[Int] = []
    func nodeNumber(_ str: String) -> Int {
        guard let tmp = nameToInt[str] else {
            return -1
        }
        return tmp
    }
    mutating func insert(_ str: String) -> Int {
        let count = arr.count
        arr.append(count)
        memberCount.append(1)
        nameToInt[str] = count
        return count
    }
    mutating func findRoot(_ n: Int) -> Int {
        if arr[n] == n {
            return n
        }
        else {
            let root = findRoot(arr[n])
            arr[n] = root
            return root
        }
    }
    mutating func union(_ a: Int, _ b: Int) -> Int {
        let rootA = findRoot(a), rootB = findRoot(b)
        if rootA < rootB {
            arr[rootB] = rootA
            memberCount[rootA] += memberCount[rootB]
            return memberCount[rootA]
        }
        else if rootA > rootB{
            arr[rootA] = rootB
            memberCount[rootB] += memberCount[rootA]
            return memberCount[rootB]
        }
        else {
            return memberCount[rootA]
        }
    }
}

let testcase = Int(readLine()!)!
var str = ""
for _ in 1...testcase {
    let n = Int(readLine()!)!
    var disjointSet = DisjointSet()
    for _ in 1...n {
        let relation = readLine()!.split(separator: " ").map{String($0)}
        let person1 = relation[0], person2 = relation[1]
        var number1 = disjointSet.nodeNumber(person1)
        var number2 = disjointSet.nodeNumber(person2)
        if number1 == -1 {
            number1 = disjointSet.insert(person1)
        }
        if number2 == -1 {
            number2 = disjointSet.insert(person2)
        }
        str += "\(disjointSet.union(number1, number2))\n"
    }
}
print(str)

백준 1655 가운데를 말해요

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1655

입력이 하나씩 들어올때마다 여지껏 들어온 입력들 중에서 중간값을 출력해야하는 문제이다. 만약 짝수개라면 두 수 중에서 작은 수를 말해야 한다.

생각보다 아이디어를 생각하기 어려운 문제였다. 두 개의 힙을 준비해서 정 중앙 값을 기준으로 절반은 왼쪽에 절반은 오른쪽 힙에 집어넣는다고 하자. 만약 왼쪽 heap이 max heap이고 오른쪽 heap이 min heap이라면 두 heap은 항상 정중앙에 가까운 값을 root에 위치시킬 것이다. 홀수번째에는 max heap에 짝수번째에는 min heap에 값을 집어넣는다고 하자.

만약 정상적으로 코드가 동작해서 중간값을 기준으로 작은 값들은 모두 max heap에 들어있고 큰 값들은 모두 min heap에 들어있다고 하자. 그렇다면 새로운 입력이 들어왔을 때 그 값이 max heap에 들어갔다고 하자. 그런데 새로운 입력이 중간값보다 훨씬 커서 min heap에 위치해야한다면 이를 옮겨줘야 할 것이다. 당연히 새로운 입력은 max heap의 모든 값보다 크기 때문에 max heap의 root에 위치할 것이다. 따라서 과정은 다음과 같다.

max heap의 root와 min heap의 root를 바꾼다.
기존의 min heap의 최솟값은 max heap의 새로운 최댓값이 될 것이고 root에 위치시키면 된다.
min heap의 새로운 root에 shift down 함수를 적용해서 적절한 위치를 찾아준다.  

반대로 새로운 입력이 min heap에 들어갔지만 중간값보다 작아서 옮겨줘야 할 경우에도 위와 동일하게 적용을 시켜준다. 다만 이번에는 max heap에 shift down을 적용해서 적절한 위치를 찾아준다. 최종적으로 중간값은 max heap의 root에 위치할 것이다.

전체 코드

struct Heap<T> {
    var arr:[T]
    var compare:(T, T) -> Bool
    var root:T? {
        get {
            if arr.isEmpty {
                return nil
            }
            else {
                return arr[0]
            }
        }
    }
    mutating func shiftUp(a: Int) {
        var index = a
        while index > 0 {
            let parent = (index-1)/2
            if compare(arr[index], arr[parent]) {
                arr.swapAt(index, parent)
                index = parent
            }
            else {
                break
            }
        }
    }
    mutating func shiftDown(a: Int) {
        var index = a
        var child = 2*a+1
        let count = arr.count
        while child < count {
            if child + 1 < count {
                child = compare(arr[child], arr[child+1]) ? child : child+1
            }
            if compare(arr[child], arr[index]) {
                arr.swapAt(index, child)
                index = child
                child = 2*index+1
            }
            else {
                break
            }
        }
    }
    mutating func insert(_ a: T) {
        arr.append(a)
        shiftUp(a: arr.count-1)
    }
    mutating func pop() -> T? {
        if arr.isEmpty {
            return nil
        }
        else {
            arr.swapAt(0, arr.count-1)
            let result = arr.removeLast()
            shiftDown(a: 0)
            return result
        }
    }
    init(arr: [T] = [], compare: @escaping (T, T) -> Bool) {
        self.arr = arr
        self.compare = compare
    }
}

var minHeap = Heap<Int>{$0<$1}
var maxHeap = Heap<Int>{$0>$1}

let n = Int(readLine()!)!
if n == 1 {
    print(Int(readLine()!)!)
}
else {
    var str = ""
    maxHeap.insert(Int(readLine()!)!)
    str += "\(maxHeap.root!)\n"
    for i in 2...n {
        let k = Int(readLine()!)!
        if i%2 == 0 {minHeap.insert(k)}
        else {maxHeap.insert(k)}
        let a = maxHeap.root!
        let b = minHeap.root!
        if a > b {
            minHeap.arr[0] = a
            maxHeap.arr[0] = b
        }
        if i%2 == 0 {maxHeap.shiftDown(a: 0)}
        else {minHeap.shiftDown(a: 0)}
        str += "\(maxHeap.root!)\n"
    }
    print(str)
}

백준 11286 절댓값 힙

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11286

힙을 만드는데 최댓값, 최솟값이 아닌 절댓값이 가장 작은 값이 우선순위를 갖는 힙을 구성하는 문제이다. 물론 동일한 절댓값이면 음수가 양수보다 먼저 나오게 설정한다.

뭔가 엄청난 것을 할 필요없이 compare 함수만 제대로 설정해주면 끝이다. 그 외에는 알고리즘 설명에서 정리한 우선순위 큐를 그대로 사용하면 된다. 클로저를 사용해서 구현했으니 클로저에 대해 모른다면 문법공부를 하고오면 좋을 것 같다.

compare 함수 설정

var minHeap = Heap<Int>{
    if abs($0) < abs($1) {
        return true
    }
    else if abs($0) == abs($1) {
        return $0 < $1
    }
    else {
        return false
    }
}

전체 코드

struct Heap<T> {
    var arr:[T]
    var compare:(T, T) -> Bool
    mutating func shiftUp(a: Int) {
        var index = a
        while index > 0 {
            let parent = (index-1)/2
            if compare(arr[index], arr[parent]) {
                arr.swapAt(index, parent)
                index = parent
            }
            else {
                break
            }
        }
    }
    mutating func shiftDown(a: Int) {
        var index = a
        var child = 2*a+1
        let count = arr.count
        while child < count {
            if child + 1 < count {
                child = compare(arr[child], arr[child+1]) ? child : child+1
            }
            if compare(arr[child], arr[index]) {
                arr.swapAt(index, child)
                index = child
                child = 2*index+1
            }
            else {
                break
            }
        }
    }
    mutating func insert(_ a: T) {
        arr.append(a)
        shiftUp(a: arr.count-1)
    }
    mutating func pop() -> T? {
        if arr.isEmpty {
            return nil
        }
        else {
            arr.swapAt(0, arr.count-1)
            let result = arr.removeLast()
            shiftDown(a: 0)
            return result
        }
    }
    init(arr: [T] = [], compare: @escaping (T, T) -> Bool) {
        self.arr = arr
        self.compare = compare
    }
}

var minHeap = Heap<Int>{
    if abs($0) < abs($1) {
        return true
    }
    else if abs($0) == abs($1) {
        return $0 < $1
    }
    else {
        return false
    }
}
let n = Int(readLine()!)!
for _ in 1...n {
    let k = Int(readLine()!)!
    if k == 0 {
        print(minHeap.pop() ?? 0)
    }
    else {
        minHeap.insert(k)
    }
}

백준 4803 트리

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/4803

정점의 갯수와 간선의 갯수가 주어지고 간선의 정보가 이어서 주어진다고 하자. 이 때 해당 그래프에서 트리의 갯수가 몇개인지 세는 문제이다. 트리의 조건은 사이클이 없고 임의의 두 정점에 대해서 경로가 유일하다는 특징을 갖고있다. 이를 활용하여 문제를 풀 것이다.

트리는 어떤 점을 루트로 잡아도 트리의 형태를 유지한다는 것은 알고있을 것이다. 그렇다면 임의의 한 점을 대상으로 dfs를 돌리면 트리의 모든 정점을 방문할 수 있게 된다. 트리에는 사이클이 없기 때문에 부모로부터 자식으로 내려온 간선을 제외시켜가며 dfs를 돌리면 이미 방문한 노드를 방문할 일이 없다. 만약 dfs과정에서 이미 방문한 노드를 방문한다면 그것은 사이클이 존재한다는 소리고 트리가 아니게 된다.

DFS Function

var visited = Array(repeating: false, count: n+1)
func dfs(_ current: Int, _ before: Int) -> Bool {
    visited[current] = true
    for next in edge[current] where next != before {
        if visited[next] {
            return false
        }
        else if !dfs(next, current) {
            return false
        }
    }
    return true
}

따라서 visited 배열을 활용하여 사이클이 발생하는지 확인해주도록 하자. for문을 보면 알겠지만 dfs 입력으로 before (부모 정점)을 받아서 부모 정점으로의 간선은 제외시키고 dfs를 반복적으로 계산했다.

전체 코드

var caseCount = 0
while let i = readLine() {
    caseCount += 1
    let nm = i.split(separator: " ").map{Int(String($0))!}
    let n = nm[0], m = nm[1]
    if n == 0 && m == 0 {break}
    var edge:[[Int]] = Array(repeating: [], count: n+1)
    for _ in 0..<m {
        let line = readLine()!.split(separator: " ").map{Int(String($0))!}
        edge[line[0]].append(line[1])
        edge[line[1]].append(line[0])
    }
    
    var visited = Array(repeating: false, count: n+1)
    func dfs(_ current: Int, _ before: Int) -> Bool {
        visited[current] = true
        for next in edge[current] where next != before {
            if visited[next] {
                return false
            }
            else if !dfs(next, current) {
                return false
            }
        }
        return true
    }
    
    var result = 0
    for i in 1...n {
        if !visited[i] {
            if dfs(i, 0) {
                result += 1
            }
        }
    }
    switch result {
    case 0:
        print("Case \(caseCount): No trees.")
    case 1:
        print("Case \(caseCount): There is one tree.")
    default:
        print("Case \(caseCount): A forest of \(result) trees.")
    }
}

백준 2263 트리의 순회

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2263

순회는 모든 노드를 한번씩 방문하는 방법을 이야기한다. 이진트리에서는 preorder, inorder, postorder 3가지의 순회 방법이 존재한다. 그 중에서 이 문제는 인오더와 포스트오더가 주어졌을 때 프리오더를 구하는 문제이다.

preorder  (전위 순회) : (루트)(왼쪽 자식)(오른쪽 자식)
inorder   (중위 순회) : (왼쪽 자식)(루트)(오른쪽 자식)
postorder (후위 순회) : (왼쪽 자식)(오른쪽 자식)(루트)

방법은 간단하다. 포스트에서 맨 마지막이 루트를 나타날 것이기 때문에 해당 값으로 인오더에서 루트의 위치를 찾아준 다음에 그 정보를 활용하여 inorder와 postorder를 왼쪽 자식과 오른쪽 자식으로 구분짓는다. 루트는 preorder list에 추가시켜주고 왼쪽 자식, 오른쪽 자식 각각에 대해 재귀적으로 루트를 찾는 과정을 반복하면 preorder를 완성할 수 있다.

유의할 것은 inorder와 postorder가 처음에는 start index와 end index가 동일하지만 진행하면서 달라진다는 점이다. 따라서 왼쪽 자식과 오른쪽 자식을 나눌 때 둘의 index 범위가 다르다는 것을 유의하고 진행해야 한다.

전체 코드

let n = Int(readLine()!)!
let inorder = readLine()!.split(separator: " ").map{Int(String($0))!}
let postorder = readLine()!.split(separator: " ").map{Int(String($0))!}
var preorder:[String] = []
var inorderDic:[Int:Int] = [:]
inorder.enumerated().forEach {
    inorderDic[$0.element] = $0.offset
}


func orderChange(inorderS: Int, inorderE: Int, postorderS: Int, postorderE: Int) {
    if inorderS > inorderE {
        return
    }
    else {
        let rootNode = postorder[postorderE]
        let rootIndex = inorderDic[rootNode]!
        let postLeftEnd = rootIndex - inorderS + postorderS - 1
        preorder.append(String(rootNode))
        orderChange(inorderS: inorderS, inorderE: rootIndex-1, postorderS: postorderS, postorderE: postLeftEnd)
        orderChange(inorderS: rootIndex+1, inorderE: inorderE, postorderS: postLeftEnd+1, postorderE: postorderE-1)
    }
}

orderChange(inorderS: 0, inorderE: n-1, postorderS: 0, postorderE: n-1)
print(preorder.joined(separator: " "))

백준 1167 트리의 지름

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1167

트리의 지름이란 트리에서 임의의 두 점 사이의 거리 중 가장 긴 것을 구하는 문제이다. 트리의 루트가 무엇인지 알려주지 않았지만 트리는 어떤 노드를 루트로 잡더라도 새롭게 트리를 구성할 수 있기 때문에 큰 상관이 없다.

먼저 임의의 점으로부터 가장 먼 노드를 먼저 찾는다. 그 후 해당 노드로부터 가장 먼 지점을 찾으면 된다. 이것이 가능한 이유는 어떤 점을 시작점으로 잡더라도 가장 먼 노드를 찾았을 때 트리의 지름에 해당하는 두 노드 중 하나를 가장 먼 노드로 찾게될 것이기 때문이다. 트리 탐색은 dfs로 구현을 하였다.

전체 코드

let n = Int(readLine()!)!
var edge:[[(Int, Int)]] = Array(repeating: [], count: n+1)
for i in 1...n {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    var index = 1
    while index != line.count-1 {
        edge[line[0]].append((line[index], line[index+1]))
        edge[line[index]].append((line[0], line[index+1]))
        index += 2
    }
}
func dfs(s: Int, d: Int) {
    if visited[s] {
        return
    }
    if d > maximum {
        maximum = d
        maxIndex = s
    }
    visited[s] = true
    for i in edge[s] {
        dfs(s: i.0, d: d+i.1)
    }
}
var visited = Array(repeating: false, count: n+1)
var maximum = 0
var maxIndex = 1
dfs(s:1, d:0)

visited = Array(repeating: false, count: n+1)
maximum = 0
dfs(s:maxIndex, d:0)
print(maximum)

백준 5430 AC

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/5430

R 뒤집기와 D 첫번째 숫자 버리기 라는 두 명령이 있는 언어가 주어지면 초기 배열에 적용한 최종 결과를 구하라.

deque를 활용하여 풀라고 되어있지만 swift에서는 front pop시 성능저하가 생겨서 다른 방법을 고안해야했다. 새로운 원소의 입력이 없기 때문에 배열에서 시작과 끝을 표시해주어 pop할때 실제로 pop하는 것이 아닌 index를 옮기는 방식으로 구현했다. reverse 여부에 따라 앞을 1 증가시킬지 뒤를 1 뺄지 결정하면 되는 문제이다.

단 error가 나는 case를 따로 고려해주어야 한다. 여기서는 first와 last가 역전되는 경우 error가 발생하도록 구현하였다.

전체 코드

let n = Int(readLine()!)!
loop: for _ in 1...n {
    let order = readLine()!
    let length = Int(readLine()!)!
    var testcase = readLine()!.split(separator: ",")
    if length == 0 {
        testcase = []
    }
    else {
        testcase[0].removeFirst()
        testcase[length-1].removeLast()
    }
    var deque = Deque(testcase.map{Int($0)!})
    for c in order {
        if deque.RD(str:c) {
            print("error")
            continue loop
        }
    }
    if deque.first > deque.last {
        print("[]")
    }
    else {
        var result = Array(deque.enqueue[deque.first...deque.last])
        if deque.reversed {result = result.reversed()}
        var str = "["
        for i in result {
            str += "\(i),"
        }
        str.removeLast()
        str += "]"
        print(str)
    }
}

struct Deque {
    var reversed:Bool = false
    var enqueue:[Int]
    var first:Int
    var last:Int
    init(_ arr: [Int]) {
        enqueue = arr
        first = 0
        last = arr.count-1
    }
    mutating func RD(str:Character) -> Bool {
        if str == "R" {
            reversed = !reversed
        }
        else if str == "D" {
            if first > last {
                return true
            }
            else {
                if reversed {
                    last -= 1
                }
                else {
                    first += 1
                }
            }
        }
        return false
    }
}

백준 11866 요세푸스 문제 0

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11866

원에 1-N번의 사람이 순서대로 앉아 있을 때 K번째 사람을 제거하고 남은 사람들로 이루어진 원을 따라 계속해서 K번째 사람을 제거해나간다고 했을 때 제거되는 사람 순서를 (N, K) - 요세푸스 순열이라고 부른다. n과 k가 주어졌을 때 요세푸스 순열을 구하는 문제이다.

여기서는 큐를 활용한 문제이기 때문에 queue로 구현했다. 1-N 들어있는 큐에서 반복적으로 pop한 후 해당 값을 다시 push한다. 만약 K번째에 해당한다면 그 값을 pop한 후 순열에 저장한다. 이 값은 다시 큐에 넣지 않는다.

swift에서는 pop이 O(n)의 시간이 걸리기 때문에 속도단축을 위해서 enqueue와 dequeue를 활용해서 구현했다. 문제에서 요구하는 형식에 맞게 출력을 수정하는 것을 잊지 않도록 하자.

전체 코드

struct Queue {
    var enqueue:[Int] = []
    var dequeue:[Int] = []
    init(_ arr:[Int]) {
        enqueue = arr
    }
    mutating func push(_ a: Int) {
        enqueue.append(a)
    }
    mutating func pop() -> Int {
        if dequeue.isEmpty {
            dequeue = enqueue.reversed()
            enqueue.removeAll()
        }
        if dequeue.isEmpty {
            return -1
        }
        else {return dequeue.removeLast()}
    }
}
let nk = readLine()!.split(separator: " ").map{Int($0)!}
let n = nk[0]
let k = nk[1]
var queue = Queue([Int](1...n))
var str = "<"
for _ in 1...n {
    for _ in 1..<k {
        queue.push(queue.pop())
    }
    str += "\(queue.pop()), "
}
str.removeLast()
str.removeLast()
str += ">"
print(str)

백준 6549 히스토그램에서 가장 큰 직사각형

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/6549

풀이방법으로는 세그먼트트리와 분할정복을 사용하는 것과 스택을 사용하는 것 2가지가 존재하는 문제이다. 여기서는 스택을 사용한 풀이방법을 소개할 것이다. 히스토그램이 주어질 때 히스토그램에서 가장 넓이가 큰 직사각형을 구하는 문제이다. 스택에는 각 직사각형의 길이와 그때의 index를 같이 저장시켜줄 것이다.

만약 그림처럼 점점 증가하는 직사각형이 주어지다가 길이가 이전꺼보다 짧은 직사각형이 왔다고 하자. 그렇다면 현재 스택에는 [2, 3, 7] 이 저장되어 있고 1이 들어갈 차례이다. 이제 스택에 저장되어있는 원소들은 직사각형들의 높이라고 했을 때 7을 높이로 갖는 직사각형은 1이 등장했기 때문에 더이상 오른쪽으로 너비를 증가시킬 수 없다. 따라서 stack에서 꺼내 가능한 너비를 계산 후 직사각형 넓이를 구해준다. 마찬가지로 3과 2역시 동일하게 수행한다.

직사각형 너비 계산 코드

let lastElement = stack.removeLast()
if stack.isEmpty {
    result = max(result, (i-1)*lastElement.0)
    stack.append((line[i], i))
    break
}
else {
    let beforeLast = stack.last!
    result = max(result, (i - beforeLast.1 - 1)*lastElement.0)
}

이 때 코드를 보면 너비를 계산해줄 때 새로운 index인 i 로부터 stack에서 pop한 사각형의 index를 빼주는 것이 아닌 stack의 top의 index를 빼주는 것을 볼 수 있는데 좌측으로의 너비를 고려해주기 위함이다.

전체 코드

while true {
    var line = readLine()!.split(separator: " ").map{Int(String($0))!}
    let n = line[0]
    if n == 0 {
        break
    }
    line.append(0)
    var stack:[(Int, Int)] = []
    var result = 0
    for i in 1...n+1 {
        if stack.isEmpty {
            stack.append((line[i], i))
        }
        else {
            while let tmp = stack.last {
                if tmp.0 <= line[i] {
                    stack.append((line[i], i))
                    break
                }
                else {
                    let lastElement = stack.removeLast()
                    if stack.isEmpty {
                        result = max(result, (i-1)*lastElement.0)
                        stack.append((line[i], i))
                        break
                    }
                    else {
                        let beforeLast = stack.last!
                        result = max(result, (i - beforeLast.1 - 1)*lastElement.0)
                    }
                }
            }
        }
    }
    print(result)
}

백준 17298 오큰수

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/17298

수열이 주어졌을 때 각 원소에 대해서 본인보다 오른쪽에 있으면서 본인보다 원소 값이 큰 수 중에서 가장 왼쪽에 있는 수를 구하는 문제이다. 이 때 존재하지 않는다면 -1을 출력하도록 한다.

스택을 활용하면 아주 간단하게 풀리는 문제이다. 먼저 스택에 수열을 앞에서부터 집어넣는데 이 때 수열의 index를 같이 저장시켜준다. 만약 새롭게 들어오는 원소가 stack에 top에 들어있는 값보다 크다면 stack에서 pop해준 뒤 해당 index에 새롭게 들어오는 원소값을 입력해주면 되는 문제이다.

최종적으로 stack에 남아있는 원소들에 대해서는 index를 하나씩 찾아가 -1을 입력해주면 된다.

전체 코드

let n = Int(readLine()!)!
var num = readLine()!.split(separator: " ").map{Int(String($0))!}
var stack:[(v:Int, i:Int)] = []
stack.append((v:num[0], i:0))
for i in 1..<n {
    let value = num[i]
    while let tmp = stack.last {
        if tmp.v < value {
            num[tmp.i] = value
            stack.removeLast()
        }
        else {
            break
        }
    }
    stack.append((v:num[i], i:i))
}
while let tmp = stack.popLast() {
    num[tmp.i] = -1
}
var str = ""
for i in num {
    str += "\(i) "
}
print(str)

백준 8462 배열의 힘

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/8462

배열이 주어질때 부분 배열 안에 있는 자연수 s의 개수를 K_s라고 하자. 그러면 쿼리가 주어지면 쿼리 범위에 나타나는 모든 자연수에 대해서 K_s x K_s x s 의 합들을 구하는 문제이다. 앞에서와 마찬가지로 mo’s algorithm으로 해결할 것이다. 만약에 구간 변동으로 인해 어떤 자연수 s의 갯수가 1개 증가 혹은 감소하게 되면 새로운 값은 다음과 같다.

(Ks+1)*(Ks+1)*s = Ks*Ks*s + (2Ks+1)*s
(Ks-1)*(Ks-1)*s = Ks*Ks*s + (1-2Ks)*s

즉 구간변동으로 값이 바뀔때마다 뒷부분의 값을 추가해주면 되는 문제이다.

전체 코드

import Foundation

let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nm[0], m = nm[1], sqrtN = Int(sqrt(Double(n)))
let A = [0] + readLine()!.split(separator: " ").map{Int(String($0))!}
var query = Array(repeating: (0, 0, 0), count: m)
var qResult = Array(repeating: 0, count: m)
var count = Array(repeating: 0, count: 1000001)
for i in 0..<m {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    query[i] = (line[0], line[1], i)
}
query.sort(by: {$0.1 < $1.1})
query.sort(by: {$0.0/sqrtN < $1.0/sqrtN})

func plus(s: Int, e: Int, r: inout Int) {
    for i in s...e {
        r += A[i]*(2*count[A[i]]+1)
        count[A[i]] += 1
    }
}

func minus(s: Int, e: Int, r: inout Int) {
    for i in s...e {
        r += A[i]*(1-2*count[A[i]])
        count[A[i]] -= 1
    }
}

var result = 0, ps = query[0].0, pe = query[0].1
plus(s: ps, e: pe, r: &result)
qResult[query[0].2] = result
for i in 1..<m {
    let curr = query[i]
    if ps < curr.0 {
        minus(s: ps, e: curr.0-1, r: &result)
    }
    else if ps > curr.0 {
        plus(s: curr.0, e: ps-1, r: &result)
    }
    if pe < curr.1 {
        plus(s: pe+1, e: curr.1, r: &result)
    }
    else if pe > curr.1 {
        minus(s: curr.1+1, e: pe, r: &result)
    }
    ps = curr.0
    pe = curr.1
    qResult[curr.2] = result
}

var str = ""
for i in 0..<m {
    str += "\(qResult[i])\n"
}
print(str)

백준 13547 수열과 쿼리 5

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/13547

길이 N의 수열이 주어졌을때 쿼리 i j 가 주어지면 A[i] - A[j] 에 존재하는 서로 다른 수의 개수를 출력하는 문제이다. 쿼리의 수가 많고 입력 수열에 변화가 없는 오프라인 쿼리이기 때문에 mo’s 알고리즘을 사용하였다. 앞에서 배운 개념에 약간의 변화를 줘야하는데 서로 다른 수의 개수를 세줘야 하기 때문이다. 그 외에는 평방 분할을 한 후 정렬해 쿼리를 처리해주면 된다는 것만 신경쓰면 된다.

구간 변화 작업 함수

func minus(s: Int, e: Int, val: inout Int) {
    for i in s...e {
        count[A[i]] -= 1
        if count[A[i]] == 0 {val -= 1}
    }
}

func plus(s: Int, e: Int, val: inout Int) {
    for i in s...e {
        if count[A[i]] == 0 {val += 1}
        count[A[i]] += 1
    }
}

구간이 변할때마다 구간이 증가하면 plus함수를 감소하면 minus함수를 호출할 것인데 각각의 함수는 서로 다른 수의 갯수이기 때문에 새롭게 수가 0에서 1로 증가할 경우와 기존의 수가 1에서 0으로 감소하는 경우 두가지가 발생하면 전체 result에 값을 1 변동되게 하였다. 그 외에는 count라는 배열을 통해서 각 수가 세어진 횟수를 저장해두는 방식으로 구현했다.

파일의 입력이 크기때문에 fread를 해줘야 시간초과가 안난다. 관련 코드는 JCSooHwanCho님의 FileIO.swift 를 참조하였다.
<출처 : https://gist.github.com/JCSooHwanCho/30be4b669321e7a135b84a1e9b075f88>

전체 코드

/*
 fread 코드는 JCSooHwanCho님의 FileIO.swift 를 참조하였습니다.
 <출처 : https://gist.github.com/JCSooHwanCho/30be4b669321e7a135b84a1e9b075f88>
*/

import Foundation

final class FileIO {
    private let buffer:[UInt8]
    private var index: Int = 0

    init(fileHandle: FileHandle = FileHandle.standardInput) {
        buffer = Array(try! fileHandle.readToEnd()!)+[UInt8(0)] // 인덱스 범위 넘어가는 것 방지
    }

    @inline(__always) private func read() -> UInt8 {
        defer { index += 1 }
        return buffer[index]
    }

    @inline(__always) func readInt() -> Int {
        var sum = 0
        var now = read()
        var isPositive = true

        while now == 10
                || now == 32 { now = read() } // 공백과 줄바꿈 무시
        if now == 45 { isPositive.toggle(); now = read() } // 음수 처리
        while now >= 48, now <= 57 {
            sum = sum * 10 + Int(now-48)
            now = read()
        }

        return sum * (isPositive ? 1:-1)
    }

    @inline(__always) func readString() -> String {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return String(bytes: Array(buffer[beginIndex..<(index-1)]), encoding: .ascii)!
    }

    @inline(__always) func readByteSequenceWithoutSpaceAndLineFeed() -> [UInt8] {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return Array(buffer[beginIndex..<(index-1)])
    }
}

let fIO = FileIO()
let n = fIO.readInt(), sqrtN = Int(sqrt(Double(n)))
var A = Array(repeating: 0, count: n+1)
for i in 1...n {
    A[i] = fIO.readInt()
}
let m = fIO.readInt()
var query:[(Int, Int, Int)] = Array(repeating: (0, 0, 0), count: m)
var count:[Int] = Array(repeating: 0, count: 1_000_001)

func minus(s: Int, e: Int, val: inout Int) {
    for i in s...e {
        count[A[i]] -= 1
        if count[A[i]] == 0 {val -= 1}
    }
}

func plus(s: Int, e: Int, val: inout Int) {
    for i in s...e {
        if count[A[i]] == 0 {val += 1}
        count[A[i]] += 1
    }
}

for i in 0..<m {
    query[i] = (fIO.readInt(), fIO.readInt(), i)
}
query.sort(by: {$0.1 < $1.1})
query.sort(by: {$0.0/sqrtN < $1.0/sqrtN})

var queryResult = Array(repeating: 0, count: m)
var result = 0, ps = query[0].0, pe = query[0].1
plus(s: ps, e: pe, val: &result)
queryResult[query[0].2] = result
for i in 1..<query.count {
    let curr = query[i]
    if curr.0 < ps {plus(s: curr.0, e: ps-1, val: &result)}
    else if curr.0 > ps {minus(s: ps, e: curr.0-1, val: &result)}
    if curr.1 > pe {plus(s: pe+1, e: curr.1, val: &result)}
    else if curr.1 < pe {minus(s: curr.1+1, e: pe, val: &result)}
    ps = curr.0
    pe = curr.1
    queryResult[curr.2] = result
}

var str = ""
for i in 0..<queryResult.count {
    str += "\(queryResult[i])\n"
}
print(str)

백준 1086 박성원

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1086

정수로 이루어진 집합이 주어질 때 정수들을 앞뒤로 배치시켜서 큰 정수를 만들었을 때 해당 정수가 K로 나누어 떨어질 확률을 구하는 문제이다. 나머지의 원리를 이용하는 문제이다. 5221 이라는 숫자 뒤에 40 이라는 숫자가 온다고 생각해보자.

522140 % k = ((5221*100)%k + 40%k)%k = ((5221%k * 100%k)%k + 40%k)%k

식이 굉장히 복잡해보이지만 간단히 설명하면 새로운 숫자를 붙이려고 한다면 다음 세가지의 수의 식으로 표현된다는 것이다.

(기존의 만들어진 큰 수)%k
(10^새로운 숫자의 길이)%k
(새로운 숫자)%k

따라서 우리는 각 배열의 숫자마다 길이를 저장해둘 것이고 각 배열의 수를 k로 나눈 값들을 저장해 둘 것이다. 여기에 배열에서 어떤 정수들을 사용했는지를 bitmask를 활용해서 표시해줄 것이고 그렇게 만들어진 큰 정수를 k로 나눴을때 나머지가 몇인지에 따라서 dp값을 저장해 줄 것이다.

DP code (bottom up)

var dp:[[CLongLong]] = Array(repeating: Array(repeating: 0, count: k), count: (1<<n))
dp[0][0] = 1
for i in 0..<(1<<n) {
    for j in 0..<k {
        if dp[i][j] == 0 {
            continue
        }
        for idx in 0..<n {
            if (i & (1<<idx)) == 0 {
                let next = ((j*ten[len[idx]])%k + modnum[idx]) % k
                dp[i|(1<<idx)][next] += dp[i][j]
            }
        }
    }
}

ten은 10의 제곱들의 mod k이고 modnum은 기존 정수값의 mod k 이다. 이 때 아무것도 없는 상태를 dp[0][0] = 1로 초기값을 준 후 바텀업으로 dp를 구성해나갈 것이다.

i와 j의 역할이 뭔가 헤깔릴 수도 있는데 예를들어 1번, 2번, 3번을 사용해서 만든 큰 수가 나머지가 0일때와 2일때 3일때가 존재한다고 했을 때 1,2,3번을 사용했다는 정보는 i로 나타내줄것이고 나머지가 0, 2, 3이라는 정보는 j로 나타내줄 수 있다. 그 때의 dp[i][j]는 경우의수가 있으므로 0이 아닌 값이 저장되어 있어 continue 구문을 통과해 다음 구문을 수행한다.

해당 정수 뒤에 다음 정수를 붙이고자 할 때 idx라는 변수를 활용하여 만약 아직 사용한 적이 없는 정수라면 그 정수를 붙여 만든 큰 수의 mod k는 next에 저장되고 dp[i|(1<<idx)][next] += dp[i][j] 코드를 통해서 경우의 수를 업데이트 시켜준다. 최종적으로 dp[(1<<n)-1][0] 에 우리가 구하고자 하는 값이 들어있을 것이고 이것을 전체 경우의 수와 최대 공약수를 찾아 분수형태로 출력해주면 된다.

전체 코드

import Foundation
let n = Int(readLine()!)!
var num:[String] = []
var modnum:[Int] = []
var len:[Int] = []
var ten = Array(repeating: 1, count: 51)
var fact:[CLongLong] = Array(repeating: 1, count: 16)
for _ in 1...n {
    let tmp = readLine()!
    len.append(tmp.count)
    num.append(tmp)
}
let k = Int(readLine()!)!
for i in 1...50 {
    ten[i] = (ten[i-1]*10) % k
}
for i in 1...15 {
    fact[i] = fact[i-1]*CLongLong(i)
}
for i in 0..<n {
    var tmp = 0
    for c in num[i] {
        tmp = (tmp*10 + Int(String(c))!) % k
    }
    modnum.append(tmp)
}
var dp:[[CLongLong]] = Array(repeating: Array(repeating: 0, count: k), count: (1<<n))
dp[0][0] = 1

for i in 0..<(1<<n) {
    for j in 0..<k {
        if dp[i][j] == 0 {
            continue
        }
        for idx in 0..<n {
            if (i & (1<<idx)) == 0 {
                let next = ((j*ten[len[idx]])%k + modnum[idx]) % k
                dp[i|(1<<idx)][next] += dp[i][j]
            }
        }
    }
}

let gcdVal = gcd(a: dp[(1<<n)-1][0], b: fact[n])
print("\(dp[(1<<n)-1][0]/gcdVal)/\(fact[n]/gcdVal)")

func gcd(a: CLongLong, b: CLongLong) -> CLongLong {
    return b == 0 ? a : gcd(a:b, b:a % b)
}

백준 2098 외판원 순회

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2098

N개의 도시가 있을 때 각 도시간 이동 비용이 주어진다고 하자. 이 때 갈 수 없는 경우는 0으로 나타나고 모든 도시간의 비용은 양의 정수라고 하자. 이 때 중복없이 모든 도시를 지난 후 시작도시로 돌아오는 가장 적은 비용을 구하는 문제이다.

DFS와 DP를 결합해서 문제를 풀어주어야 한다. 이 때 비트마스크를 활용해 여행해온 도시의 상태를 나타내줄 예정이다. 먼저 모든 도시간 이동방법을 고려해주기 위해서 DFS를 이용해서 모든 경로를 탐색할 것이다.

이 때 단순히 모든 경로를 탐색하게 된다면 경우의 수가 너무 많기 때문에 DP를 활용해서 중복 경로를 줄여줄 것이다. 1-2-3 이후에 4라는 도시로 간다고 해보자. 그러면 4부터 모든 도시를 돌아 1로 돌아오는 최단 거리를 dp에 저장해주자. 탐색도중에 우리는 1-3-2 이후에 4라는 도시로 가는 경우가 있을 것이다. 이 때 4부터 모든 도시를 돌아 1로가는 최단 거리는 dp에 저장되어 있기 때문에 두 번 연산해줄 필요가 없다. 이렇듯 겹치는 경로에 대해서는 dp를 활용할 것이다.

그런데 1-5-3 이후에 4라는 도시로 가는 경우를 생각해보자. 이때는 여지껏 거쳐온 도시가 다르기 때문에 위에서 구한 dp값을 쓸 수가 없다. 즉 우리가 어떤 도시를 거쳐왔는지로 dp를 구분시켜줘야 한다는 것이다. 이 때 비트마스크를 사용하여 어떤 도시를 거쳐왔는지를 간단히 정수로 표현할 것이다.

DFS function

func dfs(d: Int, visited: Int) -> Int {
    if visited == ((1<<n)-1) {
        return cost[d][0] == 0 ? 16_000_001 : cost[d][0]
    }
    else if dp[d][visited] != -1 {
        return dp[d][visited]
    }
    else {
        dp[d][visited] = 16_000_001
        for i in 0..<n {
            if (visited & (1<<i)) == 0 && cost[d][i] != 0 {
                dp[d][visited] = min(dp[d][visited], dfs(d: i, visited: visited | (1<<i)) + cost[d][i])
            }
        }
        return dp[d][visited]
    }
}

자 위의 코드를 한번 보자. visited라는 Int 변수가 나타난다는 것을 알 수 있다. 여기에 비트마스크를 활용할 것이다. 먼저 첫번째 if문을 보면 if visited == (1<<n)-1로 둘을 비교하고있다. (1<<n)-1는 0부터 n-1까지의 bit를 모두 1로 만들어주는 역할을 하고 있다. 이 조건문이 true라면 모든 도시를 탐색했다는 소리이다. 이 경우 우리는 첫번째 도시로 돌아가야하기 때문에 d라는 도시에서 0번째 도시로 가는 경로가 존재할 경우 그 비용을 return 해준다.

자 그러면 마지막 else문을 살펴보자. visited에는 우리가 여지껏 거쳐온 도시의 정보가 들어있다. 따라서 if (visited & 1<<i) 를 하게되면 i번째 도시를 탐색한 적이 있는지 확인할 수 있다. 그래서 만약 도시 이동이 가능하다면 해당 도시로 이동해서 새롭게 dfs를 시행해준다. visited | (1<<i)를 하게되면 visited에 i번째 bit를 1로 만들 수 있다는 것을 명심하자.

전체 코드

let n = Int(readLine()!)!
var dp:[[Int]] = Array(repeating: Array(repeating: -1, count: 1<<n), count: 20)
var cost:[[Int]] = []
for _ in 1...n {
    cost.append(readLine()!.split(separator: " ").map{Int(String($0))!})
}

func dfs(d: Int, visited: Int) -> Int {
    if visited == ((1<<n)-1) {
        return cost[d][0] == 0 ? 16_000_001 : cost[d][0]
    }
    else if dp[d][visited] != -1 {
        return dp[d][visited]
    }
    else {
        dp[d][visited] = 16_000_001
        for i in 0..<n {
            if (visited & (1<<i)) == 0 && cost[d][i] != 0 {
                dp[d][visited] = min(dp[d][visited], dfs(d: i, visited: visited | (1<<i)) + cost[d][i])
            }
        }
        return dp[d][visited]
    }
}
var result = 16_000_001
result = min(result, dfs(d: 0, visited: 1))
print(result)

백준 1311 할 일 정하기 1

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1311

n명의 사람과 n개의 일이 있을 때 사람마다 일을 처리하는 비용이 각각 적혀있다고 했을 때 모든 일을 하는데 필요한 비용의 최솟값을 구하는 문제이다. n개의 일에 대해 비트마스크를 적용시켜 상태를 확인한다고 하자. 모든 경우에 대해 탐색해야하기 때문에 dfs를 사용할 것이고 중복 연산을 방지하기 위해 dp를 사용할 것이다.

0번째 사람부터 n-1번째 사람까지 하나씩 일을 부여할 것인데 visited라는 변수를 통해 아직 해결되지 않은 일들을 for문을 통해 다음 사람에게 부여시킨다. for문 내부에서는 dfs를 통해 해당 경우의 최소 비용을 탐색해오고 그 중 가장 적은 비용이 드는 것을 선택한다.

visited를 비트마스크가 아닌 배열로 해도 기능상에는 차이가 없다. 하지만 길이 20의 배열을 계속해서 함수 호출로 넘겨줘야하기 때문에 overhead가 상당하다. 그래서 비트마스크를 활용하는 것이다.

전체 코드

let n = Int(readLine()!)!
var dp:[[Int]] = Array(repeating: Array(repeating: -1, count: 1<<21), count: 20)
var cost:[[Int]] = []
for _ in 1...n {
    cost.append(readLine()!.split(separator: " ").map{Int(String($0))!})
}

func dfs(d: Int, visited: Int) -> Int {
    if d == n {
        return 0
    }
    else if dp[d][visited] != -1 {
        return dp[d][visited]
    }
    else {
        dp[d][visited] = 1_000_000
        for i in 0..<n {
            if (visited & (1<<i)) == 0 {
                dp[d][visited] = min(dp[d][visited], dfs(d: d+1, visited: visited|(1<<i)) + cost[d][i])
            }
        }
        return dp[d][visited]
    }
}
print(dfs(d:0, visited:0))

백준 11012 Egg

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11012

총 n개의 점들의 위치가 주어질 때 사각형의 왼쪽과 오른쪽, 아래와 위의 좌표를 나타내주는 쿼리가 주어지면 해당 쿼리의 사각형 안에 총 몇개의 점들이 포함되어있는지 세는 문제이다. 다른 방법도 있는 것 같지만 스위핑으로 풀 수 있다고 되어있어서 스위핑과 세그먼트 트리 개념만을 이용해서 풀었다.

먼저 y좌표마다 점이 있는 x좌표를 표시해준다. 그 후 쿼리들을 저장시켜주는데 이 때 트릭이 필요하다. 다음 그림을 한번 보자.

각 column마다 점이 등장하면 값에 1을 더해주는 형태로 좌표를 구성해보자. 이 때 우리가 빨갛게 칠한 영역내의 점들의 갯수를 구하고 싶다면 영역 최상단의 1 + 1 + 2 에서 영역 바로 아래에 해당하는 1 + 0 + 1을 빼주면 된다. 해당 영역에서 점이 나타났다면 그만큼 값이 증가했을 것이기 때문이다.

쿼리 저장 코드

for i in 0..<m {
    let parade = readLine()!.split(separator: " ").map{Int(String($0))!}
    arr.append((parade[0]+1, parade[1]+1, parade[2], i))
    arr.append((parade[0]+1, parade[1]+1, parade[3]+1, i))
}
arr.sort(by: {$0.2 < $1.2})

이 개념을 활용하여 영역 바로 아랫부분과 영역의 제일 윗부분으로 쿼리를 나눠서 각각 저장시켜준다. 그 후 array를 y좌표를 기준으로 정렬시켜준다. 이 때 쿼리를 나눠서 저장시킬 때 몇번째 쿼리인지를 같이 저장시켜줘야한다.

세그먼트 코드 & 쿼리 처리 코드

var index = 0
var result = 0
for p in arr {
    while index <= p.2 {
        for i in ydp[index] {
            updateTree(tree: &tree, start: 1, end: 100001, node: 1, index: i, val: 1)
        }
        index += 1
    }
    //index를 증가시키며 해당 라인에 있는 점들을 모두 업데이트
    let findresult = findTree(tree: tree, start: 1, end: 100001, node: 1, left: p.0, right: p.1)
    
    if paradeResult[p.3] == -1 {
        paradeResult[p.3] = findresult 
        //처음 만나는 쿼리라면 그냥 값을 저장
    }
    else {
        result += findresult - paradeResult[p.3] 
        //두번째 만나는 쿼리라면 차이만큼 결과에 더함 
    }
}

여기서부터는 세그먼트 트리만 알면 쉽다. y값이 작은 놈부터 쿼리가 저장되어있을텐데 해당 y값까지 index를 하나씩 증가시키면서 ydp[index] 위의 점들을 세그먼트 트리에 추가시켜준다. 그 후 우리가 원하는 구간에 대해 값을 구해준다.

위에서 몇번째 쿼리인지 같이 저장한 이유가 여기서 나온다. 만약 처음 만나는 쿼리라면 쿼리의 아랫부분에 해당할 것이고 일단 그 값을 저장시킨다. 그 후 이미 만난적이 있는 쿼리라면 쿼리의 윗부분에 해당할 것이고 기존에 저장되어있던 값과의 차가 우리가 구하고자 하는 결과일 것이다.

전체 코드

func updateTree(tree: inout [Int], start: Int, end: Int, node: Int, index: Int, val: Int) {
    if index < start || index > end {
        return
    }
    tree[node] += val
    if start == end {
        return
    }
    let mid = (start+end)/2
    updateTree(tree: &tree, start: start, end: mid, node: 2*node, index: index, val: val)
    updateTree(tree: &tree, start: mid+1, end: end, node: 2*node+1, index: index, val: val)
}

func findTree(tree: [Int], start: Int, end: Int, node: Int, left: Int, right: Int) -> Int {
    if right < start || left > end {
        return 0
    }
    if left <= start && end <= right {
        return tree[node]
    }
    let mid = (start+end)/2
    return findTree(tree: tree, start: start, end: mid, node: 2*node, left: left, right: right) + findTree(tree: tree, start: mid+1, end: end, node: 2*node+1, left: left, right: right)
}

let t = Int(readLine()!)!
for _ in 0..<t {
    let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
    let n = nm[0], m = nm[1]
    var ydp:[[Int]] = Array(repeating: [], count: 100002)
    var arr:[(Int, Int, Int, Int)] = []
    var tree:[Int] = Array(repeating: 0, count: 2*131072)
    var paradeResult:[Int] = Array(repeating: -1, count: m)
    for _ in 0..<n {
        let xy = readLine()!.split(separator: " ").map{Int(String($0))!}
        let x = xy[0], y = xy[1]
        ydp[y+1].append(x+1)
    }
    for i in 0..<m {
        let parade = readLine()!.split(separator: " ").map{Int(String($0))!}
        arr.append((parade[0]+1, parade[1]+1, parade[2], i))
        arr.append((parade[0]+1, parade[1]+1, parade[3]+1, i))
    }
    arr.sort(by: {$0.2 < $1.2})
    var index = 0
    var result = 0
    for p in arr {
        while index <= p.2 {
            for i in ydp[index] {
                updateTree(tree: &tree, start: 1, end: 100001, node: 1, index: i, val: 1)
            }
            index += 1
        }
        let findresult = findTree(tree: tree, start: 1, end: 100001, node: 1, left: p.0, right: p.1)
        if paradeResult[p.3] == -1 {
            paradeResult[p.3] = findresult
        }
        else {
            result += findresult - paradeResult[p.3]
        }
    }
    print(result)
}

백준 5419 북서풍

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/5419

이 문제를 풀기 위해서는 총 3개의 개념을 알아야한다. 첫번째로는 스위핑이고 두번째로는 세그먼트트리 (여기서는 팬윅트리로 구현했지만 세그먼트로도 가능하다), 마지막으로는 좌표압축이다. 좌표압축은 간단하지만 세그먼트 트리는 모르면 힘들기 때문에 세그먼트 트리 파트를 가서 공부하고 다시 푸는 것을 추천드린다.

먼저 문제는 간단하다. 좌표상에 수많은 점이 주어지면 본인보다 x값은 같거나 작고 y값은 크거나 같은 점들의 갯수를 모든 점에 대해서 세어주면 된다.

스위핑

island.sort(by: {$0.0 < $1.0})
island.sort(by: {$0.1 > $1.1})

우리는 x축, y축 두가지에 대해 모두 고려를 해줘야하기 때문에 앞선 문제들과는 다르게 쉽사리 접근하기가 어렵다. 먼저 스위핑을 사용하여 sort를 2번 사용하여 y축에 대해서 큰 값부터 작은 값이 오도록 정렬하되 y값이 같다면 x값이 작은 점이 먼저 오도록 정렬을 하자. 그러면 y축에 대해서는 고려를 이제 안해줘도 된다는 것이 보일 것이다.

세그먼트(펜윅) 트리

var result:CLongLong = 0
for s in islandX {
    result += CLongLong(fenwickFind(fwk: tree, index: s))
    fenwickUpdate(fwk: &tree, index: s, val: 1, n: n)
}

그렇다면 x축 값이 본인보다 작은 녀석들의 갯수를 모두 세줘야하는데 이 때 생각나는 것이 세그먼트 트리이다. 세그먼트를 활용하여 본인보다 작거나 같은 범위에 있는 점들의 갯수를 구해주면 된다. 그 후 점이 1개 추가되었으므로 본인 위치에 1만큼 값을 update해준다. 이 때 정렬된 순서로 확인하기 때문에 1을 업데이트 해줘야 나중에 살펴볼 점들이 본인을 count한다는 것을 알 수 있다.

그런데 여기서 fenwick트리를 사용하려고 하니 x좌표 범위가 음수까지 있어서 어떻게 배열로 나타내야 할지 당황할 수 있다. 이 때 사용하는 것이 좌표압축이다.

좌표압축 function

func arrMapedX(arr: [(Int, Int)]) -> [Int] {
    let arr_sorted = arr.sorted(by: {$0.0 < $1.0})
    var index = 1
    var dict = Dictionary<Int, Int>()
    for i in arr_sorted {
        guard dict[i.0] != nil else {
            dict[i.0] = index
            index += 1
            continue
        }
    }
    var tmp = [Int]()
    for i in arr {
        tmp.append(dict[i.0]!)
    }
    return tmp
}

좌표압축은 그렇게 어려운 코드가 아니니까 한번 읽어보면 이해가 갈 것이다. dictionary 구조체를 활용하여 가장 작은 값부터 1부터 증가하는 번호를 매긴 후 원래 배열의 값들을 바뀐 번호로 압축시키는 형태이다. 이렇게 되면 넓은 범위를 가지거나 음수의 범위가 나타나도 팬윅트리를 활용할 수 있는 범위로 바뀐다. (좌표간의 대소관계가 중요한 것이지 그 차이가 중요한 것이 아니기 때문에 좌표압축을 사용할 수 있다)

파일의 입력이 크기때문에 fread를 해줘야 시간초과가 안난다. 관련 코드는 JCSooHwanCho님의 FileIO.swift 를 참조하였다.
<출처 : https://gist.github.com/JCSooHwanCho/30be4b669321e7a135b84a1e9b075f88>

전체 코드

/*
 fread 코드는 JCSooHwanCho님의 FileIO.swift 를 참조하였습니다.
 <출처 : https://gist.github.com/JCSooHwanCho/30be4b669321e7a135b84a1e9b075f88>
*/
import Foundation

final class FileIO {
    private let buffer:[UInt8]
    private var index: Int = 0

    init(fileHandle: FileHandle = FileHandle.standardInput) {
        buffer = Array(try! fileHandle.readToEnd()!)+[UInt8(0)] // 인덱스 범위 넘어가는 것 방지
    }

    @inline(__always) private func read() -> UInt8 {
        defer { index += 1 }
        return buffer[index]
    }

    @inline(__always) func readInt() -> Int {
        var sum = 0
        var now = read()
        var isPositive = true

        while now == 10
                || now == 32 { now = read() } // 공백과 줄바꿈 무시
        if now == 45 { isPositive.toggle(); now = read() } // 음수 처리
        while now >= 48, now <= 57 {
            sum = sum * 10 + Int(now-48)
            now = read()
        }

        return sum * (isPositive ? 1:-1)
    }

    @inline(__always) func readString() -> String {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return String(bytes: Array(buffer[beginIndex..<(index-1)]), encoding: .ascii)!
    }

    @inline(__always) func readByteSequenceWithoutSpaceAndLineFeed() -> [UInt8] {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return Array(buffer[beginIndex..<(index-1)])
    }
}

let fIO = FileIO()
let t = fIO.readInt()
var str = ""
for _ in 0..<t {
    let n = fIO.readInt()
    var tree:[Int] = Array(repeating: 0, count: n+1)
    var island:[(Int, Int)] = Array(repeating: (0, 0), count: n)
    for i in 0..<n {
        island[i] = (fIO.readInt(), fIO.readInt())
    }
    island.sort(by: {$0.0 < $1.0})
    island.sort(by: {$0.1 > $1.1})
    let islandX = arrMapedX(arr: island)
    var result:CLongLong = 0
    for s in islandX {
        result += CLongLong(fenwickFind(fwk: tree, index: s))
        fenwickUpdate(fwk: &tree, index: s, val: 1, n: n)
    }
    str += "\(result)\n"
}
print(str)

func fenwickFind(fwk: [Int], index: Int) -> Int {
    var idx = index
    var rst = 0
    while idx > 0 {
        rst += fwk[idx]
        idx -= (idx & -idx)
    }
    return rst
}

func fenwickUpdate(fwk: inout [Int], index: Int, val: Int, n: Int) {
    var idx = index
    while idx <= n {
        fwk[idx] += val
        idx += (idx & -idx)
    }
}

func arrMapedX(arr: [(Int, Int)]) -> [Int] {
    let arr_sorted = arr.sorted(by: {$0.0 < $1.0})
    var index = 1
    var dict = Dictionary<Int, Int>()
    for i in arr_sorted {
        guard dict[i.0] != nil else {
            dict[i.0] = index
            index += 1
            continue
        }
    }
    var tmp = [Int]()
    for i in arr {
        tmp.append(dict[i.0]!)
    }
    return tmp
}

백준 2836 수상 택시

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2836

상근이가 0번에서 M번으로 이동할 때 다른 사람들의 탑승위치와 내리는 위치가 주어지면 0번에서 출발하여 다른 사람들을 태운 뒤 원하는 곳에 모두 내려주고 M번으로 최종적으로 이동하는 거리의 최솟값을 구하는 문제이다.

얼핏보면 이전에 풀었던 2170 선긋기 문제와 유사하다는 것을 짐작할 수 있을 것이다. 잘 생각해보면 상근이가 0번에서 M번으로 이동해야하기때문에 시작점 < 끝점 인 승객들은 별다른 노력 없이 가는길에 태워서 내려다주면 된다. 그렇다면 우리가 고려해야할 것은 시작점 > 끝점 인 승객들이다. 해당 승객들에 대해서만 선긋기를 한다고 생각하자.

다음과 같이 2명의 역으로 올라가는 승객이 있다고 하자. 우리가 해당승객을 만날때마다 거꾸로 갔다가 다시 오면 총 이동거리는 밑쪽의 선분들의 합과 같다.

하지만 서로 겹치는 승객들에 대해서 매번 거슬러 오를 필요없이 한번에 처리를 하게되면 위의 사진과 같은 이동을 하게된다. 이 때 묶어서 처리하면 겹치는 부분*2의 길이만큼 더 적게 이동한다는 것을 확인할 수 있다.

input 처리 코드

for _ in 0..<n {
    let xy = readLine()!.split(separator: " ").map{Int(String($0))!}
    let x = xy[0], y = xy[1]
    if x > y {
        line.append((y, x))
    }
}
line.sort(by: {$0.0 < $1.0})

따라서 입력을 받았을 때 x > y인 경우만 우리가 고려할 line에 넣어주고 line을 sort해서 2170과 같은 방법으로 총 선분의 길이를 구해준다. 결과에 2를 곱해주고 m과 더해주면 끝! 이 때 m이 최대 10⁹ 이므로 Int64로 표현해줘야 안전하다는 것 기억하자.

전체 코드

let nm = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nm[0], m = nm[1]
var line:[(Int, Int)] = []
for _ in 0..<n {
    let xy = readLine()!.split(separator: " ").map{Int(String($0))!}
    let x = xy[0], y = xy[1]
    if x > y {
        line.append((y, x))
    }
}

line.sort(by: {$0.0 < $1.0})
var r = -1, l = -1
var result:CLongLong = 0
for m in line {
    if r < m.0 {
        l = m.0
        r = m.1
        result += CLongLong(r-l)
    }
    else if r < m.1 {
        result += CLongLong(m.1-r)
        r = m.1
    }
}
result *= 2
result += CLongLong(m)
print(result)

백준 2170 선 긋기

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2170

선분의 시작과 끝이 주어지고 그러한 선들이 n개 있다고 할 때 그려지는 선들의 총 길이를 구하는 문제이다. 이 때 겹치는 부분은 1번만 계산한다. 스위핑에 대해 감을 익히기 좋은 문제인것 같다. 선들을 시작점을 기준으로 sort한다고 생각하자. 그렇다면 연속된 두 선분의 관계는 다음 세 경우로 나뉜다.

line[i].end <= line[i+1].start
line[i].end > line[i+1].start && line[i].end >= line[1+1].end
line[i].end > line[i+1].start && line[i].end < line[i+1].end

1번의 경우에는 두개의 선분이 겹치는 부분이 없을때이므로 새로운 선분의 길이를 더해주면 된다.
2, 3번의 경우에는 두개의 선분이 겹치는 부분이 생긴다. 이 때 뒷 선분이 앞 선분에 포함되는 경우가 2번에 해당한다. 새로운 선분의 길이는 이 때 전부 겹치기 때문에 더해줄 필요가 없이 넘어간다.
3번의 경우에는 뒷 선분의 end와 앞 선분의 end의 차만큼을 더해줘야 한다.

길이 계산 코드

var left = -1_000_000_000, right = -1_000_000_000, result = 0
for l in line {
    if right < l.0 {
        left = l.0
        right = l.1
        result += right-left
    }
    //case 1
    else if l.1 > right {
        result += l.1-right
        right = l.1
    }
    //case 3
}

이 때 단순히 앞 선분과 비교를 하는 것이 아니라 여지껏 누적해온 선분들의 가장 오른쪽 좌표와 비교를 해야하기 때문에 right라는 변수를 활용하여 이를 비교해주었다.

전체 코드

/*
 fread를 위한 코드로는 JCSooHwanCho님의 FileIO.swift를 참조하였습니다.
 출처 : https://gist.github.com/JCSooHwanCho/30be4b669321e7a135b84a1e9b075f88
 */

import Foundation

final class FileIO {
    private let buffer:[UInt8]
    private var index: Int = 0

    init(fileHandle: FileHandle = FileHandle.standardInput) {
        buffer = Array(try! fileHandle.readToEnd()!)+[UInt8(0)] // 인덱스 범위 넘어가는 것 방지
    }

    @inline(__always) private func read() -> UInt8 {
        defer { index += 1 }
        return buffer[index]
    }

    @inline(__always) func readInt() -> Int {
        var sum = 0
        var now = read()
        var isPositive = true

        while now == 10
                || now == 32 { now = read() } // 공백과 줄바꿈 무시
        if now == 45 { isPositive.toggle(); now = read() } // 음수 처리
        while now >= 48, now <= 57 {
            sum = sum * 10 + Int(now-48)
            now = read()
        }

        return sum * (isPositive ? 1:-1)
    }

    @inline(__always) func readString() -> String {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return String(bytes: Array(buffer[beginIndex..<(index-1)]), encoding: .ascii)!
    }

    @inline(__always) func readByteSequenceWithoutSpaceAndLineFeed() -> [UInt8] {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return Array(buffer[beginIndex..<(index-1)])
    }
}

let fIO = FileIO()
let n = fIO.readInt()
var line:[(Int, Int)] = Array(repeating: (0,0), count: n)
for i in 0..<n {
    let x = fIO.readInt(), y = fIO.readInt()
    line[i] = (x, y)
}
line.sort(by: {$0.0 < $1.0})

var left = -1_000_000_000, right = -1_000_000_000, result = 0
for l in line {
    if right < l.0 {
        left = l.0
        right = l.1
        result += right-left
    }
    else if l.1 > right {
        result += l.1-right
        right = l.1
    }
}
print(result)

백준 13261 탈옥

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/13261

죄수의 수와 간수의 수가 주어지고 각 죄수마다 탈옥력 Ci가 주어질 때 탈옥 위험도 Ri는 Ci와 i번칸을 감시하는 간수의 감시하는 죄수의 수를 곱한 값이라고 했을 때 모든 Ri를 더한 값이 최소가 되도록 하는 문제이다. dp[i][j]를 i명의 간수가 j번 죄수까지 감시를 할 때 탈옥 위험도의 최솟값이라 정의하자. 그러면 dp를 다음과 같이 쓸 수 있다.

dp[i][j] = min(dp[i-1][k] + c[k][j])

i-1명의 간수가 k까지 살펴본다고 할 때 i번째 간수는 k+1번 죄수부터 j번죄수까지를 살펴보면 된다. 따라서 c[k][j]는 (j-k)*(Sum[j]-Sum[k])라고 정의할 수 있다. 여기서 Sum이란 Ci들의 누적합을 의미한다. c함수는 Monge Array이기 때문에 DnC optimization을 적용할 수 있다.

여기서 유의할 것은 앞서 푼 김치 문제처럼 i가 1개인 1차원이 아니라 2차원이라는 점이다. 따라서 i값을 1부터 간수의 최대 수까지 증가시켜가면서 dnc를 해줘야 한다는 점이다. 최종적으로 원하는 값은 dp[간수의 수][죄수의 수]에 저장되어 있다.

개인적으로 분할 정복 트릭의 기본 형태 그대로 적용하는 문제였기 때문에 분할 정복 트릭을 이해하는데 꽤 괜찮은 문제라고 생각한다.

전체 코드

let lg = readLine()!.split(separator: " ").map{Int(String($0))!}
let l = lg[0], g = lg[1]
let c = readLine()!.split(separator: " ").map{Int64(String($0))!}
var dp:[[Int64]] = Array(repeating: Array(repeating: -1, count: l+1), count: g+1)
var opt = Array(repeating: Array(repeating: -1, count: l+1), count: g+1)
var sum:[Int64] = Array(repeating: 0, count: l+1)
for i in 1...l {
    sum[i] = sum[i-1]+c[i-1]
    dp[1][i] = sum[i]*Int64(i)
}
for t in 2..<g+1 {
    dnc(s: 1, e: l, l: 1, r: l, t: t)
}
print(dp[g][l])

func dnc(s: Int, e: Int, l: Int, r: Int, t: Int) {
    if s > e {
        return
    }
    let m = (s+e)/2
    for i in l...min(r, m) {
        let dpVal = dp[t-1][i] + c(i+1, m)
        if dp[t][m] == -1 || dp[t][m] > dpVal {
            dp[t][m] = dpVal
            opt[t][m] = i
        }
    }
    dnc(s: s, e: m-1, l: l, r: opt[t][m], t: t)
    dnc(s: m+1, e: e, l: opt[t][m], r: r, t: t)
}

func c(_ i: Int, _ j: Int) -> Int64 {
    return (sum[j]-sum[i-1])*Int64(j-i+1)
}

백준 11001 김치

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11001

날짜와 시간제한이 주어질 때 각 날짜별 온도 Ti와 가치 Vi가 주어진다. 이 때 i일에 김치를 넣어서 j일에 김치를 꺼낸다면 (j-i)*Tj + Vi 로 정의되는 김치의 맛의 최댓값을 구하는 문제이다.

c[i][j] = (j-i)*Tj + Vi 로 c 함수를 정의하자. 즉 i일에 넣어서 j일에 꺼낼 때의 김치의 맛이 정의되어있다. 그런데 이 c함수는 Monge Array라는 것을 Monge Array 조건에 대입해보면 확인할 수 있다. 그렇다면 앞에서의 분할 정복 트릭을 생각해보자.

dp[i][j] = min(dp[i-1][k] + c[k][j]) where k < j && c[i][j] is Monge Array

그런데 여기서는 i라는 것이 없다. 따라서 이전 dp 값은 모두 없고 1차원 dp를 구한다고 생각해보자. 그렇다면 식은 다음처럼 변한다.

dp[j] = min(c[k][j]) where k < j && c is Monge Array

아하. 그렇다면 dp[j]를 j날에 김치를 꺼낼 때 가장 맛있는 김치값이라 정의하고 그것을 만족하는 k를 opt_j라고 할 수 있을 것이다. 그렇다면 j일보다 나중에 김치를 꺼낸다고 한다면 그때의 최솟값을 얻게해주는 opt 값은 k보다 크거나 같다는 것을 알 수 있다.

이해가 잘 안가는 사람은 위의 그림을 보자. 만약 정중앙 날짜의 해답이 노란색 화살표로 표시되어있을 때 해당 날짜보다 왼쪽 날짜들의 최적해는 노란색 최적해보다 작거나 같고 정중앙 날짜보다 오른쪽 날짜들의 최적해는 노란색 최적해보다 크거나 같다. 따라서 분할 정복으로 정중앙 값을 구하고 왼쪽 영역과 오른쪽 영역에 대해 각각 분할 정복을 반복적으로 실시해주면 된다.

dnc 코드 일부

var k = max(l, m-d)
for i in k...min(r, m) {
    if c(i: k, j: m) < c(i: i, j: m) {
        k = i
    }
}

코드를 보면 알겠지만 dnc 중간 부분에서 위의 코드가 나온다. 원래는 함수의 입력으로 들어온 l부터 r로 범위를 사용해야하나 max와 min값으로 범위를 제한해주는데 최대 d일까지 떨어져있을 수 있다는 조건과 집어넣은 날이 꺼내는 날보다 나중에 있을 수는 없기 때문에 범위를 제한해주었다.

전체 코드

let nd = readLine()!.split(separator: " ").map{Int(String($0))!}
let n = nd[0], d = nd[1]
let t = readLine()!.split(separator: " ").map{Int(String($0))!}
let v = readLine()!.split(separator: " ").map{Int(String($0))!}
var result:Int64 = 0
dnc(s: 0, e: n-1, l: 0, r: n-1)
print(result)

func c(i: Int, j: Int) -> Int64 {
    return Int64(j-i)*Int64(t[j])+Int64(v[i])
}

func dnc(s: Int, e: Int, l: Int, r: Int) {
    if s > e {
        return
    }
    let m = (s+e)/2
    var k = max(l, m-d)
    for i in k...min(r, m) {
        if c(i: k, j: m) < c(i: i, j: m) {
            k = i
        }
    }
    result = max(result, c(i: k, j: m))
    dnc(s: s, e: m-1, l: l, r: k)
    dnc(s: m+1, e: e, l: k, r: r)
}

백준 13263 나무 자르기

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/13263

나무들의 높이와 해당 나무를 다 자르고 난 후 충전 비용이 주어졌을 때 전기톱으로 나무를 자르는 가장 저렴한 방법 찾는 문제이다. 단 전기톱은 1번 사용시마다 충전해야하고 나무의 높이는 1만큼 감소한다. 마지막 나무의 충전 비용은 0이므로 사실상 마지막 나무를 가장 저렴하게 자르는 방법을 찾는 것과 같다. 이때 점화식은 다음과 같다.

dp[i] = min(b[j]*a[i] + dp[j])

딱 봐도 컨벡스헐 트릭 쓰는 문제로 보인다. 게다가 a는 증가수열이고 b는 감소수열이라고까지 조건을 제시해줬다. 다른건 앞에서 공부한 컨벡스 헐이랑 차이는 없지만 한가지 유의할 점으로는 a가 증가수열이기 때문에 lower bound로 직선을 찾을 필요가 없다는 것이다.

query 함수

func query(x: Int) -> Int {
    while ptr < stack.count-1 && stack[ptr+1].x < Double(x) {
        ptr += 1
    }
    return stack[ptr].f(x)
}

코드를 보면 알 수 있듯이 ptr이라는 이전 선분이 위치한 index부터 1씩 증가시키면서 보면 된다. 초기값으로는 기울기 b[0], 절편 0으로 주고 시작하면 된다. 왜냐하면 충전이 되어있고 첫번째 나무의 길이는 항상 1이기 때문에 첫번째 나무를 자르는데 드는 비용은 0이 되기 때문이다.

전체 코드

struct line {
    var a:Int
    var b:Int
    var x:Double
    func f(_ xx: Int) -> Int {
        return a*xx+b
    }
}

let INF:Double = 1_000_000_007
var stack:[line] = []
var ptr = 0

func intersect(a: line, b: line) -> Double {
    return Double(b.b-a.b)/Double(a.a-b.a)
}

func addLine(a: Int, b: Int) {
    var tmp = line(a: a, b: b, x: -INF)
    if stack.isEmpty {
        stack.append(tmp)
        return
    }
    while !stack.isEmpty {
        let top = stack.last!
        let x = intersect(a: top, b: tmp)
        if x <= top.x {
            stack.removeLast()
        }
        else {
            break
        }
    }
    tmp.x = intersect(a: stack.last!, b: tmp)
    stack.append(tmp)
    if ptr >= stack.count {
        ptr = stack.count-1
    }
}

func query(x: Int) -> Int {
    while ptr < stack.count-1 && stack[ptr+1].x < Double(x) {
        ptr += 1
    }
    return stack[ptr].f(x)
}

let n = Int(readLine()!)!
var a = readLine()!.split(separator: " ").map{Int(String($0))!}
var b = readLine()!.split(separator: " ").map{Int(String($0))!}
var dp = Array(repeating: 0, count: n)
addLine(a: b[0], b: dp[0])
for i in 1..<n {
    dp[i] = query(x: a[i])
    addLine(a: b[i], b: dp[i])
}
print(dp[n-1])

백준 14751 Leftmost Segment

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/14751

최하단과 최상단의 y좌표가 주어졌을 때 h_upper와 h_lower 상에 점이 있어 두 점을 이은 직선들이 주어진다고 하자. 이 때 h_upper와 h_lower 사이의 y값이 주어질 때 만나게 되는 가장 왼쪽의 선분의 h_upper상의 값을 출력하는 문제이다.

먼저 컨벡스 헐 트릭을 적용시키면 가장 왼쪽의 선분을 구하는데 용이할 것이다. 컨벡스 헐을 적용시키기 위해 그림을 90도 반시계 방향으로 회전시켜 h_upper를 x = 0 선분으로 생각하고 시작하였다. 그 후 수많은 입력 선분들을 기울기가 감소하는 순서로 정렬시킨 후 컨벡스 헐 트릭을 적용했다. 직선의 up 좌표는 절편이 될 것이고 기울기는 (down-up)/(Ymax-Ymin)으로 표현될 것이다.

line insert 함수

var stack:[line] = Array(repeating: line(), count: 100001)
var sz = 0
func insert(v: line) {
    stack[sz] = v
    while sz != 0 && (stack[sz].down-stack[sz].up) == (stack[sz-1].down-stack[sz-1].up) && stack[sz].up < stack[sz-1].up {
        stack[sz-1] = stack[sz]
        sz -= 1
    }
    while sz > 1 && compare3(p: sz-2, q: sz-1, r: sz){
        stack[sz-1] = stack[sz]
        sz -= 1
    }
    sz += 1
}

먼저 컨벡스 헐 트릭의 핵심이 되는 line insert 함수이다. 앞에서 설명했듯이 이전 직선이 필요없어지면 sz를 감소시켜 해당 위치에 새로운 직선을 배치하는 방식으로 구현했다. 단 기울기가 같으면 절편값을 이용해 비교해 주었다. compare3함수는 세 직선을 비교해 가운데 직선을 삭제해도 될지 결정해주는 함수이다.

query 처리 함수

func sol(x: Double) -> Int {
    var lo = 0, hi = sz-1
    while lo < hi {
        let mid = (lo+hi)/2
        if compareX(p: mid, q: mid+1, x: x) {
            lo = mid+1
        }
        else {
            hi = mid
        }
    }
    return stack[hi].idx
}

유의해야할 것은 입력으로 들어오는 쿼리가 Q[i] < Q[i+1]을 만족하지 않는다는 것이다. 따라서 이분탐색을 통해서 적합한 직선을 찾아주고 직선의 index값을 출력해주어야한다.

전체 코드

struct line {
    var up: Int64
    var down: Int64
    var idx: Int
    init() {
        up = 0
        down = 0
        idx = -1
    }
    init(up: Int64, down: Int64, idx: Int) {
        self.up = up
        self.down = down
        self.idx = idx
    }
}
let Y = readLine()!.split(separator: " ").map{Int64(String($0))!}
let maxY = Y[0], minY = Y[1]
var stack:[line] = Array(repeating: line(), count: 100001)
var sz = 0

func insert(v: line) {
    stack[sz] = v
    while sz != 0 && (stack[sz].down-stack[sz].up) == (stack[sz-1].down-stack[sz-1].up) && stack[sz].up < stack[sz-1].up {
        stack[sz-1] = stack[sz]
        sz -= 1
    }
    while sz > 1 && compare3(p: sz-2, q: sz-1, r: sz){
        stack[sz-1] = stack[sz]
        sz -= 1
    }
    sz += 1
}

func compare3(p: Int, q: Int, r: Int) -> Bool {
    let a1 = stack[p], a2 = stack[q], a3 = stack[r]
    return (a2.up-a1.up)*(maxY-minY)*(a2.down-a2.up-a3.down+a3.up) > (a3.up-a2.up)*(maxY-minY)*(a1.down-a1.up-a2.down+a2.up)
}

func compareX(p: Int, q: Int, x: Double) -> Bool {
    let a1 = stack[p], a2 = stack[q]
    return Double(a2.up-a1.up)*Double(maxY-minY) < x*Double(a1.down-a1.up-a2.down+a2.up)
}

func sol(x: Double) -> Int {
    var lo = 0, hi = sz-1
    while lo < hi {
        let mid = (lo+hi)/2
        if compareX(p: mid, q: mid+1, x: x) {
            lo = mid+1
        }
        else {
            hi = mid
        }
    }
    return stack[hi].idx
}

let n = Int(readLine()!)!
var lineSet:[line] = []
for i in 1...n {
    let X = readLine()!.split(separator: " ").map{Int64(String($0))!}
    lineSet.append(line(up: X[0], down: X[1], idx: i))
}
lineSet.sort(by: {($0.down-$0.up) > ($1.down-$1.up)})
for i in lineSet {
    insert(v: i)
}
let m = Int(readLine()!)!
var str = ""
for _ in 0..<m {
    let tmp = Double(maxY) - Double(readLine()!)!
    str += "\(sol(x: tmp))\n"
}
print(str, terminator: "")

백준 12865 평범한 배낭

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/12865

이 문제 역시 DP Algorithm에서 설명한 내용이다. 입출력 부분이 추가된 전체 코드만 올리겠으니 자세한 풀이는 DP Algorithm을 참조하길 바란다.

전체 코드

let nk = readLine()!.split(separator: " ").map{Int($0)!}
let n = nk[0]
let k = nk[1]
var arr = Array(repeating: 0, count: k+1)
var WV:[(w:Int, v:Int)] = []
for _ in 1...n {
    let line = readLine()!.split(separator: " ").map{Int($0)!}
    WV.append((w:line[0], v:line[1]))
}
for wv in WV {
    let w = wv.w, v = wv.v
    if w > k {continue}
    var tmp = arr
    for i in w...k {
        if arr[i] < arr[i-w] + v {
            tmp[i] = arr[i-w] + v
        }
    }
    arr = tmp
}
print(arr[k])

백준 9251 LCS

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/9251

DP에서 설명한 LCS와 같은 문제이다. 설명은 Algorithm DP 파트를 참조바란다.

전체 코드

let a = readLine()!.map{Character(String($0))}
let b = readLine()!.map{Character(String($0))}
var board: [[Int]] = Array(repeating: Array(repeating: 0, count: b.count+1), count: a.count+1)
var result = 0
for i in 1...a.count {
    for j in 1...b.count {
        if b[j-1] == a[i-1] {
            board[i][j] = board[i-1][j-1] + 1
        }
        else {
            board[i][j] = max(board[i][j-1], board[i-1][j])
        }
    }
}
print(board[a.count][b.count])

백준 11054 가장 긴 바이토닉 부분 수열

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/11054

어떤 수열이 주어졌을 때 가장 긴 바이토닉 부분 수열을 찾는 문제이다. 바이토닉 부분 수열이란 앞에서부터 증가했다가 어떤 수를 기점으로 감소하는 형태를 보이는 부분 수열을 말한다.

DP Algorithm에서 다루었던 LIS의 응용버전이다. 간단하게 정상적인 LIS를 구한 뒤 주어진 수열을 reverse해서 거꾸로 계산한 LIS을 구해준 뒤 각 자리마다 더해준 후 최댓값을 찾아내면 된다.

func LIS(A: [Int]) -> [Int] {
    let n = A.count
    var dp = Array(repeating: -1, count: n)
    var lis = Array(repeating: -1, count: n)
    var count = 0
    for i in 0..<n {
        let idx = lowerBound(start: 0, end: count, key: A[i], arr: dp)
        dp[idx] = A[i]
        lis[i] = idx + 1
        if idx == count {
            count += 1
        }
    }
    return lis
}

성능을 위해 O(nlogn) 으로 구현했으며 각 수열의 자리마다 본인을 마지막으로 포함하는 LIS의 값을 구해야하기 때문에 lis 배열에 저장해둔 뒤 return 시켰다.

전체 코드

let n = Int(readLine()!)!
let A = readLine()!.split(separator: " ").map{Int($0)!}
var dp = LIS(A: A)
var backdp = LIS(A: A.reversed())
backdp.reverse()
for i in 0..<n {
    dp[i] += backdp[i]-1
}
print(dp.max()!)

func LIS(A: [Int]) -> [Int] {
    let n = A.count
    var dp = Array(repeating: -1, count: n)
    var lis = Array(repeating: -1, count: n)
    var count = 0
    for i in 0..<n {
        let idx = lowerBound(start: 0, end: count, key: A[i], arr: dp)
        dp[idx] = A[i]
        lis[i] = idx + 1
        if idx == count {
            count += 1
        }
    }
    return lis
}

func lowerBound(start: Int, end: Int, key: Int, arr: [Int]) -> Int {
    var s = start, e = end
    while s < e {
        let m = (s+e)/2
        if arr[m] >= key {
            e = m
        }
        else {
            s = m+1
        }
    }
    return e
}

백준 2156 포도주 시식

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2156

포도주가 순서대로 주어질 때 연속으로 놓여 있는 3잔을 모두 마실 수 없다고 했을 때 포도주를 가장 많이 먹는 방법을 구하는 문제이다. 점화식을 세워보면 다음과 같다.

dp[i][0] = max(dp[i-1][0], dp[i-1][1])  
dp[i][1] = max(dp[i-1][0], dp[i-2][0] + c[i-1]) + c[i]  

여기서 c는 포도주의 양을 순서대로 나열해놓은 배열이다. 현재 포도주를 마시지 않을 경우는 이전 포도주를 마신 것과 안마신 것중에서 최댓값이 올 것이고 현재 포도주를 마실 경우에는 3개를 연속해서 마실 수 없기 때문에 이전꺼를 안마실경우와 전전꺼를 안마시고 이전꺼를 마신경우 2가지 경우로 나눠서 최댓값을 찾아준다.

DP code

var dp = Array(repeating: Array(repeating: 0, count: 2), count: 2)
dp[0][1] = c[0]
dp[1][0] = c[0]
dp[1][1] = c[0]+c[1]
for i in 2..<n {
    let nDrink = max(dp[1][0], dp[1][1])
    let Drink = max(dp[1][0], dp[0][0] + c[i-1]) + c[i]
    dp[0] = dp[1]
    dp[1] = [nDrink, Drink]
}
print(max(dp[1][0], dp[1][1]))

이 때 앞에서와 마찬가지로 전전꺼까지의 결과만 있으면 되기 때문에 dp 배열을 2x2로 표현하여 불필요한 메모리 사용을 줄여주었다.

전체 코드

let n = Int(readLine()!)!
var c = Array(repeating: 0, count: n)
for i in 0..<n {
    c[i] = Int(readLine()!)!
}
if n == 1 {
    print(c[0])
}
else {
    var dp = Array(repeating: Array(repeating: 0, count: 2), count: 2)
    dp[0][1] = c[0]
    dp[1][0] = c[0]
    dp[1][1] = c[0]+c[1]
    for i in 2..<n {
        let nDrink = max(dp[1][0], dp[1][1])
        let Drink = max(dp[1][0], dp[0][0] + c[i-1]) + c[i]
        dp[0] = dp[1]
        dp[1] = [nDrink, Drink]
    }
    print(max(dp[1][0], dp[1][1]))
}

백준 1149 RGB거리

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1149

각 집마다 색깔을 칠하는 비용이 주어졌을 때 이웃하는 집과의 색과 다르게 색칠하면서 모든 집을 칠하는 비용의 최솟값을 출력하는 문제이다. 코딩 수업을 들은 사람이라면 어디선가 한번쯤은 봤을 문제이다.

var dp = cost[0]
for idx in 1..<n {
    let rcost = min(dp[1], dp[2]) + cost[idx][0]
    let gcost = min(dp[0], dp[2]) + cost[idx][1]
    let bcost = min(dp[0], dp[1]) + cost[idx][2]
    dp = [rcost, gcost, bcost]
}

간단하게 현재 집의 색깔을 R로 할경우 이전 집의 색깔을 G나 B로 했을때의 비용 중 최솟값에 R을 칠할 때의 비용을 더해주면 끝이다. 같은 방식으로 G, B도 업데이트 해주면서 처음부터 끝까지 dp를 업데이트 해주면 된다.

이 때 dp 배열을 [n][3]으로 선언할 필요 없이 바로 직전 값을 활용해서 현재값을 결정하기 때문에 1차원 배열로 선언해주어 메모리를 아끼는 것이 좋다.

전체 코드

let n = Int(readLine()!)!
var cost: [[Int]] = []
for _ in 1...n {
    cost.append(readLine()!.split(separator: " ").map{Int(String($0))!})
}

var dp = cost[0]
for idx in 1..<n {
    let rcost = min(dp[1], dp[2]) + cost[idx][0]
    let gcost = min(dp[0], dp[2]) + cost[idx][1]
    let bcost = min(dp[0], dp[1]) + cost[idx][2]
    dp = [rcost, gcost, bcost]
}
print(dp.min()!)

백준 2206 벽 부수고 이동하기

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2206

NxM으로 되어있는 맵이 있을 때 0은 이동가능한 곳, 1은 벽이 있는 곳이다. 이 때 벽을 한개까지 부수고 이동할 수 있다고 할 때 (1, 1)에서 (N, M)까지 최단경로를 찾아내는 문제이다. 불가능할 경우 -1을 출력한다.

앞에서 다룬 2178 미로탐색의 확장버전이다. 벽을 1개까지 부술 수 있다는 점이 특징이다. 따라서 벽을 부순 후인지 벽을 부수기 전인지를 같이 나타내서 해결해야 한다.

var board:[[(Int, Bool)]] = []
var queue:[(y:Int, x:Int, broken:Bool)] = [(0, 0, false)]

자 이제 우리는 board와 queue에 bool 변수를 함께 포함해서 나타낼 예정이다. 여기서 bool 변수는 현재 경로로 올 때 벽 부수기를 실행했는지 아닌지를 나타내는 변수이다. 그리고 board의 int값에는 -1, 0, 1, 2 네가지의 값이 올 것이다. 2는 정상적으로 길을 방문했을 경우, 1은 벽이 있는 경우, 0은 아직 방문한적 없는 길, -1은 벽을 부숴서 길이 된 경우를 나타낸다.

BFS code

let X = node.x + dx[i]
let Y = node.y + dy[i]
if X < 0 || Y < 0 || X == m || Y == n {continue}
let visited = board[Y][X].0
let brokenSpace = board[Y][X].1
if visited == 0 {
		board[Y][X] = (2, node.broken)
		queue.append((y: Y, x: X, broken: node.broken))
}
else if visited == 1 && !node.broken {
		board[Y][X] = (-1, true)
		queue.append((y: Y, x: X, broken: true))
}
else if visited == 2 && !node.broken && brokenSpace {
		board[Y][X] = (2, false)
		queue.append((y: Y, x: X, broken: false))
}

자 이제 bfs내부의 동작을 살펴보자. 현재지점에서 다음지점을 바라봤을 때 4가지의 경우가 있을 것이다.

1) 방문한적 없는 길 :  
  현재 지점의 bool 변수를 그대로 이용하고 board에 방문했다고 2라고 표시해준다.  
2) 벽일 경우 && 벽뚫기 가능 :  
  해당 벽을 부수고 bool 변수를 true로 바꾸어 저장해준다. 
  이 때 -1로 표시해주는 이유는 다음에 방문했을때 벽인줄 알고 부수고 이동할 필요가 없기 때문이다. 
  (이미 해당 벽을 부수고 이동하는 최단 경로는 -1을 표시할 때이다)
3) 방문한 적이 있는 길이지만 벽뚫기를 사용해서 방문했었던 경우 : 
  벽뚫기를 안쓰고 방문이 가능하다고 새롭게 표시해준다.
4) 그 외에는 이미 최단경로로 방문을 했었기 때문에 아무것도 하지 않고 넘어간다.  

3번 경우에 대해 자세히 설명하겠다. 이 부분이 중요하다. 만약 벽뚫기를 해서 방문을 하면 다음 경로가 (3,5) 지점에 방문하는 최단 경로일 것이다.

하지만 이렇게 방문을 하면 벽뚫기를 이미 사용해서 최종 목적지로 이동이 불가능하다.

위의 경로로 방문을 할 경우 벽을 뚫고 최종 목적지로 이동이 가능하다. 따라서 우리는 벽뚫기를 해서 먼저 방문한 지점의 경우 board에 벽뚫기를 하지 않고 방문이 가능하다고 나타내주고 다시 queue에 추가해 bfs를 계속한다.

전체 코드

let nm = readLine()!.split(separator: " ").map{Int($0)!}
let n = nm[0]
let m = nm[1]
var board:[[(Int, Bool)]] = []
for _ in 1...n {
    board.append(readLine()!.map{(Int(String($0))!, false)})
}
var queue:[(y:Int, x:Int, broken:Bool)] = [(0, 0, false)]
board[0][0] = (2, false)

let dx = [1, -1, 0, 0]
let dy = [0, 0, 1, -1]
var dist = 0
var index = 0
var success = false
loop: while index < queue.count {
    dist += 1
    for i in index..<queue.count {
        let node = queue[i]
        if node.x == m-1 && node.y == n-1 {
            success = true
            break loop
        }
        for i in 0...3 {
            let X = node.x + dx[i]
            let Y = node.y + dy[i]
            if X < 0 || Y < 0 || X == m || Y == n {continue}
            let visited = board[Y][X].0
            let brokenSpace = board[Y][X].1
            if visited == 0 {
                board[Y][X] = (2, node.broken)
                queue.append((y: Y, x: X, broken: node.broken))
            }
            else if visited == 1 && !node.broken {
                board[Y][X] = (-1, true)
                queue.append((y: Y, x: X, broken: true))
            }
            else if visited == 2 && !node.broken && brokenSpace {
                board[Y][X] = (2, false)
                queue.append((y: Y, x: X, broken: false))
            }
        }
        index += 1
    }
}
print(success ? dist : -1)

백준 1697 숨바꼭질

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1697

수빈이의 위치 n과 동생의 위치 k가 주어질 때 수빈이가 동생을 찾는 가장 빠른 시간을 구하는 문제이다. 수빈이의 위치가 x일 때 1초 후 수빈이는 x-1 혹은 x+1 혹은 2x로 이동이 가능하다.

가장 빠른 시간이라는 점에서 먼저 떠올라야하는 것은 바로 bfs이다. queue에 현재 위치를 기준으로 x-1, x+1, 2x 중 방문한 적이 없는 값을 집어넣고 bfs를 계속 돌리다가 위치가 k가 되면 그 때의 시간을 출력해주면 되는 간단한 문제이다.

BFS code

var time = -1
var index = 0
loop: while true {
    time += 1
    let k = index
    for i in k..<queue.count {
        let node = queue[i]
        if node == end {
            break loop
        }
        else {
            let a = 2*node
            let b = node-1
            let c = node+1
            if a <= 100000 && !visited[a] {
                visited[a] = true
                queue.append(a)
            }
            if b >= 0 && !visited[b]{
                visited[b] = true
                queue.append(b)
            }
            if c <= 100000 && !visited[c]{
                visited[c] = true
                queue.append(c)
            }
            index += 1
        }
    }
}

이 때 queue.removeFirst를 매번 해주는 것이 swift에서는 O(1)에 불가능하기 때문에 index 를 1씩 증가시켜 queue에 접근하는 방식으로 구현하였다. 메모리적으로는 더 많이 들지만 시간적으로 굉장히 절약이 되기 때문에 이 방식을 사용했다. 이 때 범위가 0-100000 이기에 해당 범위를 넘어서지 않을때만 동작하도록 하였다.

전체 코드

let nm = readLine()!.split(separator: " ").map{Int($0)!}
let start = nm[0]
let end = nm[1]
var queue:[Int] = []
var visited = Array(repeating: false, count: 100001)
queue.append(start)
visited[start] = true

var time = -1
var index = 0
loop: while true {
    time += 1
    let k = index
    for i in k..<queue.count {
        let node = queue[i]
        if node == end {
            break loop
        }
        else {
            let a = 2*node
            let b = node-1
            let c = node+1
            if a <= 100000 && !visited[a] {
                visited[a] = true
                queue.append(a)
            }
            if b >= 0 && !visited[b]{
                visited[b] = true
                queue.append(b)
            }
            if c <= 100000 && !visited[c]{
                visited[c] = true
                queue.append(c)
            }
            index += 1
        }
    }
}
print(time)

백준 2178 미로 탐색

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2178

NxM의 배열이 주어진다. 1은 이동할 수 있는 칸, 0은 이동할 수 없는 칸을 나타낼 때 (1, 1) 위치에서 (NxM) 위치로 이동하는 최단 거리를 구하는 문제이다. 이 문제는 BFS를 활용해서 푸는 문제이다. BFS의 특징은 시작지점으로부터 같은 거리만큼 떨어진 곳을 모두 방문한 후에 다음 거리를 방문한다는 점이다. 즉 최단거리 찾는 문제에 종종 사용된다.

BFS function

func BFS() {
    var queue:[(y:Int, x:Int)] = [(0, 0)]
    let dx = [1, -1, 0, 0]
    let dy = [0, 0, 1, -1]
    
    while !queue.isEmpty {
        let node = queue.removeFirst()
        for i in 0...3 {
            let nextX = node.x + dx[i]
            let nextY = node.y + dy[i]
            if nextX < 0 || nextY < 0 || nextX == m || nextY == n {continue}
            else if board[nextY][nextX] == 1 {
                board[nextY][nextX] = board[node.y][node.x] + 1
                queue.append((y:nextY, x:nextX))
            }
        }
    }
}

2667문제의 DFS와 마찬가지로 상하좌우만 확인해주면 되기 때문에 edge가 따로 구현되어있지 않다. 따라서 nextX&nextY를 통해 네 지점을 확인해 줄 것이다. 여기서는 check함수가 없이 구현이 되어있는데 기존 미로의 구성을 저장한 board 배열이 check함수의 역할까지 함께 하고 있다.

현재 지점으로부터 길이 있다면 현재지점 최단거리+1 이 다음 지점까지의 최단거리가 될 것이고 이미 방문한 적이 있다면 board 배열 값이 1이 아닐 것이기 때문에 check배열 없이 구현이 가능하다. 최종적으로는 board[n-1][m-1] 에 저장된 값이 최단 경로이다.

전체 코드

let nm = readLine()!.split(separator: " ").map{Int($0)!}
let n = nm[0], m = nm[1]
var board:[[Int]] = []
for _ in 1...n {
    board.append(readLine()!.map{Int(String($0))!})
}
BFS()
print(board[n-1][m-1])

func BFS() {
    var queue:[(y:Int, x:Int)] = [(0, 0)]
    let dx = [1, -1, 0, 0]
    let dy = [0, 0, 1, -1]
    
    while !queue.isEmpty {
        let node = queue.removeFirst()
        for i in 0...3 {
            let nextX = node.x + dx[i]
            let nextY = node.y + dy[i]
            if nextX < 0 || nextY < 0 || nextX == m || nextY == n {continue}
            else if board[nextY][nextX] == 1 {
                board[nextY][nextX] = board[node.y][node.x] + 1
                queue.append((y:nextY, x:nextX))
            }
        }
    }
}

백준 2667 단지번호붙이기

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2667

NxN의 행렬이 주어졌을 때 1은 집이 있는 곳을 0은 집이 없는 곳을 의미한다. 붙어있는 집들간에는 같은 단지 번호를 매긴다고 했을 때 각 단지별 집의 수를 오름차순으로 출력하는 문제이다.

전형적인 DFS, BFS 연습문제로 어느 것을 사용하든 상관이 없다. 나는 DFS로 문제를 구현하였다.

DFS function

func DFS(result: inout Int, x: Int, y: Int) {
    let dx = [0, 0, -1, 1]
    let dy = [-1, 1, 0, 0]
    for i in 0...3 {
        let calcX = x+dx[i]
        let calcY = y+dy[i]
        if calcX < 0 || calcX == n || calcY < 0 || calcY == n || isVisited[calcX][calcY] {continue}
        else {
            result += 1
            isVisited[calcX][calcY] = true
            DFS(result: &result, x: calcX, y: calcY)
        }
    }
}

자 앞에서 배운 dfs코드와는 조금 다른 형태임을 알 수 있다. 그래프의 경우 node간의 edge들이 모두 구현된 상태에서 진행했었지만 2차원 array를 이용한 문제이기때문에 본인 기준 상하좌우만 확인하면 되서 따로 edge들이 구현되어있지않다. 따라서 calcX와 calcY라는 변수를 이용해서 상하좌우를 확인할 것이다.

isVisited라는 방문여부를 확인해주는 배열이 있다. 이 때 집이 없는 곳들의 isVisited 값을 true로 해주어 해당 단지와 연결되어 있지 않으면 방문하지 않도록 구현해주었다.

main 코드

var town:[Int] = []
for i in 0..<n {
    for j in 0..<n {
        if isVisited[i][j] {continue}
        else {
            var result = 1
            isVisited[i][j] = true
            DFS(result: &result, x: i, y: j)
            town.append(result)
        }
    }
}

이제 모든 위치에 대해서 탐색을 해줄 것이다. 만약 본인이 포함된 단지가 한번이라도 DFS가 실행되었다면 isVisited 값이 true로 나와 같은 단지를 두번 탐색하지 않는다. 단지별 아파트 수는 town이라는 변수에 매번 저장을 해주어 최종적으로 결과를 뽑아낼 것이다.

전체 코드

let n = Int(readLine()!)!
var isVisited = Array(repeating: Array(repeating: false, count: n), count: n)
var town:[Int] = []
for i in 0..<n {
    var j = 0
    for c in readLine()! {
        if c == "0" {
            isVisited[i][j] = true
        }
        j += 1
    }
}

for i in 0..<n {
    for j in 0..<n {
        if isVisited[i][j] {continue}
        else {
            var result = 1
            isVisited[i][j] = true
            DFS(result: &result, x: i, y: j)
            town.append(result)
        }
    }
}
var str = "\(town.count)\n"
for i in town.sorted() {
    str += "\(i)\n"
}
print(str)

func DFS(result: inout Int, x: Int, y: Int) {
    let dx = [0, 0, -1, 1]
    let dy = [-1, 1, 0, 0]
    for i in 0...3 {
        let calcX = x+dx[i]
        let calcY = y+dy[i]
        if calcX < 0 || calcX == n || calcY < 0 || calcY == n || isVisited[calcX][calcY] {continue}
        else {
            result += 1
            isVisited[calcX][calcY] = true
            DFS(result: &result, x: calcX, y: calcY)
        }
    }
}

백준 1300 K번째 수

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1300

NxN의 행렬 A가 있을 때 A의 각 원소는 ixj로 표현된다고 하자. 이 때 A의 원소들을 오름차순으로 B에 저장했을 때 B[k]의 값을 구하는 문제이다. 이 때 인덱스는 1부터 시작한다고 한다.

다음은 n=4 일때를 예시로 A를 그려보았다.

A행렬 (n = 4)

| 1 | 2 | 3 | 4 | | :–: | :–: | :–: | :–: | | 2 | 4 | 6 | 8 | | 3 | 6 | 9 | 12 | | 4 | 8 | 12 | 16 |

var end = k+1
var start = 1

한가지 포인트는 우리가 k라는 index를 찾고자하면 B[k]의 저장된 값은 k보다 항상 작거나 같다는 것이다. 따라서 B[k]에 저장된 값을 우리는 이분탐색으로 찾을 것인데 초기 end값을 k+1로 주고 시작한다.

while start < end {
    let mid = (start+end)/2
    var count = 0
    for i in 1...n {
        let tmp = min(mid/i, n)
        if tmp == 0 {break} 
        //만약 0이 나왔다면 그 이후에 대해서도 0일것이므로 break
        count += tmp
    }
    if count < k {
        start = mid+1
    }
    else {
        end = mid
    }
}

위의 A행렬을 가로로 한줄씩 살펴보도록하자. 우리가 8이라는 수를 골랐다고하자. 그렇다면 2번째 줄의 8보다 작거나 같은 수의 갯수는 8/2 = 4 가 될 것이다. 그렇다면 3번째줄의 경우는? 8/3 = 2 로 총 2개가 나타나게 된다. 즉 임의의 i번째 row의 k보다 작거나 같은 숫자의 갯수는 min(k/i, n)이 된다.

따라서 B[k]에 저장된 값을 이분탐색으로 찾을 때 mid보다 작거나 같은 원소의 갯수를 count라는 변수에 저장해준다. 해당 갯수가 k보다 작다면 B[k]의 값을 증가시켜야 하므로 우측 영역을 탐색하도록 하고 k보다 크거나 같다면 좌측 영역을 탐색하도록 하였다.

전체 코드

let n = Int(readLine()!)!
let k = Int(readLine()!)!
var end = k+1
var start = 1
while start < end {
    let mid = (start+end)/2
    var count = 0
    for i in 1...n {
        let tmp = min(mid/i, n)
        if tmp == 0 {break}
        count += tmp
    }
    if count < k {
        start = mid+1
    }
    else {
        end = mid
    }
}
print(end)

백준 2110 공유기 설치

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/2110

n개의 집에 대한 좌표가 주어졌을 때 총 c개의 공유기를 집들 중 선택해서 설치하려고한다. 이 때 공유기간의 거리 중 최솟값이 최대가 되도록 할때 그 길이를 구하는 문제이다.

앞에서 다루었던 랜선자르기와 느낌이 비슷하다. 핵심 포인트는 공유기간의 거리의 최솟값을 이분탐색 조건으로 놓고 진행한다는 것이다.

input.sort()
for i in 0..<n-1 {
    length.append(input[i+1] - input[i])
}

먼저 input에는 집들의 좌표가 들어있고 length에는 이웃한 집들간의 거리를 저장한다고 해보자. 따라서 input을 sort한 후 이웃한 input간의 차를 length에 저장해주었다.

var end = length.reduce(0, +) + 1
var start = length.min()!
while start < end {
    let mid = (start+end)/2
    var result = 0, count = 0
    for num in length {
        count += num
        if count >= mid {
            result += 1
            count = 0
        }
    }
    if result >= m-1 {
        start = mid+1
    }
    else {
        end = mid
    }
}

위의 코드가 이분탐색을 해주는 부분이다. 여기서 주목할 것은 count라는 변수이다. count는 length를 앞에서부터 하나씩 더해가는데 이는 두 공유기 간의 거리를 의미하게 된다. 만약 공유기간의 거리가 우리가 설정한 mid라는 기준을 넘게되면 공유기를 설치할 수 있으므로 설치해주고 count값을 다시 0으로 만들어서 새로운 공유기와의 거리를 측정해준다.

이렇게 설치한 공유기의 갯수 result가 m-1개보다 크거나 같으면 우측영역 탐색을, 작으면 좌측영역 탐색을 진행한다. 이 때 m-1개가 기준인 이유는 가장 왼쪽에 있는 집에는 무조건 설치하기 때문에 1을 빼줘야한다.

전체 코드

let nm = readLine()!.split(separator: " ").map{Int($0)!}
let n = nm[0], m = nm[1]
var input = [Int]()
var length = [Int]()
for _ in 1...n {
    input.append(Int(readLine()!)!)
}
input.sort()
for i in 0..<n-1 {
    length.append(input[i+1] - input[i])
}
var end = length.reduce(0, +) + 1
var start = length.min()!
while start < end {
    let mid = (start+end)/2
    var result = 0, count = 0
    for num in length {
        count += num
        if count >= mid {
            result += 1
            count = 0
        }
    }
    if result >= m-1 {
        start = mid+1
    }
    else {
        end = mid
    }
}
print(end-1)

백준 1654 랜선 자르기

2021-06-23T00:00:00+00:00

https://www.acmicpc.net/problem/1654

총 k개의 랜선이 주어지고 주어진 랜선들을 잘라서 같은 길이의 n개의 랜선을 만들때 만들 수 있는 가장 긴 랜선의 길이를 찾는 문제이다. 포인트는 랜선들을 자를 길이를 기준으로 이분탐색을 진행해서 잘라낸 랜선 개수가 n개를 만족할 수 있는지를 확인하는 것이다.

var end = input.max()! + 1
var start = 1
while start < end {
    let mid = (start+end)/2
    var result = 0
    for num in input {
        result += num/mid
    }
    if result >= n {
        start = mid+1
    }
    else {
        end = mid
    }
}

위의 코드는 이분탐색을 해주는 코드이다. input에 k개의 랜선들의 길이를 넣어놓고 매 iteration마다 mid의 길이로 몇개씩 잘라낼 수 있는지 찾아내서 n개 보다 크거나 같을 경우 mid보다 큰 길이에 대해 확인해주고 n개보다 작을 경우 mid보다 작은 길이에 대해 확인해주도록 구현했다.

전체 코드

let kn = readLine()!.split(separator: " ").map{Int($0)!}
let k = kn[0]
let n = kn[1]
var input = [Int]()
for _ in 1...k {
    input.append(Int(readLine()!)!)
}
var end = input.max()! + 1
var start = 1
while start < end {
    let mid = (start+end)/2
    var result = 0
    for num in input {
        result += num/mid
    }
    if result >= n {
        start = mid+1
    }
    else {
        end = mid
    }
}
print(end-1)

어려운 수학 정리

2021-06-22T00:00:00+00:00

1. 뤼카의 정리 (Lucas’ Theorem)

음이 아닌 정수 n, k와 작은 소수 p가 주어졌을 때 n과 k를 p진수로 나타낸다고 하자.

이 때 다음과 같은 식이 성립한다.

해당 식의 증명은 다른 분들에게 맡기고… 놀랍게도 기존의 이항계수를 구하는 알고리즘은 dp를 활용해 구하는 것이 대부분이었다. 하지만 n이 커질수록 필요로하는 array의 크기도 커지고 걸리는 시간 역시 점점 늘어났다.

어차피 이항계수는 특정 범위를 넘어서면 자료형에 담을 수 없어 임의의 숫자로 나누어 준 나머지를 종종 구했다. 이 때 뤼카의 정리를 활용하면 _nC_k mod p 를 굉장히 빠른 시간내에 구할 수 있게 된다. 유의할 것은 n_i 보다 k_i가 크다면 그 때의 comb값은 0이 되도록 해야한다는 것이다.

Lucas Algorithm

var n:Int64 = 1000000, k:Int64 = 10000, m:Int64 = 13
var comb:[[Int]] = Array(repeating: Array(repeating: 0, count: 2001), count: 2001)
comb[0][0] = 1
for i in 1...Int(m) {
    comb[i][0] = 1
    for j in 1...i {
        comb[i][j] = (comb[i-1][j-1] + comb[i-1][j])%Int(m)
    }
}

var result = 1
while n != 0 && k != 0 {
    result *= comb[Int(n%m)][Int(k%m)]
    result %= Int(m)
    n /= m
    k /= m
}

2. 확장 유클리드 알고리즘

두 수 A, B가 주어졌을 때 두 수는 다음과 같은 부정방정식의 해를 갖는다.

AX+BY = gcd(A, B)

이 때 해가 되는 X, Y를 구하는 알고리즘을 확장 유클리드 알고리즘이라 부른다. 확장 유클리드 알고리즘은 유클리드 알고리즘을 활용해 gcd를 구한것을 응용해서 해를 구한다.

유클리드 알고리즘에서 A = BQ + R 형태로 gcd를 구할 수 있던 것을 생각하자. 이 때 r1 = A, r2 = B로 초깃값을 주고 다시 식을 일반화하면 다음과 같이 변한다.

식 : r1 = r2Q + r -> r = r1 - r2Q
r1 = r2, r2 = r를 주고 반복

이를 반복해서 새롭게 구한 r이 0이 되었을 때 그 때의 r2의 값이 gcd가 되었었다.

이제부터 r을 r = sA + tB의 형태로 나타낼 것이다. 즉 r을 초기값인 A와 B의 방정식 형태로 나타내겠다는 의미이다. 유클리드를 통해 구하게 되는 gcd도 gcd(A, B) = sA + tB의 형태로 나타날 것이고 그 때의 s, t가 부정방정식의 해가 될 것이다. 그렇다면 s와 t를 어떻게 나타내면 좋을까?

r1 = s1A + t1B
r2 = s2A + t2B

초기에는 r1 = A, r2 = B이기 때문에 s1 = 1, s2 = 0, t1 = 0, t2 = 1로 초깃값을 준다. 그렇다면 r은 다음과 같이 변형할 수 있다.

r = r1 - r2Q = (s1A + t1B) - (s2A + t2B)Q
r = (s1 - s2Q)A + (t1 - t2Q)B = sA + tB

놀랍게도 r의 s와 t는 r과 동일한 형태로 나타나게 된다.

r = r1 - r2Q
s = s1 - s2Q
t = t1 - t2Q

이제 r1 = r2, r2 = r로 값을 바꿀 때 동일하게 s1 = s2, s2 = s, t1 = t2, t2 = t로 값을 바꿔준다. 최종적으로 gcd의 s와 t를 구해주면 문제를 해결할 수 있다.

Euclidean Algorithm

func Euclidean(a: Int, b: Int) -> (Int, Int, Int) {
    var r1 = a, r2 = b, s1 = 1, s2 = 0, t1 = 0, t2 = 1
    while r2 != 0 {
        let q = r1/r2
        let r = r1-q*r2, s = s1-q*s2, t = t1-q*t2
        r1 = r2
        s1 = s2
        t1 = t2
        r2 = r
        s2 = s
        t2 = t
    }
    return (r1, s1, t1)
}

3. 중국인의 나머지 정리

다음과 같은 문제를 어디선가 본 적이 있을 것이다.

3으로 나누었을 때 2가 남고, 5로 나누었을 때 3이 남고, 7로 나누었을 때 2가 남는 수는 무엇인가?

이와 같은 연립방정식 문제를 쉽게 풀 수 있도록 도와주는 정리를 중국인의 나머지 정리라 부른다. 중국인의 나머지 정리는 다음과 같다.

m₁, m₂ … m_n이 쌍마다 서로소이면 (gcd(m_i, m_j) = 1), 다음 연립 합동식
x ≡ a₁ (mod m₁)
x ≡ a₂ (mod m₂)
x ≡ a₃ (mod m₃)
⋅
⋅
⋅
x ≡ a_n(mod m_n)
을 만족하는 유일한 해 x가 존재한다.

x가 유일하다는 점을 주목하자. 실제로 x를 구하는 방법은 다음과 같다.

모든 m_i들의 곱을 m이라 정의하자. (m = m₁m₂…m_n)
그 때 n_k = m/m_k 라고 했을 때 gcd(n_k, m_k) = 1이 된다.
이 때 유클리드 확장 알고리즘을 사용하면 s_kn_k + t_km_k = 1을 만족하는 s_k, t_k를 찾을 수 있다.
여기서 s_kn_k ≡ 1 (mod m_k)가 성립하게 된다.
최종적으로 x = a₁n₁s₁ + a₂n₂s₂ … a_nn_ns_n 이라고 하자.
그러면 m_k로 나누게 되면 k번째 항을 제외하고는 모두 나누어떨어져서
x ≡ a_kn_ks_k ≡ a_k⋅1 ≡ a_k (mod m_k) 를 만족하게 된다.
이 때 해 x는 m보다 작아야 하므로 x = a₁n₁s₁ + a₂n₂s₂ … a_nn_ns_n (mod m)이 구하고자 하는 해가 된다.

중국인의 나머지 정리 Algorithm

func Euclidean(a: Int, b: Int) -> Int {
    var r1 = a, r2 = b, s1 = 1, t1 = 0, s2 = 0, t2 = 1
    while r2 != 0 {
        let q = r1/r2
        let r = r1-q*r2, s = s1-q*s2, t = t1-q*t2
        r1 = r2
        s1 = s2
        t1 = t2
        r2 = r
        s2 = s
        t2 = t
    }
    return s1
}

func Chinese(a: [Int], m: [Int]) -> Int {
    let mult_m = m.reduce(1, *)
    var x = 0
    for i in 0..<a.count {
        let n = mult_m/m[i]
        let s = (Euclidean(a: n, b: m[i]) + m[i])%m[i]
        x += n*s*a[i]
    }
    return x%mult_m
}

4. 밀러-라빈 소수판별법 (Miller-Rabin primality test)

밀러-라빈 소수 판별법은 N이 소수인지 아닌지를 확률적으로 알아내는 판별법이다. 밀러-라빈 소수 판별법을 알아보기 전에 2가지 보조정리를 알고 가야한다.

보조정리 1 : 페르마의 소정리

소수 p와 임의의 정수 a에 대해서 다음을 만족한다.
a^p ≡ a (mod p)

양변을 a로 나누어주면
a^p-1 ≡ 1 (mod p) when a%p ≠ 0

보조정리 2

소수 p에 대해서 x² ≡ 1 (mod p) 이면,
x ≡ -1 (mod p) 혹은 x ≡ 1 (mod p) 를 만족한다.

자 이제 밀러 라빈 소수판별법에 대해서 알아보자. 임의의 2가 아닌 소수 N에 대해서 N-1은 항상 짝수일 것이다.

N-1 = d*2^r

그러면 임의의 정수 a와 소수 N에 대해서 다음을 만족한다.

a^N-1 = a^{dx2^r} ≡ 1 (mod N) by 보조정리 1
a^{dx2^r-1} ≡ -1 (mod N) or a^{dx2^r-1} ≡ 1 (mod N) by 보조정리 2

만약 보조정리 2를 적용한 결과가 -1 이 될 경우는 상관 없지만 1이 될 경우 반복적으로 보조정리 2를 적용할 수 있다. 따라서 최종적으로 N이 소수라면 다음의 2가지 조건 중 하나를 만족해야 한다.

a^d ≡ 1 (mod N)

a^{dx2^r} ≡ -1 (mod N) for some r

밀러라빈은 확률적으로 소수 여부를 확인해주는 알고리즘이라고 앞에서 얘기했었다. 실제로 N이 소수가 아니더라도 특정한 a에 대해서 이 조건을 만족시킬 수 있다. 따라서 우리는 최대한 많은 a에 대해서 알고리즘을 적용해 소수인지를 확인해주어야한다.

일반적으로 int 범위에 대해서는 a = [2, 7, 61] 세 소수에 대해서만 확인해주면 소수 여부를 정확히 판별할 수 있다. LongLong 범위에 대해서는 41이하의 소수에 대해 모두 확인해주면 소수 여부를 판별할 수 있다고 알려져 있다.

Miller-Rabin Algorithm

let alist:[UInt64] = [2, 7, 61]
func powmod(x: UInt64, y: UInt64, m:UInt64) -> UInt64 {
    var X = x%m
    var iter = y
    var result:UInt64 = 1
    while iter != 0 {
        if iter%2 == 1 {
            result = (result*X)%m
        }
        X = (X*X)%m
        iter /= 2
    }
    return result
    //x^y (mod m)을 구해주는 함수
}

func miller(n: UInt64, a: UInt64) -> Bool {
    var d = n-1
    while d%2 == 0 {
        if powmod(x: a, y: d, m: n) == n-1 {
        // a^d (mod n)이 -1이 나오는 것은 n-1이 되는 것과 같다.
            return true
        }
        d /= 2
    }
    let tmp = powmod(x: a, y: d, m: n)
    return tmp == n-1 || tmp == 1
    //최종적으로 홀수 지수가 남았을 때 1 혹은 -1이 되는지 모두 확인해준다.
}

func isPrime(n: UInt64) -> Bool {
    if n <= 1 {
        return false
    }
    for a in alist {
        if !miller(n: n, a: a) {
            return false
            //하나라도 소수 조건을 만족하지 못하면 소수가 아니다
        }
    }
    return true
    //모든 a에 대해 소수 조건을 만족하면 소수라고 판정한다.
}

5. 폴라드 로 알고리즘 (Pollard’s rho Algorithm)

인수 분해 알고리즘으로 어떤 수 n의 인수를 한가지 찾을 때 사용하는 알고리즘이다. 유의할 점으로는 소인수 분해가 아니라 인수를 찾아주는 것이기 때문에 소인수 분해를 하고 싶다면 반복적으로 사용해야한다.

먼저 f(x) = x² + c (mod n) 형태의 함수를 생각해보자. 그러면 초기값 x₀에 대해 다음과 같이 수열을 정의하자.

x_i = x₀, f(x₀), f(f(x₀)) …

n = 24751043, x₀ = 2, c = 1이라면 수열은 다음과 같다.

x_i = 2, 5, 26, 677, 458330 …

이 때 각 항을 p|n인 p로 나눈 나머지를 구한다. 24751043 = 317 x 78079이기 때문에 p = 317로 수열을 나눈 나머지를 순서대로 써보자.

x_i mod p = 2, 5, 26, 43, 265, 169, 32, 74, 88, 137, 67, 52, 169 …

위의 형태로 나타나게 되고 놀랍게도 이후로 [169, 32, 74, 88, 137, 67, 52]가 무한히 반복된다. 여담으로 이 형태가 마치 rho의 형태와 비슷하다고 하여 pollard’s rho라는 이름이 붙게 된 알고리즘이다.

자 이제 수열상의 i < j인 두 index를 골랐을 때 다음을 만족한다고 하자.

x_i ≡ x_j (mod p)

이는 달리 얘기하면 p|(x_i - x_j) 라는 의미가 된다. 이 때 p는 n의 인수라고 가정했기 때문에 p|n이 성립하고 최종적으로 p|gcd(x_i - x_j, n)이 성립한다. 따라서 이를 활용하여 p값을 먼저 정하고 진행하는 것이 아니라 gcd(x_i - x_j, n) 값을 구하고 그 값이 1이 아닐경우 n의 인수 p라고 판별할 수 있다.

그렇다면 x_i, x_j를 선택하는 기준을 어떻게 잡아야할까? 일반적으로 알려진 방법은 x_i = f(x_i), x_j = f(f(x_j)) 로 값을 변경해가면서 gcd(x_i - x_j, n) 값이 1이 아닌 지점이 나올때까지 반복하는 형태로 사용한다. 왜 x_i는 f를 한번 적용시키는데 x_j는 f를 두번 적용시키는지에 대해 의문이 들 수 있다. 만약 두 수에 대해 f를 모두 한번씩 적용시키게 되면 다음과 같다.

f(x_i) = x_i² + c (mod n)
f(x_j) = x_j² + c (mod n)

이 때 x_i ≡ x_j (mod p) 이라면 f(x_i) ≡ f(x_j) (mod p) 가 성립하게 된다. 만약 gcd(x_i - x_j, n) = 1이 되었을 경우 x_i, x_j 모두 f를 한번씩만 적용하게 되면 gcd값이 계속 1이 나타나게 될 것이다. 이를 방지하기 위해 x_i, x_j의 f 적용 횟수에 차이를 두고 알고리즘을 구현한다.

Pollard’s rho Algorithm

func phr(n: UInt64) -> UInt64 {
    if isPrime(n: n) {
    //miller-rabim 알고리즘으로 소수 판정을 빨리 함
        return n
    }
    if n == 1 {
        return 1
    }
    if n%2 == 0 {
        return 2
    }
    var x:UInt64 = 2, y:UInt64 = 2, g:UInt64 = 1
    //x0 = 2로 주고 시작했다. 임의의 숫자로 변경가능
    let c:[UInt64] = [1, 2, 3]
    //c에 대해서는 1, 2, 3에 대해 시도하도록 구현
    for i in  0...2 {
        x = 2
        y = 2
        g = 1
        while g == 1 {
            x = (mulmod(x: x, y: x, m: n) + c[i])%n
            //x = x*x + c (mod n)을 수행
            y = (mulmod(x: y, y: y, m: n) + c[i])%n
            y = (mulmod(x: y, y: y, m: n) + c[i])%n
            //y는 f를 두번 적용시킨다.
            let tmp = x > y ? x-y : y-x
            g = gcd(a: tmp, b: n)
        }
        if g != n {
            break
        }
    }
    return g
}

그런데 코드를 보면 알겠지만 시작부터 밀러 라빈 알고리즘으로 소수 판정을 해주는 것을 확인할 수 있다. n이 합성수가 아닌 소수라면 pollard-rho는 매우 느린 속도로 동작을 하게되기 때문에 소수일 경우 해당 값을 반환하도록 구현을 해놨다.

또한 x₀와 c에 대해 여러 값을 시도해보도록 구현이 되어있다. x₀와 c값에 따라 인수 분해가 불가능한 숫자들이 몇가지 있다. 이를 방지하고자 여러개의 초기값에 대해서 pollard rho 알고리즘을 적용시켜 인수를 찾아주도록 구현한 것이다.

기하학

2021-06-22T00:00:00+00:00

1. CCW(Counter Clock Wise)

수학에서 외적의 개념을 적용한 알고리즘을 CCW 알고리즘이라고 종종 부른다. 벡터의 외적은 두 벡터 u = (x1, y1, z1), v = (x2, y2, z2)가 주어진다면 다음과 같이 정의된다.

u x v = (y1z2 - z1y2, z1x2 - x1z2, x1y2 - y1x2)

외적을 함수로 구현하면 다음과 같다. 여기서는 벡터를 받은 것이 아니라 임의의 세 점 P (x1, y1, z1), Q (x2, y2, z2), R (x3, y3, z3)을 입력으로 받는다.

func ccw(x1: Int, x2: Int, x3: Int, y1: Int, y2: Int, y3: Int, z1: Int, z2: Int, z3:Int) -> (Int, Int, Int){
    let A = (x:x2-x1, y:y2-y1, z:z2-z1)
    let B = (x:x3-x1, y:y3-y1, z:z3-z1)
    let AxB = (A.y*B.z - A.z*B.y, A.z*B.x - A.x*B.z, A.x*B.y - A.y*B.x)
    return AxB
}

놀랍게도 외적을 2차원상에서 정의하면 외적은 z값은 모두 0이되고 AxB의 3번째 항만이 의미를 갖는다. 2차원 상에서 세점이 주어졌을 때 외적은 다음과 같은 2가지 경우로 구분된다.

첫번째 케이스의 경우 외적의 결과값이 양이 나오고 두번째 케이스의 경우 외적의 결과값이 음이 나오게 된다. 따라서 외적의 부호에 따라서 세 점의 위치관계를 알 수 있다. 만약 외적값이 양수라면 P, Q, R을 순서대로 이은 선분이 반시계 방향이고 음수라면 시계 방향이 되고 0 이라면 일직선을 이룬다.

2. 컨벡스 헐

2차원 평면에 많은 점들이 주어졌을 때 해당 점들을 모두 포함하는 다각형을 그리려한다 생각해보자. 그 중 다각형의 모든 내각이 180도 이하인 것을 볼록 다각형이라 부른다.

그러면 몇 개의 점을 골라 볼록 다각형을 만들었을 때 나머지 모든 점들이 다각형 내부에 포함되도록 만들 수 있다. 이를 컨벡스 헐 알고리즘이라 부른다. 볼록다각형은 다음의 특징을 갖는다.

1. 모든 내각이 180도 미만이기에 볼록다각형의 선분들을 반시계 방향으로 살펴볼 때 연속된 두 선분은 ccw 값이 항상 양수이다.
2. 가장 좌측 하단의 점을 기준으로 나머지 점들을 이은 선분들은 기울기가 점차 증가하는 형태이다.

이를 활용해서 컨벡스 헐을 만들기 위해 먼저 모든 점들중에서 가장 좌측 하단에 위치한 점을 선택한다.

그 점을 기준으로 나머지 점들을 기울기 순으로 정렬한다.

이제 기울기가 작은 점부터 하나씩 살펴볼 것이다. stack에 점들을 하나씩 넣어둘것인데 만약 stack에 점이 2개 미만이라면 점을 무조건 추가해준다.

만약 stack에 점이 2개 이상 들어있다면 stack의 top과 stack의 두번째 top, 새로운 점에 대해서 ccw를 해준다. 볼록다각형의 조건을 만족한다면 해당 각은 180도 미만으로 외적의 값이 양수가 나타날 것이다.

따라서 세번째 점을 추가하고 다음 순서의 점에 대해서 과정을 반복해준다. 순서대로 반복한다면 다섯번째 점까지 stack에 추가할 수 있게 된다.

여섯번째 점과 stack top의 두 점에 대해서 ccw를 하였더니 이번에는 음수가 나타났다. 실제로도 내각이 180도 이상인 형태로 점이 등장했다. 컨벡스 헐은 내각이 180도 이하여야하기 때문에 뭔가 조치가 필요하다는 것을 알 수 있다. 만약 ccw값이 음수가 나온다면 stack의 top을 pop해준다.

다시한번 스택의 top의 두 점과 여섯번째 점에 대해서 ccw를 해준다. 마찬가지로 음수가 등장하기 때문에 stack의 top을 pop해준다.

드디어 ccw값이 양수가 나타나 점을 stack에 push해준다. 놀랍게도 삭제한 두 점은 현재 stack에 있는 점들로 다각형을 만들었을 때 그 내부에 위치한다. 기울기가 증가하는 형태로 점들을 살펴보고 있기 때문에 새롭게 등장하는 점이 이전의 점들을 cover할 수 있게 된다.

최종적으로 마지막 점까지 과정을 반복해주면 다음과 같은 컨벡스 헐이 등장한다.

이를 코드로 나타내주면 다음과 같다. 컨벡스 헐의 선분 위에 여러 점이 존재할 경우 가장 끝의 점만 나타내도록 구현하였다.

func ccw(a: (Int, Int), b: (Int, Int), c: (Int, Int)) -> Int {
    let result = (b.0-a.0)*(c.1-a.1) - (b.1-a.1)*(c.0-a.0)
    return result > 0 ? 1 : (result == 0 ? 0 : -1)
}

func dist(a: (Int, Int), b: (Int, Int)) -> Int {
    let dx = a.0 - b.0, dy = a.1-b.1
    return dx*dx + dy*dy
}

func makeHul(input: [(Int, Int)]) -> [(Int, Int)] {
    var arr = input
    arr.sort(by: {$0.1 < $1.1})
    arr.sort(by: {$0.0 < $1.0})
    let S = arr[0]
    arr[1..<arr.count].sort(by: {
        ccw(a: S, b: $0, c: $1) == 0 && (dist(a: S, b: $0) < dist(a: S, b: $1))
        //기울기가 같을 경우 거리가 짧은 점부터 보도록 한다.
    })
    arr[1..<arr.count].sort(by: {
        ccw(a: S, b: $0, c: $1) > 0
    })
    var stack:[(Int, Int)] = []
    for next in arr {
        while stack.count >= 2 && (ccw(a: stack[stack.count-2], b: stack[stack.count-1], c: next) <= 0) {
        // 기울기가 같은 점을 마주쳤을 때도 마지막 점을 pop한다.
            stack.removeLast()
        }
        stack.append(next)
    }
    return stack
}

정수론 & 조합론

2021-06-22T00:00:00+00:00

1. 약수

약수의 갯수를 구하는 알고리즘을 알아보자.
간단하게 표현한다면 다음과 같을 것이다.

var divisor = [Int]()
for i in 1...n {
    if n%i == 0 {
        divisor.append(i)
    }
}

그런데 약수의 경우 i x i = n 이 되는 i에 대해서 i를 기준으로 절반씩 갯수가 존재한다. 따라서 모든 i에 대해 볼 필요없이 범위를 sqrt(n)까지로 제한해 줄 수 있다.

import Foundation
var divisor = [Int]()
let sqrtn = Int(sqrt(Double(n)))
for i in 1...sqrtn {
    if n%i == 0 {
        divisor.append(i)
        if i*i != n {
            divisor.append(n/i)
        }
    }
}

만약 우리가 1~n까지의 모든 수의 약수의 갯수를 구하고자 한다면 어떻게해야할까? 위에서 사용했던 방식을 사용하면 모든 수에 대해서 sqrt(n)만큼을 확인해야하기 때문에 O(nsqrt(n)) 의 시간이 소요된다.

좀 더 개선을 하기위해 2부터 숫자를 늘려가며 범위내의 모든 곱에 대해서 체크를 해주는 방식을 활용할 것이다.

import Foundation
let n = 20
var divisor = Array(repeating: 0, count: n+1)
for i in 1...n {
    for j in 1..<n/i+1 {
        divisor[i*j] += 1
    }
}

2. 최대공약수

최대공약수 알고리즘을 이해하려면 유클리드 호제법에 대해서 먼저 알아야한다.

유클리드 호제법
a를 b로 나눈 나머지가 r이라고 하고 a와 b의 최대공약수를 (a, b)라고 한다면 다음이 성립한다.
(a, b) = (b, r)

따라서 예시로 1071과 1029에 대한 최대공약수를 적어보면
(1071, 1029) = (1029, 42) = (42, 21) = (21, 0)
최종적으로 0이 등장하면 그때의 값이 최대공약수가 된다.
따라서 1071과 1029의 최대공약수는 21이 된다.

이를 재귀 함수로 나타내면 다음과 같다. a, b의 대소관계는 중요치 않다는 것을 명심하자. a = 10, b = 25로 예를 들면 gcd(a: 25, b: 10%25)가 호출되어서 자동으로 a, b 값이 swap된 형태로 함수가 작동한다.

func gcd(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return gcd(a: b, b: a%b)
}

3. 최소공배수

두 수의 최소공배수는 최대공약수를 구하면 간단히 구할 수 있다. 예시로 1071, 1029를 예로 들자면 둘의 최대 공약수는 21이다. 이 때 두 수는 51x21 = 1071 과 49x21 = 1029로 나타낼 수 있다. 따라서 최소공배수는 두 수의 곱에서 최대 공약수를 한번 나누어준것과 같다.

func LCM(a: Int, b: Int) -> Int {
    let gcdVal = gcd(a: a, b: b)
    return a*(b/gcdVal)
}

4. 이항계수

_nC_k로 표현되는 이항계수는 n개 중에서 k개를 택할 때의 경우의 수를 의미한다. 일반적으로 DP를 활용하여 구하는 방법이 보편적이다. _nC_k = _n-1C_k-1 + _n-1C_k의 성질과 _nC₀ = _nC_n = 1 성질을 활용해 코드를 짤 것이다.

이항계수의 경우 n이 조금만 커져도 값이 순식간에 int 범위를 벗어나기 때문에 임의의 숫자로 나눈 나머지로 표현하는 경우가 많다.

func combo(n: Int, k: Int) -> Int {
    var arr = Array(repeating: 1, count: n+1)
    for i in 1...n {
        let tmp = arr
        for j in 1..<i {
            arr[j] = tmp[j-1] + tmp[j]
        }
    }
    return arr[k]
}

5. 소수

소수란 약수가 1과 본인 자신밖에 없는 수를 말한다. 간단하게 구현하자면 2부터 n-1까지 모든 수를 n과 나누어서 나머지가 0이 되는 값이 존재하는지 확인해주면 된다.

그러나 약수 알고리즘과 동일하게 모든 수는 2~sqrt(n)까지의 지점에 대해서만 확인을 하면 그 이상의 약수에 대해서는 sqrt(n)과 작거나 같은 범위를 탐색할 때 한번씩 방문을 하게 된다. 따라서 다음과 같이 소수판별 알고리즘을 짤 수 있다.

import Foundation
func prime(n: Int) -> Bool {
    let sqrtn = Int(sqrt(Double(n)))
    for i in 2...sqrtn {
        if n%i == 0 {
            return false
        }
    }
    return true
    // 1, 2, 3은 예외처리를 해줘야한다. 여기선 skip
}

만약 1~n까지의 모든 수의 소수 여부를 알고싶다고 했을 때 일일히 prime함수를 대입하는 것은 시간낭비이다. 약수의 갯수를 셌던 알고리즘을 생각해보자. 이를 동일하게 prime 알고리즘에도 적용할 수 있다.

2부터 순차적으로 sqrt(n)까지 방문을 하는데 만약 이전에 방문한 적이 없다면(소수라면) 해당 숫자의 배수들은 모두. 소수가 아니라고 판명해주는 것이다.

예시로 2는 소수가 아니므로 2의 배수들 4, 6, 8 … 을 모두 소수가 아니라고 check배열에 표시해준다. 3도 마찬가지로 소수가 아니므로 배수들 6, 9, 12 … 을 모두 소수가 아니라고 check배열에 표시해준다. 4는 check배열에 소수가 아니라고 표시되어 있기 때문에 넘어간다. 5도 마찬가지로 소수가 아니므로 배수들 10, 15, 20 … 을 소수가 아니라고 표시해준다.

이런식으로 2-sqrt(n)까지 반복하면서 소수 여부를 배열에 남겨주면 된다. 이를 에라토스테네스의 체 라고 부른다.

import Foundation
func prime(n: Int) -> [Bool] {
    let sqrtn = Int(sqrt(Double(n)))
    var check = Array(repeating: true, count: n+1)
    check[0] = false
    check[1] = false
    for i in 0...sqrtn {
        if check[i] {
            var idx = 2*i
            while idx <= n {
                check[idx] = false
                idx += i
            }
        }
    }
    return check
}

아호코라식 알고리즘

2021-06-22T00:00:00+00:00

앞에서 KMP알고리즘을 배우고 온 상태에서 해당 공부를 하는 것을 추천한다. 만약 다음과 같은 두 개의 문자열이 존재한다고하자. A의 길이를 N, B의 길이를 M이라 표현하겠다.

A = “hshshi”
B = “shsh”

A속에 B가 존재하는지 확인하는 것은 KMP알고리즘을 사용할 시 O(N+M) 의 시간이 소요된다.

그런데 만약 A속에 존재하는지 확인하고 싶은 문자열이 여러개라고 하자. 다음과 같이 B는 문자열 집합으로 변한다.

A = “hshshi”
B = “shsh, shi, hshi”

B 문자열 집합에는 k개의 원소가 존재한다고 했을 때 KMP알고리즘을 각각 적용하면 O(kN + M1 + M2 … Mk) 의 시간이 걸리게 된다. 즉 A문자열을 매번 전부 확인해줘야하기 때문에 N이 크다면 굉장히 많은 시간이 소요되게 될 것이다.

1. Trie Make 알고리즘

이를 해결하기 위해서 아호 코라식 알고리즘이 등장했다. 해당 알고리즘은 KMP알고리즘의 fail함수와 Trie를 섞어 만든 기법이다. 먼저 B의 문자열 집합에 대해 Trie를 만든다고 하자. 그렇다면 해당 그래프는 다음과 같이 나타날 것이다.

만약 어떤 문자열을 따라서 HSH까지 왔다고 생각해보자. 만약 그 뒤에 SH가 등장한다면 어떻게 해야할까? 생각해보면 HSHSH라는 경로는 앞에 H를 탈락시키고 SHSH로 볼 수도 있다. 그렇다면 HSHSH속에는 SHSH라는 B 문자열 집합 중 하나가 존재한다고 판별이 가능하다.

이를 해결하기위해 HSH 경로의 마지막 H와 SH 경로의 H를 fail 관계라고 연결시켜줘보자. 만약 HSH 이후에 S를 만난다면 더이상 나아갈 길이 없다. 이 때 SH 경로의 H로 fail관계를 따라 돌아가게되면 S로 나아가는 새로운 길이 보인다.

최종적으로 HSH -> SH -> SHSH로 HSHSH 속에서 SHSH라는 문자열을 찾아낼 수 있게 된다. 우와 놀랍게도 KMP 알고리즘에서 fail함수를 거친 것처럼 현재 찾고있는 문자열이 변하게 된다. 그렇다면 어떻게 fail 관계들을 설정하면 좋을까?

우리는 root부터 순차적으로 BFS로 Trie를 훑을 것이다. 먼저 root와 연결된 S, H 정점에 대해서는 부모가 root기 때문에 fail 경로를 root로 선택해준다.

다음 S -> H의 경우 S의 fail을 따라가면 root가 나온다. 이 때 H로의 경로가 존재하기 때문에 root -> H와 S -> H의 H를 연결해준다. 마찬가지로 H -> S의 S도 fail을 연결해준다.

이 것의 의미는 만약 SH다음에 E라는 문자가 등장했을 때 경로가 존재하지 않는다면 H로 살펴보고 있던 경로를 함축시키고 HE라는 문자가 Trie에 있는지 확인하라는 의미가 된다.

마찬가지로 다음 depth를 설정해준다. 만약 부모의 fail을 따라갔을 때 여전히 경로가 존재하지 않는다면 경로가 존재할때까지 반복해서 거슬러내려가줘야한다는 것을 명심하자. I의 fail을 설정할 때 SH -> H -> root로 2번 반복해서 fail경로를 탐색했다. 최종적으로 root에서도 경로가 없다면 root로 fail을 연결시킨다.

최종적으로 완성한 Trie는 위와 같다. Trie Class에 대한 코드와 Trie fail 관계를 설정해주는 ahocorasick 함수는 다음과 같다.

Trie Class

class Trie {
    var go:[Trie?] = Array(repeating: nil, count: 26)
    var fail:Trie?
    var output = false
    var isRoot = false
    
    func delete() {
        fail = nil
        for i in 0..<26 {
            if go[i] != nil {
                go[i]!.delete()
            }
            go[i] = nil
        }
    }
    
    func insert(key: String) {
        if key == "" {
            output = true
            return
        }
        let next = Int(key.first!.asciiValue!-97)
        if go[next] == nil {
            go[next] = Trie()
        }
        var tmp = key
        tmp.removeFirst()
        go[next]!.insert(key: tmp)
    }
}

ahocorasick Function

func ahocorasick(root: Trie) {
    var q = [Trie]()
    q.append(root)
    while !q.isEmpty {
        let curr = q.removeFirst()
        for i in 0..<26 {
            if curr.go[i] == nil {continue}
            let next = curr.go[i]!
            if curr.isRoot {next.fail = root}
            else {
                var failure:Trie? = curr.fail
                while !(failure!.isRoot) && failure!.go[i] == nil {
                    failure = failure!.fail
                }
                if failure!.go[i] != nil {
                    failure = failure!.go[i]
                }
                next.fail = failure
            }
            if next.fail!.output {
                next.output = true
            }
            q.append(next)
        }
    }
}

root를 설정해주고 root에 여러 문자열들을 insert시키면 Trie 구조체를 만들 수 있다. 그 후 root에 대해 ahocorasick 함수를 동작시켜 모든 fail관계를 구축해주면 된다.

Aho-Corasick Trie Make Code

var root = Trie()
root.isRoot = true
for s in StringSet {
    root.insert(key: s)
}
ahocorasick(root: root)

2. Find 알고리즘

이제 우리는 찾고자하는 문자열 집합에 대해 Trie를 완성시켰다. 그러면 A라는 문자열을 쭉 훑으면서 B라는 집합 속의 문자열들이 등장하는지 확인할 것이다. 방법으로는 KMP알고리즘처럼 쭉 훑다가 해당 문자로 나아갈 경로가 없다면 fail함수를 거쳐 새로운 경로를 찾는 것이다.

방법 자체는 간단하니 한번 코드를 읽고 확인해주면 될 것 같다. 여기서는 B 집합속의 원소를 하나라도 발견할 시 true를 리턴시켜주도록 구현이 되어있는데 문제 형태에 맞게 변형시켜주면 된다.

KMP Function

func KMP(root: Trie, str: String) -> Bool {
    var isFind = false
    var current:Trie? = root
    for c in str {
        let idx = Int(c.asciiValue!-97)
        while !(current!.isRoot) && current!.go[idx] == nil {
            current = current!.fail
        }
        if current!.go[idx] != nil {
            current = current!.go[idx]
        }
        if current!.output {
            isFind = true
            break
        }
    }
    return isFind
}

최종적으로 걸리는 시간은 Trie를 만드는데 O(M1 + M2 + … + Mk ) 문자열을 쭉 훑으면서 Trie속의 문자열들이 등장하는지 확인하는데 O(N) 이 걸리게 되어 총 O(N + M1 + M2 + … + Mk) 이 소요된다.

Suffix Array & LCP

2021-06-22T00:00:00+00:00

1. Suffix Array

suffix란 앞에서 배웠듯이 접미사들을 의미한다.
예를 들어 banana에 대해 접미사를 나열해보면 다음과 같다.

Suffix	i
banana	1
anana	2
nana	3
ana	4
na	5
a	6

이 접미사들을 사전 순으로 나열하면 다음과 같이 정리할 수 있다.

Suffix	i
a	6
ana	4
anana	2
banana	1
na	5
nana	3

이렇게 사전순으로 정렬된 i의 배열 [6, 4, 2, 1, 5, 3]을 S의 Suffix Array라고 부른다.

어떻게하면 suffix array를 구할 수 있을까? 단순히 정렬 알고리즘을 사용한다고하면 정렬에 O(nlogn) 비교에 O(n) 이 걸려 총 O(n²logn) 이 소요되게 된다. 이를 개선하기 위해서 O(nlog²n)만에 구하는 알고리즘이 존재하는데 이를 맨버-마이어스 알고리즘이라 부른다.

2. Manber-Myers Algorithm

글자 정렬을 할 때 1, 2, 4… 와 같이 2의 제곱수들을 기준으로 정렬하는 방식으로 되어있는 알고리즘이다. 예를들어 banana를 기준으로 정렬을 해보면 첫글자를 갖고 먼저 정렬을 하면 다음과 같다.

2⁰
anana
ana
a
banana
nana
na

단순히 첫번째 글자만 비교하면 되니까 O(nlogn)이 걸린다.
이번에는 두개의 글자를 가지고 비교를 해보자.

2¹
a
ana
anana
banana
nana
na

이번에는 네개의 글자를 가지고 비교를 해보자.

2²
a
ana
anana
banana
na
nana

어라 그런데 생각을 해보면 4개의 글자를 비교하는 과정에서 하나씩 비교를 하게되면 결국에는 O(n)만큼 비교를 하게 되는 것이 아닌가 생각이 든다. 결국 O(n²logn)이 걸리는 것은 변함이 없어 보인다. 이를 해결하기 위해 우리는 g와 sfx 배열을 이용할 것이다.

먼저 suffix 배열에는 각각 0번부터 5번까지 순차적으로 입력을 해주고 g에는 알파벳들의 순서에 맞게 번호를 매겨준다. banana의 경우 a가 1, b가 2, n이 3이 되었다. g 배열의 마지막 index에는 항상 -1을 넣어놓는다.

suffix 배열을 g를 기준으로 정렬할 것이다. 이 때 g는 해당 위치의 알파벳을 시작으로 t 길이의 영역간의 대소 순위를 나타내준다. 초기에는 t가 1이므로 b, a, n, a, n, a 각각에 대한 크기 순위가 g에 저장되어있다.

그렇게 새롭게 sfx배열을 얻어내면 위와 같이 나타난다. 우리는 새롭게 정렬된 sfx배열과 기존의 g 배열을 이용해서 새로운 g를 얻어낼 것이다. 새롭게 얻어내는 g는 이전 t의 2배에 해당하는 영역의 순위를 나타낸다. 즉 이번에는 ba, an, na, an, na, a 에 대해서 g값을 얻어낼 것이다.

맨 처음에는 5번 index와 1번 index를 비교한다. 이 때 g[5]와 g[1]의 값은 똑같이 1(A)이 나왔기 때문에 t만큼 떨어진 위치의 알파벳을 확인해준다. t의 값은 아직 1이기 때문에 g[5+1] 과 g[1+1] 을 비교해주고 각각 -1(빈칸)과 3(N)이 나타난다.

-1을 g의 마지막 index에 대입해준 이유가 여기서 나타난다. 공백에 다른 모든 알파벳보다 우선순위를 주기 위해서이다. g[6] < g[2] 이기 때문에 new g[1]에 new g[5] + 1을 대입해주게 된다.

이번에는 g[1]과 g[3]을 비교할 차례이다. 하지만 g[1] == g[3] (A), g[2] == g[4] (N) 이기 때문에 new g[1] == new g[3] 가 되게 된다.

이번에는 g[3]과 g[0]을 비교하자. 길게 볼 필요 없이 g[3] < g[0]이기 때문에 new g[0] = new g[3] + 1이 된다. 여기서 g[3] < g[0] 이라는 것은 AN과 BA의 순위 관계를 매겨주기위해서 A < B 이기 때문에 첫번째 알파벳만을 확인해서 순위를 매겨줬다는 의미를 갖고있다는 것을 다시한번 확인하자.

순서대로 나머지 빈칸들을 다 완성하면 새로운 sfx와 g값이 완성된다. t값도 2배를 해주어 1 -> 2로 변하였다.

자 이제 sfx에는 문자 2개씩 비교해서 얻어낸 결과가 들어있고 g에는 문자열에서 해당 문자를 시작으로 2칸씩 묶었을 때 대소관계를 비교한 결과가 들어있다.

이제 다시 sfx배열을 g를 이용해서 정렬시켜줄 것이다. g에는 문자 2개씩 묶은 값이 들어있기 때문에 sfx는 최대 4개의 문자를 비교할 수 있게 된다.

위와같이 ANAN과 ANA 를 비교해야할 때 처음 두 글자는 모두 AN으로 같기 때문에 뒤의 AN와 A 를 비교해서 순서를 매겨준다.

마찬가지로 NANA와 NA 를 비교해야한다면 첫 두 글자는 모두 NA로 같기 때문에 뒤의 NA와 (공백)을 비교해서 순서를 매겨준다.

최종적으로 완성된 suffix array는 위와 같다. 이제 새로운 g를 마찬가지로 구해준다. 앞서 했던것과 과정은 동일한데 이번에는 t가 2이기 때문에 2칸 떨어져있는 곳의 g값을 참조한다는 것을 염두해두고 보길 바란다.

과정을 반복해 t가 n보다 커진다면 멈추고 그 때의 sfx를 반환시켜준다. 놀랍게도 n개의 알파벳을 모두 비교하던 때와는 다르게 단 2번의 비교만으로 n길이의 단어들을 비교할 수 있게 되었다.

따라서 O(logn)번 sfx sort를 하게되고 sort 자체에 O(nlogn)이 소요되고 비교과정이 O(1)으로 줄었기 때문에 총 O(nlog²n)의 시간복잡도를 갖게된다.

Manber-Myers Function

func suffix(str: String) -> [Int] {
    let n = str.count
    var g = Array(repeating: -1, count: n+1)
    var tmp = Array(repeating: -1, count: n+1)
    var sfx = Array(repeating: 0, count: n)
    var t = 1, idx = 0
    
    func compare(i: Int, j: Int) -> Bool {
        if g[i] == g[j] {
            return g[i+t] < g[j+t]
        }
        else {
            return g[i] < g[j]
        }
    }

    for i in str.indices {
        g[idx] = Int(str[i].asciiValue!)
        sfx[idx] = idx
        idx += 1
    }

    while t < n {
        sfx.sort(by: compare)
        tmp[sfx[0]] = 0
        for i in 1..<n {
            if compare(i: sfx[i-1], j: sfx[i]) {
                tmp[sfx[i]] = tmp[sfx[i-1]]+1
            }
            else {
                tmp[sfx[i]] = tmp[sfx[i-1]]
            }
        }
        g = tmp
        t <<= 1
    }
    return sfx
}

3. LCP (Longest Common Prefix)

최장 공통 접두사를 의미하는 것으로 Suffix Array를 구한 후 바로 이전 suffix와의 lcp를 배열에 담은 것을 lcp array 라고 부른다. banana를 기준으로 [6, 4, 2, 1, 5, 3] 은 [a, ana, anana, banana, na, nana]를 나타내게 되고 lcp array를 구하면 [x, 1, 3, 0, 0, 2]가 되게 된다.

마찬가지로 일일히 이전 suffix와 현재 suffix를 앞에서부터 비교해나가면 o(n²)의 시간이 소요될 것이다. 자 이제 위에서 구한 suffix array를 활용할 때가 왔다. rank라는 배열을 하나 만들 것인데 이는 각각의 index로부터 시작하는 suffix의 suffix array(SA)상에서의 순위를 나타낸다.

rank와 SA를 나타내어 정리하면 다음 그림과 같다. banana는 SA상에서 3순위로 rank[0] = 3이 되었다.

한가지 예시로 anana와 ana가 존재할 때 둘의 LCP는 ana로 길이 3이다. 그런데 맨앞에서 a를 둘 다 제거해보면 nana와 na가 나타나게 되고 둘의 LCP는 na로 길이 2이다.

anana와 ana은 suffix array 상에서 붙어있는데 맨 앞에서 a를 제거한 nana, na 역시 붙어있는 것은 suffix의 특성상 당연하다. 그렇다면 anana와 ana이 3이라는 공통 접두사가 존재하기 때문에 맨앞에서 한개씩 뗀 nana와 na 역시 최소 2 이상의 공통 접두사가 존재할 수 밖에 없다.

이제 banana부터 앞에서부터 하나씩 알파벳을 지워가면서 진행할 것이다. banana의 rank는 3으로 rank 2의 단어와 비교를 해야 LCP Array를 채울 수 있다. 이 때 SA[rank] 를 하게되면 해당 rank의 단어의 string상에서의 index를 알 수 있다. 따라서 banana와 anana를 비교할 수 있게 되고 둘은 공통 접두사가 없기 때문에 LCP[3] = 0 이 된다.

이번에는 anana의 차례이다. banana에서 anana가 됐지만 banana의 LCP 값이 0이었기 때문에 이전 정보를 활용하지 않는다. anana의 rank 값은 2고 바로 직전의 SA 값은 ana에 해당한다. anana와 ana는 공통 접두사 길이가 3이기 때문에 LCP[2] = 3이 된다.

자 여기서부터가 하이라이트이다. anana에서 맨 앞 글자를 지우면 nana가 된다. 이 때 nana의 rank는 5로 rank 4인 na와 비교를 하게 된다.

그런데 이전에 구한 lcp 값 - 1보다 공통 접두사 길이가 크거나 같을 것이기 때문에 nana와 na를 맨앞글자부터 비교할 필요 없이 최소한 2글자는 공통된다는 것을 가정하여 3번째 글자끼리 비교를 하게 된다. 참고로 String에 #과 같은 안쓰는 문자를 추가해주어 문자열의 끝을 나타내주면 비교가 편하다.

이 때 세번째 글자는 같지 않기 때문에 공통 접두사의 길이는 2가 된다. 따라서 LCP[5] = 2가 된다. 이와같은 방법으로 나머지 모든 LCP를 완성하게 되면 [x, 1, 3, 0, 0, 2] 의 LCP 배열을 얻어낼 수 있다.

LCP Code

let SA = suffix(str: str)
var rank = Array(repeating: 0, count: str.count)
var strArr = str.map{Character(String($0))}
strArr.append("#")
for i in 0..<str.count {
    rank[SA[i]] = i
}
var len = 0
var LCP = Array(repeating: 0, count: str.count)
for i in 0..<str.count {
    let k = rank[i]
    if k != 0 {
        while strArr[SA[k-1]+len] == strArr[i+len] {
            len += 1
        }
        LCP[k] = len
        if len > 0 {
            len -= 1
        }
    }
}

Z 알고리즘

2021-06-22T00:00:00+00:00

문자열 S가 S₁S₂…S_n 으로 구성된다고 했을 때 Z[i]를 S와 S_i ~ S_n의 가장 긴 공통 접두사의 길이라고 하자. 이 때 이를 쉽게 구하는 알고리즘이 Z 알고리즘으로 Manacher와 비슷한 방식으로 동작해서 O(n) 의 시간 복잡도가 걸리는 효율적인 알고리즘이다.

Z 알고리즘에서는 l과 r이라는 변수를 사용한다. i보다 작은 index k에 대해서 Z값을 알고 있을 때 r은 그중에서 k+Z[k]가 가장 큰 값에 해당하고 그 때의 k를 l이라고 한다고 하자.

그렇다면 r보다 i가 큰 경우와 작거나 같은 경우로 나누어서 접근할 것이다.

1. i > r

이전의 정보가 아무런 도움이 안되는 경우로 i부터 새롭게 맨처음과 비교를 해나간다. if S[z[i]+1] == S[i+z[i]+1] {z[i] += 1} 최종적으로 Z[i]의 값은 새로운 r-l과 같아진다.

2. i ≤ r

S[l]~S[r]은 S[0]~S[r-l]와 같다는 정보를 이미 알고 있다. 따라서 S[i]부터 시작하는 공통 접두사는 S[i-l]의 공통 접두사와 같을 수 밖에 없다. Z[i] = min(Z[i-l], r-i)

Manacher와 마찬가지로 Z[i] = Z[i-l]로 선언할 수 없는데 r를 넘어서는 범위에 대해서는 보장을 할 수 없게되기 때문이다. 이 후 1번과 동일하게 비교를 해나가면서 Z값을 구해준다.

Z Function

func Z(str: [Character]) -> [Int] {
    let n = str.count
    var l = -1, r = -1
    var z = Array(repeating: -1, count: n)
    for i in 1..<n {
        if i <= r {
            z[i] = min(z[i-l], r-i)
        }
        while i+z[i]+1 < n && str[z[i]+1] == str[i+z[i]+1] {
            z[i] += 1
        }
        if i+z[i] > r {
            r = i+z[i]
            l = i
        }
    }
    return z
}

시간 복잡도를 생각해보면 마찬가지로 z[i]의 증가 횟수에 달려있다는 것을 알 수 있는데 이는 r의 증가 횟수와도 같다. 따라서 최대 O(n) 이 걸림을 알 수 있다.

Manacher 알고리즘

2021-06-22T00:00:00+00:00

앞서 dp파트에서 펠린드롬에 대한 문제를 풀어본 적이 있을 것이다. 펠린드롬이란 앞에서 읽었을때와 뒤부터 읽었을 때 결과가 똑같은 문자열을 의미한다. 또 다르게 생각해보면 정 중앙을 기점으로 퍼져나갈때 똑같은 문자가 등장하는 문자열을 의미한다.

기존 펠린드롬 구하기는 O(n^2) 의 시간이 소요됐었지만 이번에 소개할 알고리즘은 O(n) 이 걸리는 manacher 알고리즘이다. Manacher 알고리즘은 이전에 활용한 정보를 바탕으로 진행되는 알고리즘이다. 특정 위치를 중심으로 하는 펠린드롬을 구하는 것을 기본 전제로 하고 시작할 것이다.

만약 i번째를 중심으로 하는 펠린드롬을 구하려고한다고하자. 그런데 i보다 작은 index에 대해서 해당 index를 중심으로하는 펠린드롬들은 각각 왼쪽 끝과 오른쪽 끝이 존재할것이고 그 때 오른쪽 끝 index 값이 가장 클 때의 중심 index를 k라 하고 k를 중심으로 하는 펠린드롬의 오른쪽 끝 index를 r이라고 하자.

i가 r보다 클경우와 작은 경우로 나누어 펠린드롬을 찾아보자.

1. i > r

이전 정보를 하나도 활용할 수가 없는 경우로 i를 중심으로 하는 펠린드롬을 새롭게 찾아준다. i를 기점으로 한칸씩 양옆으로 이동하면서 비교를 해준다.
if S[i+p[i]+1] == S[i-p[i]-1] {p[i] += 1}

2. i ≤ r

자 이제 r 속에 i가 포함되는 경우를 생각해보자.

i는 k를 중심으로 하는 펠린드롬 속에 포함이 되어있다. k를 중심으로 i와 정반대에 있는 index를 i’ = 2k-i 이라고 하면 i와 i’은 대칭이기 때문에 i’을 중심으로 하는 펠린드롬은 i를 중심으로 하는 펠린드롬과 같다. 따라서 p[i] = min(p[i'], r-i) 가 성립하게 된다.

주의할 것은 p[i] = p[i’] 이 아니라는 것인데 r을 넘어서는 영역에 대해서는 펠린드롬 여부를 보장할 수가 없기 때문에 그 이후의 영역에 존재하는 문자들은 일일히 비교를 해가며 p[i] 값을 결정해주어야한다.

따라서 1에서 구했던 것과 마찬가지로 p[i] 값을 증가시키면서 i를 중심으로하는 펠린드롬의 길이를 찾아주자. 만약 i번째에 새롭게 구한 펠린드롬이 기존의 r보다 오른쪽 끝 index가 크다면 r과 k값을 새롭게 설정하면서 모든 index에 대해 펠린드롬을 구하면 된다.

Manacher function

func manacher(str: [Character]) -> [Int] {
    let n = str.count
    var k = -1, r = -1
    var p = Array(repeating: 0, count: n)
    for i in 0..<n {
        if i <= r {
            p[i] = min(p[2*k-i], r-i)
        }
        while i-p[i]-1 >= 0 && i+p[i]+1 < n && str[i-p[i]-1] == str[i+p[i]+1] {
            p[i] += 1
        }
        if i+p[i] > r {
            r = i+p[i]
            k = i
        }
    }
    return p
}

Manacher 알고리즘은 i를 중심으로 하는 펠린드롬을 구하는 것이기 때문에 기본적으로 홀수의 길이를 갖는 펠린드롬만 구해진다. 만약 짝수를 구하고 싶다면 문자열 사이사이에 # 이나 @ 같은 안쓰는 기호로 모두 채워주면 간단히 해결할 수 있다. ABBA를 예로들면 #A#B#B#A# 가 되고 가운데에 위치하는 #에 대해 펠린드롬을 구해주면 짝수의 경우에도 찾아낼 수 있다.

모든 i에 대해서 초깃값 p[i]를 찾는 것은 O(1) 이 걸리게 되고 이 후 p[i] += 1 을 하는 횟수에 따라서 시간복잡도가 결정되게 된다. 그러나 p[i]가 증가하는 횟수는 r이 증가하는 횟수와 같고 최종적으로 r ≤ n 이기 때문에 O(n) 의 시간이 걸리게 된다.

Trie

2021-06-22T00:00:00+00:00

문자열을 효율적으로 저장하기위해 고안된 일종의 자료구조이다. 사전 속에 수많은 단어가 저장되어있고 그 중에서 특정 단어를 찾고자 한다고 하자. 만약 사전 속에 수많은 단어가 하나씩 저장되어 있을 때 특정 단어를 찾고자한다면 모든 사전 속의 단어를 살펴봐야할 수 도 있다.

이 때 이를 해결하고자 등장한 것이 Trie이다. 먼저 알파벳의 단어들을 다 쪼개서 트리 형태로 저장시킬 것이다. ban, bee, be, cat, cash라는 단어들이 사전에 저장되어 있다고 하자.

이 때 주황색으로 표시된 부분은 해당 위치에서 끝나는 단어가 존재한다는 의미이다. 위처럼 단어들을 저장하게 되면 중복해서 등장하는 부분을 생략할 수 있기 때문에 탐색시 드는 시간소요가 줄어들게 된다.

따라서 사전 속 가장 긴 단어가 L의 길이를 갖고있다고 했을 때 탐색하는 과정은 O(L) 의 시간이 걸리게 된다. 탐색이 훨씬 빠르다는 장점이 있으나 각 노드별로 자식들에 대한 정보를 갖고 있어야하기 때문에 저장공간이 많이 필요하다는 단점이 존재한다. 탐색 알고리즘은 dfs를 이용해서 단어를 한 문자씩 트리에서 찾아 내려가주면 된다.

생성시 시간복잡도는 단어 하나를 insert 하는데 O(L) 이 걸리고 총 M개의 단어를 저장한다고 하면 O(ML) 이 걸리게 된다. 탐색시 시간복잡도는 단어 하나를 찾을 때마다 최대 L의 길이를 탐색하게 될 것이므로 O(L) 이 소요된다.

Trie Code

var trie = Array(repeating: Array(repeating: 0, count: 26), count: 5000001)
var check = Array(repeating: false, count: 5000001)
var nextNode = 1
func maketrie(str: String) {
    var node = 0
    for i in str {
        let idx = Int(i.asciiValue!) - 97
        if trie[node][idx] == 0 {
            trie[node][idx] = nextNode
            node = nextNode
            nextNode += 1
        }
        else {
            node = trie[node][idx]
        }
    }
    check[node] = true
}

KMP 알고리즘

2021-06-22T00:00:00+00:00

네이버에나 한글 문서등에서 찾기를 사용하면 긴 문서안에서 우리가 원하는 단어가 어디서 등장하는지 쉽게 찾을 수 있다. ABCABC에서 BC라는 문자를 찾고자 할 때는 다음과 같이 진행할 수 있다.

A	B	C	A
B	C
	B	C
		B	C

이런식으로 계속 BC를 옮겨가면서 일치하는지 여부를 확인하는 작업은 문자열의 길이를 N, 단어의 길이를 M이라고 했을 때 O(NM) 의 시간이 걸리게 된다. 만약 문서의 크기가 작다면 문제가 없지만 실생활에서 사용하기에는 매우 느려서 사용하기 어렵다. 이제 우리는 O(N+M) 의 시간만에 해결하게 해주는 KMP 알고리즘을 알아볼 것이다.

1. Suffix & Prefix

Suffix란 접미사, Prefix란 접두사를 의미하는 것이다.
예를 들어 ABCAB에 대해 접미사와 접두사를 구해보자.
-Suffix
B
AB
CAB
BCAB
ABCAB

-Prefix
A
AB
ABC
ABCA
ABCAB

2. Pi 배열 (실패 함수)

문자열의 0~i까지의 부분 문자열에 대해서 prefix와 suffix가 같은 지점의 길이를 나타내주는 배열이다. 단 prefix가 자기 자신이 되는 것은 제외한다.
예를들어 ABCABD의 Pi 배열을 나타내보자.

i	부분 문자열	Pi 값
0	A	0
1	AB	0
2	ABC	0
3	ABCA	1
4	ABCAB	2
5	ABCABD	0

3. KMP

만약 ABCABCABD 라는 문자열에서 ABCABD라는 문자를 찾고자한다고 하자.

A	B	C	A	B	C	A	B	D
A	B	C	A	B	D

하나하나 매칭을 하다보면 마지막 C와 D가 일치하지 않는다는 것을 확인할 수 있다. 하지만 위에서 보았듯이 일일히 문자를 옮겨가면서 매칭을 하는 것은 비효율 적이라는 것을 배웠다. 따라서 틀렸던 부분인 C부터 새롭게 확인을 해나가고 싶다. 문자 ABCABD에서 일치하지 않는 부분인 D를 제외하고 ABCAB를 살펴보자.

AB라는 문자가 앞에서도 나타나고 뒤에서도 나타나는데 이를 활용하면 AB라는 문자는 중복해서 나타나기때문에 ABCABD를 비교하던 것을 ABC를 비교하는 차례로 단축시킬 수 있다.

이는 pi 배열에서 구한 prefix = suffix 인 부분의 길이와도 같다. 새롭게 비교를 해서 구한 결과는 아래와 같고 문자열 속에서 원하는 문자를 찾아냈다.

A	B	C	A	B	C	A	B	D
			A	B	C	A	B	D

이제 KMP를 구현을 해보자. 문자열 T와 찾아낼 문자인 P가 존재한다고 하자. i와 j는 각각 T와 P에서의 index를 의미한다. 만약 T의 index 3부터 P가 존재하는지를 찾고 있을 때 P에서 index 2인 C를 비교할 차례라고 하면 그림은 다음과 같이 되고 i의 값은 3 j의 값은 2가 된다. 추가로 T에서 P와 비교해야할 위치는 i+j인 5가 되는 것을 확인할 수 있다.

i	0	1	2	3	4	5	6	7	8
T	A	B	C	A	B	C	A	B	D
P				A	B	C

그렇다면 다음과 같이 i = 0, j = 5인 상황을 살펴보자.

i	0	1	2	3	4	5	6	7	8
T	A	B	C	A	B	C	A	B	D
P	A	B	C	A	B	D

T와 P의 Character가 일치하지 않기 때문에 우리는 i와 j 값을 이동시켜줘야 한다. 이 때 j는 위에서 알아봤듯이 Pi[j-1] = Pi[4] = 2 이 된다는 것을 알 수 있고 i는 기존 5에서 새로워진 j를 뺀 위치로 이동한다는 것을 알 수 있다. 따라서 j는 2로 변하고 i는 5-2 = 3 이 된다.

pi배열을 위에서 실패 함수라고 부르는 이유가 바로 이것이다. 문자 비교가 실패했을 경우 이동해야할 위치를 나타내주는 역할을 하기 때문이다.

그 후 새롭게 변한 i와 j를 갖고 T와 P의 Character가 일치하는지 여부를 다시 확인한다. 일치하게 된다면 j 값을 증가시키면 되고 아닐 경우 j가 0이 될때까지 위의 과정을 반복한다. j가 0이 된다면 더 이상 이전 정보를 활용할 수 없다는 뜻이 되고 i를 1 증가시켜 새로운 비교를 해나간다.

KMP Code

var i = 0, j = 0
var resultIndex = [String]()
while i + j < T.count {
    let Curr = i+j
    while j > 0 && T[Curr] != P[j] {
    //j가 0이 되거나 T와 P의 Character가 일치할때까지
        j = pi[j-1]
        i = Curr - j
    }
    if T[Curr] == P[j] {
    //일치시 j += 1
        j += 1
    }
    else {
    //j가 0이여서 더이상 이전 정보를 활용할 수 없을 때 i += 1
        i += 1
    }
    if j == P.count {
        resultIndex.append("\(i+1)")
        j = pi[j-1]
        i = Curr - j + 1
    }
}

4. MakePi

그렇다면 Pi함수는 어떻게 만들면 좋을까? 모든 i에 대해서 앞과 뒤를 비교해가며 구할 수도 있겠지만 KMP와 비슷한 과정이라는 것을 알고 KMP알고리즘을 활용하면 간단하다. T라는 문자열 대신 P속에서 P를 매칭시키는 방법을 사용하도록 하자.

makePi Function

func makePi(str: [Character]) {
    var j = 0
    for i in 1..<str.count {
        while j > 0 && str[i] != str[j] {
            j = pi[j-1]
        }
        if str[i] == str[j] {
            j += 1
            pi[i] = j
        }
    }
}

함수를 보면 알겠지만 KMP알고리즘과 모습이 상당히 유사하다. 유의할 점은 주어진 i는 움직이지 않고 j값만을 이동시켜가며 pi를 구한다는 것이다. ABABDABABA 라는 P가 주어진다고 하자. 이 때 pi값을 하나하나 만들어가면 다음과 같고 마지막 pi값을 구하려한다 하자.

i	0	1	2	3	4	5	6	7	8	9
Pi	0	0	1	2	0	1	2	3	4
P	A	B	A	B	D	A	B	A	B	A
P						A	B	A	B	D

D와 A는 일치하지 않기 때문에 j값을 4에서 pi[4-1] = 2 로 변경시키자. 이것의 의미는 ABAB는 AB가 중복되기 때문에 ABABD를 비교하던 차례에서 ABA를 비교하는 차례로 넘어가야 한다는 것이다.

i	0	1	2	3	4	5	6	7	8	9
Pi	0	0	1	2	0	1	2	3	4	3
P	A	B	A	B	D	A	B	A	B	A
P								A	B	A

이제 A로 두 문자가 일치하기 때문에 Pi[9] = 3이 된다.

MCMF (Minimum Cost Maximum Flow)

2021-06-22T00:00:00+00:00

유량 그래프에서 추가적으로 각 간선마다 비용이 존재한다고 하자. 그렇다면 source에서 sink까지 최소의 비용으로 최대한의 유량을 흘리는 방법을 구할 때 쓰는 알고리즘이 MCMF이다. 이 때 가장 먼저 기준이 되어야 할 요소가 flow가 아닌 cost가 된다.

따라서 경로의 비용을 구하기 위해 우리는 앞에서 배웠던 최단 경로 알고리즘을 응용할 것이다. 하지만 유량 그래프에서 한쪽방향으로 유량이 흐르면 반대쪽으로 -flow가 흐른다고 했던 것 기억할 것이다. 이는 유량뿐만 아니라 비용 역시 마찬가지로 d(u, v) = -d(v, u) 의 식을 만족한다.

따라서 최단 경로를 구할 때 음수의 weight가 있으므로 벨만포드를 사용해야 할 것이다. MCMF에서는 벨만포드를 조금 변형시켜 동작이 더 빠른 SPFA(Shortest Path Faster Algorithm)을 사용할 것이다.

1. SPFA (Shortest Path Faster Algorithm)

시작 정점부터 BFS를 하면서 모든 정점에 대한 최단 경로를 구할 것이다. 다익스트라와 비슷하게 하나씩 가까운 점들을 업데이트 하는데 이미 방문했던 정점이라할지라도 비용이 더 짧은 경로를 발견할 시에는 다시 큐에 집어넣고 새로운 경로를 찾는다는 점에 차이점이 있다.

이 때 큐 내부에 업데이트가 일어난 정점이 들어있을 경우 큐에 새로운 원소를 추가하지 않음으로써 시간을 단축시킨다. 평균적으로 벨만포드보다 빠른 O(E) 시간 안에 동작하지만 최악의 경우 O(VE) 가 걸리게 된다. 유의점으로는 mcmf를 위해서 유량을 비교하는 부분이 추가되어 있다는 것이다. 구현 자체는 간단해서 코드 한번 읽어보면 이해가 될 것이다.

SPFA Function

func SPFA() -> Bool {
    var dst = Array(repeating: INF, count: n+m+2) //최단 경로 비용 저장
    var inq = Array(repeating: false, count: n+m+2) //큐 내부에 들어있는지 여부
    var queue = [Int]()
    queue.append(s)
    inq[s] = true
    dst[s] = 0
    while !queue.isEmpty {
        let curr = queue.removeFirst()
        inq[curr] = false
        for next in edge[curr] {
            if c[curr][next] - f[curr][next] <= 0 {
                continue
                //유량이 흐를 수 없는 경로에 대해서는 continue
            }
            if dst[curr] < INF && dst[next] > dst[curr]+d[curr][next] {
                dst[next] = dst[curr]+d[curr][next]
                parent[next] = curr
                if !inq[next] {
                    queue.append(next)
                    inq[next] = true
                }
            }
        }
    }
    return dst[e] != INF
    //최종적으로 sink에 도달하는 경로가 존재할 시 true, 없을시 false
}

2. MCMF Function

자 이제 SPFA에 대해 공부했으니 해당 코드를 사용해서 경로를 구해보자. 경로를 구했다면 앞서 사용했던 에드몬드 알고리즘과 동작이 비슷하다. 경로를 따라서 흐를 수 있는 유량과 그 때의 비용을 계산해주면 된다. 그 후 경로를 따라서 flow 값들을 업데이트 시켜준다.

드는 비용은 비용의 합 x 경로를 따라 흐를 수 있는 최대 유량 이 될 것이다. 최종적으로 더이상 source에서 sink로 흐르는 경로가 없을 때까지 반복해서 구해주면 된다.

Flow Function

func flow() -> (Int, Int) {
    var totalFlow = 0, money = 0
    while SPFA() {
    // 더이상 경로가 없을 때까지 반복
        var idx = e, cost = 0, minF = INF
        while idx != s {
            let prev = parent[idx]
            minF = min(minF, c[prev][idx]-f[prev][idx])
            cost += d[prev][idx]
            idx = prev
        }
        // min Flow, cost 계산
        idx = e
        while idx != s {
            let prev = parent[idx]
            f[prev][idx] += minF
            f[idx][prev] -= minF
            idx = prev
        }
        // flow update
        money += cost*minF
        totalFlow += minF
    }
    return (totalFlow, money)
}

Network Flow

2021-06-22T00:00:00+00:00

유량 그래프란 파이프와 같이 되어있는 그래프로 각 간선마다 최대 흐를 수 있는 양이 정해져있는 그래프를 의미한다. 이 때 그래프에는 시작(source)와 끝(sink) 노드가 존재한다. 예시로 다음 그래프를 보자.

유량 그래프에는 다음과 같은 요소가 있다.

소스(source)   : 시작 위치
싱크(sink)     : 끝 위치
용량(capacity) : 유량이 흐를 수 있는 크기
유량(flow)     : 간선을 따라 흐르는 양

이 때 유량 그래프에서는 다음 3가지 속성이 항상 성립한다.

f(u, v) <= c(u, v)
f(u, v) = -f(v, u)
in Flow = out Flow

1, 3은 생각해보면 당연한 것인데 2라는 개념이 헤깔릴 수 있다. 다음 예시를 보고 이해해보자.

먼저 Source -> A -> B -> Sink의 경로로 1만큼의 유량이 흘렀다고 해보자. 이어서 Source를 통해 B로 유량을 보내려고 했는데 B가 갈 수 있는 간선이 꽉 차 더이상 흐를수가 없게 되었다.

그런데 2의 개념을 적용해서 그래프를 다시 그려보면 위와 같다. 자세히 보면 한쪽 방향으로 유량이 흐르면 반대편 방향으로 - 값이 흐르게 된다는 것을 알 수 있다. 이제 B -> A 경로의 Capacity - Flow 를 해보면 1 만큼의 유량이 흐를 수 있게 된다는 것을 의미한다. 이렇게 되면 Source -> B -> A -> Sink 로의 새로운 경로가 생기게 된다.

따라서 최종적으로 흐르게 되는 유량 그래프는 위와 같다. 어떻게 보면 Source -> A -> Sink 와 Source -> B -> Sink 두개의 길을 통해 유량이 흐른 것처럼 보인다. 2번 속성에 의해 유량이 최적의 해가되는 길로 흐르지 않더라도 언제든지 거슬러 올라 최적의 해를 찾아주게 된다.

그렇다면 어떻게 최적의 해를 찾을 수 있을까? DFS를 이용하는 포드 풀커슨 알고리즘와 BFS를 이용하는 에드몬드 카프 알고리즘, 그리고 디닉 알고리즘이 존재한다.

포드 풀커슨의 경우 한번에 1 만큼의 유량만 흘려주는 방식인데 O(EF) 의 시간이 걸려 F가 큰 문제에서는 굉장히 오랜 시간이 걸리게 된다. 따라서 일반적으로 O(VE^2) 의 시간이 걸리는 에드몬드 카프 알고리즘이 많이 사용되어서 에드몬드 카프 알고리즘에 대해 먼저 정리하겠다.

1. Edmonds-Karp Algorithm

BFS 기반의 알고리즘으로 flow가 흐를 수 있는 경로를 BFS로 찾아 해당 경로를 따라 flow를 흘려준다. 이 때 parent 라는 배열을 이용하여 지나온 경로를 저장해준다.

이 때 flow는 경로상 간선마다 흐를 수 있는 flow 중에서 가장 작은 값이 흐르게 된다는 점을 이용한다. 즉 c[u][v]-f[u][v] 의 최솟값이 흐르게 된다는 것을 의미한다.

Find Path’s Minimum Flow Code

var idx = e
var minF = 1_000_000_000
while idx != s {
    let prev = parent[idx]
    minF = min(minF, c[prev][idx]-f[prev][idx])
    idx = prev
}

한편 minimum flow를 찾았다면 다시한번 경로를 따라가면서 flow 배열에 저장된 값을 변경해준다. 이 때 u -> v 로 흘렀다면 v -> u 에도 -minimum flow를 더해줌을 잊지말자.

Update Flow Array

idx = e
while idx != s {
    let prev = parent[idx]
    f[prev][idx] += minF
    f[idx][prev] -= minF
    idx = prev
}

한번 bfs로 경로를 찾을 때 걸리는 시간은 O(E) 이고 찾는 횟수는 총 O(VE) 에 해당한다. 따라서 전체 걸리는 시간은 O(VE^2) 가 된다.

에드몬드 카프 전체 코드

let n = 10
var c:[[Int]] = Array(repeating: Array(repeating: 0, count: n+1), count: n+1)
var f:[[Int]] = Array(repeating: Array(repeating: 0, count: n+1), count: n+1)

// 함수를 쓰기 전에 꼭 capacity 배열을 조건에 맞게 설정해준다.

func edward(s: Int, e: Int) -> Int {
    var result = 0
    while true {
        var parent:[Int] = Array(repeating: -1, count: n+1)
        var q = [Int]()
        parent[s] = s
        q.append(s)
        // BFS로 경로를 찾을때마다 parent배열과 q배열을 초기화시켜줘야한다.
        while !q.isEmpty && (parent[e] == -1) {
            let curr = q.removeFirst()
            for i in 1...n {
                if c[curr][i] - f[curr][i] > 0 && parent[i] == -1 {
                //flow가 흐를 수 있는 경로에 대해서만 흘려준다.
                    parent[i] = curr
                    q.append(i)
                }
            }
        }
        if parent[e] == -1 {
            break
        // 흐를 수 있는 경로가 더이상 없으면 break!
        }
        var idx = e
        var minF = 1_000_000_000
        while idx != s {
            let prev = parent[idx]
            minF = min(minF, c[prev][idx]-f[prev][idx])
            idx = prev
        }
        // minimum Flow 찾는 과정
        idx = e
        while idx != s {
            let prev = parent[idx]
            f[prev][idx] += minF
            f[idx][prev] -= minF
            idx = prev
        }
        // flow 배열 update
        result += minF
    }
    return result
}

print(edward(s: 1, e: 2))

2. Dinic Algorithm

그런데 문제의 조건이 열약하여 O(VE^2) 의 시간에도 못 구하는 경우가 있다.
이럴 경우 디닉 알고리즘이 하나의 해법이 될 수 있는데 걸리는 시간은 O(EV^2) 로 에드몬드보다 빠르다.

디닉은 레벨 그래프라는 개념이 추가되어서 dfs를 활용하여 경로를 찾는 방식이다. 먼저 우리는 level 그래프를 그릴 것이다. 다음과 같은 그래프가 주어진다고 해보자.

이 때 bfs를 이용하여 레벨을 그리면 다음과 같이 된다. 그리고 dfs를 이용하여 level차이가 1이 나고 유량이 흐를 수 있는 경우 해당 간선을 통해서 유량을 흘려준다. 한번의 dfs를 통해 1번의 경로에 대해서만 유량을 흘려줄 수 있기 때문에 더이상 추가적인 유량이 흐르지 않을 때까지 반복해서 dfs를 실행시킨다.

자 이번엔 다시 bfs를 돌려 level그래프를 새롭게 형성해준다. 이 때 유의사항으로 파란색 간선이 보일텐데 유량이 한쪽 방향으로 흐르면 반대쪽으로도 -한 값이 흐르게 된다는 것을 항상 기억하자. 따라서 해당 간선을 고려해서 level을 마킹해주었다. 이 경우 빨간색 간선들을 따라 5만큼의 유량이 새롭게 흐를 수 있게 되었다.

이번에도 마찬가지로 bfs로 level을 마킹해주려했다. 그러나 어떤 경로를 통해서라도 sink에 level을 줄 수 없기 때문에 더이상의 작업은 필요없다고 판단하고 실행을 종료시킨다.

쉬워보이지만 몇가지 테크닉이 들어가 복잡할 수 있다. 코드를 하나씩 살펴보자.

BFS Function

func bfs() -> Bool {
    level = Array(repeating: -1, count: 555)
    var q = [Int]()
    level[s] = 1
    q.append(s)
    while !q.isEmpty {
        let curr = q.removeFirst()
        for i in edge[curr] {
            if level[i] == -1 && c[curr][i] - f[curr][i] > 0 {
                level[i] = level[curr] + 1
                q.append(i)
            }
        }
    }
    return level[e] != -1
}

레벨을 매겨주는 bfs 함수이고 동작은 앞서 했던 에드몬드의 bfs와 비슷하다. 유량이 흐를 수 있는 경로가 존재할 시 parent가 아닌 level함수를 이전 level에 1씩 증가시키면서 매겨준다. 최종적으로 sink에 level이 매겨진다면 true, 아닐시 false가 반환된다.

DFS Function

func dfs(curr: Int, flow: Int) -> Int {
    if curr == e {
        return flow
    }
    let nextVertex = work[curr]
    for i in nextVertex..<edge[curr].count {
        let next = edge[curr][i]
        if level[next] == level[curr] + 1 && c[curr][next] - f[curr][next] > 0 {
            let tmp = dfs(curr: next, flow: min(flow, c[curr][next] - f[curr][next]))
            if tmp > 0 {
                f[curr][next] += tmp
                f[next][curr] -= tmp
                return tmp
            }
        }
        work[curr] += 1
    }
    return 0
}

level 배열을 정했을 때 최대로 흘려줄 수 있는 유량을 계산하는 함수이다. 이 때 work 배열이 등장하는데 이번 차례에 봐야할 edge 번호를 알려주는 배열이다.

예를 들어 어떤 정점에 연결된 3번 edge를 통해 유량을 흘려줬지만 dfs로 반환받은 결과는 0이라고하자. 즉 해당 edge로 유량을 흘려줘도 더이상 유량이 흐르지 않는다는 것을 의미한다. 그렇다면 dfs를 반복적으로 실행하는 과정에서 다시 해당 정점에 도착했다고 하자. 이미 3번 edge를 통해 유량을 흘리는 것은 의미가 없다는 것을 알기 때문에 반복 과정에서 4번 edge부터 살펴보라고 할 수 있다. 이를 위한 역할이 바로 work 배열이고 시간을 줄이는데 큰 도움을 준다.

만약 유량이 흘렀다면 그 반환값을 가지고 flow 값을 변경시켜줘야 함을 유의하자. 이 때 역방향으로 -flow를 해주는 것도 잊지말자.

Dinic Function

func dinic() -> Int {
    var totalFlow = 0
    while bfs() {
        work = Array(repeating: 0, count: 555)
        while true {
            let tmpflow  = dfs(curr: s, flow: INF)
            if tmpflow == 0 {
                break
            }
            totalFlow += tmpflow
        }
    }
    return totalFlow
}

최종적인 dinic 함수로 bfs로 레벨 매칭에 성공할시 반복적으로 동작하도록 되어있다. 이 때 매번 level을 새로 매길 때마다 work 함수는 초기화를 시켜주어 모든 간선을 살펴볼 수 있도록 해야한다. 만일 더이상 flow가 흐르지 않는다면 다음번 level로 넘어가도록 되어있다.

디닉 전체 코드

let n = 100
let INF = 1_000_000_007
let s = 501, e = 502
var level:[Int] = Array(repeating: -1, count: 555)
var edge:[[Int]] = Array(repeating: [], count: 555)
var c:[[Int]] = Array(repeating: Array(repeating: 0, count: 555), count: 555)
var f:[[Int]] = Array(repeating: Array(repeating: 0, count: 555), count: 555)
var work:[Int] = Array(repeating: 0, count: 555)

// 마찬가지로 edge와 capacity 배열을 문제에 맞게 잘 설정해주도록 하자.

func addEdge(s: Int, e: Int, val: Int) {
    edge[s].append(e)
    edge[e].append(s)
    c[s][e] += val
}

func bfs() -> Bool {
    level = Array(repeating: -1, count: 555)
    var q = [Int]()
    level[s] = 1
    q.append(s)
    while !q.isEmpty {
        let curr = q.removeFirst()
        for i in edge[curr] {
            if level[i] == -1 && c[curr][i] - f[curr][i] > 0 {
                level[i] = level[curr] + 1
                q.append(i)
            }
        }
    }
    return level[e] != -1
}

func dfs(curr: Int, flow: Int) -> Int {
    if curr == e {
        return flow
    }
    let nextVertex = work[curr]
    for i in nextVertex..<edge[curr].count {
        let next = edge[curr][i]
        if level[next] == level[curr] + 1 && c[curr][next] - f[curr][next] > 0 {
            let tmp = dfs(curr: next, flow: min(flow, c[curr][next] - f[curr][next]))
            // 유량은 항상 경로상 최솟값이 흘러야 함을 유의
            if tmp > 0 {
                f[curr][next] += tmp
                f[next][curr] -= tmp
                return tmp
            }
        }
        work[curr] += 1
        // 유량이 해당 edge로 흐르지 못한다면 work배열을 1을 증가시킨다.
    }
    return 0
}

func dinic() -> Int {
    var totalFlow = 0
    while bfs() {
        work = Array(repeating: 0, count: 555)
        while true {
            let tmpflow  = dfs(curr: s, flow: INF)
            if tmpflow == 0 {
                break
            }
            totalFlow += tmpflow
        }
    }
    return totalFlow
}

이분 매칭

2021-06-22T00:00:00+00:00

정점을 두 그룹으로 나누었을 때 모든 간선에 연결된 두 정점이 서로 다른 그룹에 속하는 그래프를 이분 그래프라고 부른다. 이분 그래프에서 각 그룹의 정점이 1번씩만 연결될 수 있다고 했을 때 선택 할 수 있는 최대 간선의 수를 구하는 문제를 이분 매칭 문제라고 부른다.

예를 들어 4명의 사람이 있고 4종류의 사탕이 1개씩 있다고 했을 때 각 사람마다 선호하는 사탕이 있다고 하자. 그렇다면 최대한 많은 사람에게 선호하는 사탕을 나눠준다고 했을 때 몇 명이 선호하는 사탕을 받을 수 있는지를 구하는 문제를 생각해보자.

A : 1, 2, 3번 사탕을 먹고 싶어
B : 1, 2번 사탕을 먹고 싶어
C : 1번 사탕을 먹고 싶어
D : 4번 사탕을 먹고 싶어

먼저 문제를 이분 그래프로 표현하면 다음과 같다.

우리는 이를 구하기 위해 dfs를 활용한 풀이를 사용할 것이다. 핵심 아이디어는 왼쪽 그룹에서 하나씩 매칭할 수 있는 정점을 찾는데 매칭하고자 하는 정점이 이미 매칭되어 있다면 앞서 매칭을 마친 정점들을 다른 매칭으로 옮길 수 있다면 옮기고 매칭하고자 했던 정점끼리 연결시켜준다는 것이다.

만약 옮길 수 없다면 다른 정점을 찾아보고 연결 가능한 모든 정점에 대해 불가능하다면 왼쪽 그룹에서 해당 정점 순서를 넘어간다. 그림을 보며 이해해보자.

먼저 A를 매칭 시킬 수 있는 정점을 찾고 매칭시켜준다.

이제 B를 매칭 시킬 정점을 찾을 것이다. 그런데 첫번째로 확인한 정점이 1번 정점이다. 이는 이미 A와 매칭되어 있기 때문에 A로 돌아가서 A가 매칭시킬 수 있는 새로운 정점을 찾는다.

다행히 A는 2번과 매칭이 가능하기 때문에 A와 2번을 매칭시켜주고 B와 1번을 매칭 시켜준다.

이번에는 C차례인데 마찬가지로 이미 B가 매칭이 되어있다.

따라서 B를 2번과 매칭시켜주려하는데 이미 A와 매칭되어 있기 때문에 A와 다른 정점 매칭이 가능한지를 확인한다.

다행히 A와 3이 매칭이 가능하기 때문에 A와 3, B와 2, C와 1를 매칭시켜준다.

D의 경우 4번과 바로 매치가 가능하기 때문에 연결시켜주고 마무리 시킨다. 전체 매칭의 갯수는 4개로 문제의 답을 구할 수 있게 된다. 코드로 나타내면 다음과 같고 생각보다 간단하기 때문에 금방 이해할 수 있을 것이다.

let n = 4, m = 4
var visited:[Bool] = Array(repeating: false, count: m+1)
var match:[Int] = Array(repeating: -1, count: m+1)
var edge:[[Int]] = Array(repeating: [], count: n+1)
var maxMatch = 0

func dfs(indexA: Int) -> Bool {
    for e in edge[indexA] {
        if visited[e] {
            continue
        }
        visited[e] = true
        //visited란 이전 노드들을 새롭게 매칭시킬 때 피해야할 노드들을 가르킨다.
        
        if match[e] == -1 || dfs(indexA: match[e]) {
        //이미 match된 정점이 없거나 이미 match된 정점들이 다른 매칭을 선택할 수 있을 때
            match[e] = indexA
            return true
        }
    }
    return false
}

//edge에 대해서 따로 설정 필요

for i in 1...n {
    visited = Array(repeating: false, count: m+1)
    //visited는 매번 초기화 시켜줘야한다. (그래야 이전 정점들이 새로운 정점을 선택할 수 있다.)
    if dfs(indexA: i) {
        maxMatch += 1
    }
}

SCC (Strongly Connexted Component)

2021-06-22T00:00:00+00:00

강한 결합 요소란 서로 긴밀하게 연결된 그래프내의 집합을 의미한다. 여기서 긴밀하게 연결되어있다는 것은 서로 도달이 가능하다는 것을 의미한다. 즉, 같은 SCC내에 속하는 모든 두 정점은 서로를 향한 경로가 있다는 것이다. 만약 방향이 없다면 모든 정점은 서로를 향한 경로가 있을 것이기에 방향 그래프에서만 의미가 있다는 것을 알아두자. SCC를 구하는 알고리즘으로는 크게 코사라주와 타잔 알고리즘이 있다.

1. 코사라주 알고리즘

우리는 그래프를 정방향 그래프와 역방향 그래프 2개를 준비할 것이다. 역방향 그래프란 기존 그래프의 간선 방향을 정반대로 만든 그래프이다. 먼저 정방향 그래프에 대해 dfs를 해서 오일러 투어를 실행할 것이다.

오일러 투어란 간단하게 설명하자면 dfs로 그래프를 순회할 때 정점에 대해서 방문할 때 inOrder번호를 부여하고 빠져나올 때 outOrder번호를 부여하는 것을 말한다. 다음 그림을 보면 이해하기 쉬울 것이다.

실제로는 inOrder는 필요하지 않기 때문에 dfs를 빠져나올 때에만 order번호를 부여했다. finish time 순으로 노드를 저장해주는 ft 배열에 order가 작은 노드부터 저장을 시켜주었다.

DFS Front Function

func dfsF(n: Int) {
    check[n] = true
    for e in edgeF[n] {
        if !check[e] {
            dfsF(n: e)
        }
    }
    ft[index] = n
    index += 1
}

그 후 outOrder가 큰 순으로 역방향 그래프에서 dfs를 다시 시행시킨다. 앞에서 구한 ft 배열을 끝에서부터 차례대로 방문하면 된다. 이 때 하나의 노드에서 dfs로 방문하는 모든 노드들은 하나의 SCC가 된다. SCC배열은 각 노드별로 몇번째 SCC에 속하는지를 나타내주는 배열이다.

DFS Back Function

func dfsB(n: Int, scc: Int) {
    SCC[n] = scc
    for e in edgeB[n] {
        if SCC[e] == 0 {
            dfsB(n: e, scc: scc)
        }
    }
}

유의할 것은 dfsF 함수나 dfsB 함수가 한번 실행하면 모든 노드를 방문하는 것이 아니기 때문에 for문으로 아직 방문한 적이 없는 노드를 만날때마다 실행시켜줘야 한다는 것이다.

main 함수 중 일부

for i in 0..<n {
    if !check[i] {
        dfsF(n: i)
    }
}
//dfsF에서는 check 배열로 방문여부 확인
for i in 0..<n {
    let node = ft[n-1-i]
    if SCC[node] == 0 {
        scc += 1
        dfsB(n: node, scc: scc)
    }
}
//dfsB에서는 SCC번호가 노드에 부여되어있는지로 확인

위의 그래프에 SCC를 적용하면 다음과 같이 바뀐다.

놀라운 것은 SCC 집합을 하나의 노드로 보면 사이클이 없는 방향 그래프가 생성된다는 것이다. 또한 SCC 집합을 하나의 노드로 보았을 때 위상정렬에서 먼저 오는 노드는 SCC 번호 순으로도 먼저 오게된다. 이를 활용하여 SCC와 위상정렬이 결합된 문제들이 많이 나온다.

이제 코사라주가 만드는 SCC의 유효성에 대해 증명을 할 것이다. 코사라주가 만든 SCC가 유효하려면 번호가 늦게 생성된 SCC에서 먼저 생성된 SCC로 가는 edge가 존재하지 않음을 보이면 된다. 아까 위에서 구한 SCC 그래프에서 설명해보면 SCC3에서 SCC1나 2로 가는 edge가 없어야한다는 소리이다. 그렇다면 두 SCC간에 edge가 존재한다고 하자.

위 그림을 보면 back DFS를 하는 과정에서 SCC2를 먼저 방문할 것이다. 하지만 새롭게 추가된 빨간 간선에 의해 back DFS과정에서 SCC3까지 방문하게 된다. 따라서 SCC3이라는 집합이 존재하지 못하게 되고 가정이 모순이 되어서 SCC3에서 SCC2로 가는 간선은 존재할 수 없다는 결론이 나오게 된다. 이로써 코사라주 알고리즘의 유효성이 증명되었다.

코사라주 전체 코드

var edgeF:[[Int]] = []
var edgeB:[[Int]] = []
var check:[Bool] = []
var ft:[Int] = []
var index = 0, scc = 0
var SCC:[Int] = []

func dfsF(n: Int) {
    check[n] = true
    for e in edgeF[n] {
        if !check[e] {
            dfsF(n: e)
        }
    }
    ft[index] = n
    index += 1
}

func dfsB(n: Int, scc: Int) {
    SCC[n] = scc
    for e in edgeB[n] {
        if SCC[e] == 0 {
            dfsB(n: e, scc: scc)
        }
    }
}

for i in 0..<n {
    if !check[i] {
        dfsF(n: i)
    }
}

for i in 0..<n {
    let node = ft[n-1-i]
    if SCC[node] == 0 {
        scc += 1
        dfsB(n: node, scc: scc)
    }
}

2. 타잔 알고리즘

이번에는 코사라주와 조금 다른 타잔 알고리즘에 대해 설명하겠다. 핵심 개념은 dfs로 하나씩 정점을 방문하면서 stack에 노드를 집어넣을 것인데 부모라는 정보를 활용해서 SCC를 구한다는 것이다. 다음 그림을 보면서 이해해보자.

먼저 1번 정점부터 순차적으로 dfs를 해서 4번으로 이동한다. 이 때 처음에 모든 정점은 부모로 자기 자신을 가리키도록 한다.

4번에서 2번을 바라봤을때 SCC그룹에 속해있지 않고 방문한 적이 있는 정점이기 때문에 해당 정점의 부모값과 본인의 부모값을 비교해서 더 작은 값을 본인의 부모로 삼아준다.

그 후 더이상 새 경로를 탐색할 수 없으므로 가지고 있던 부모값을 return 한다. 3번 노드는 return 받은 부모값이 본인이 갖고 있는 값보다 작으므로 부모값을 2로 바꿔준다.

3번은 추가적인 경로가 존재하므로 경로를 타고 들어가 7번 정점까지 방문한다.

7에서 5를 바라봤을때 위와 동일하게 부모값을 변경하고 반환해준다. 그 결과 5까지 돌아가게 되는데 5는 부모값과 본인이 동일하기 때문에 스택에서 본인이 나올때까지 pop해준다.

5, 6, 7이 하나의 그룹이 되고 마찬가지로 3에서 2로 돌아간다. 2도 부모와 본인이 동일하기 때문에 stack에서 pop해준다.

2, 3, 4가 하나의 그룹이 되고 마찬가지로 1도 동일하게 처리해준다.

최종적으로 코사라주와 동일한 SCC 그래프를 얻게된다. 다만 코사라주와 반대로 위상 정렬에서 마지막에 처리해야 할 SCC가 먼저 얻어진다.

유효성을 증명해보자면 코사라주와 동일하게 7 -> 4로 가는 선분이 있다고 생각했을 때 알고리즘을 계산해보면 두 SCC 그룹이 결국에는 하나가 되야하고 서로다른 SCC 그룹이라는 가정에 어긋나기 때문에 타잔의 알고리즘이 유효하다는 것을 증명할 수 있다.

타잔 전체 코드

let n = 2000
var edge:[[Int]] = Array(repeating: [], count: n)
var visited:[Int] = Array(repeating: 0, count: n)
var finished:[Bool] = Array(repeating: false, count: n)
var index = 1
var SCC:[[Int]] = []
var NodeSCC:[Int] = Array(repeating: -1, count: n)
var stack:[Int] = []

func dfs(n: Int) -> Int {
    visited[n] = index
    index += 1
    stack.append(n)
    var parent = visited[n]
    for e in edge[n] {
        if visited[e] == 0 {
            parent = min(parent, dfs(n: e))
        }
        else if !finished[e] {
            parent = min(parent, visited[e])
        }
    }
    if parent == visited[n] {
        var tmpScc:[Int] = []
        let count = SCC.count
        while !stack.isEmpty {
            let tmpNode = stack.popLast()!
            tmpScc.append(tmpNode)
            finished[tmpNode] = true
            NodeSCC[tmpNode] = count
            if tmpNode == n {
                break
            }
        }
        SCC.append(tmpScc)
    }
    return parent
}

for i in 0..<n {
    if visited[i] == 0 {
        dfs(n: i)
    }
}

3. 2-SAT

다음과 같은 논리식이 주어진다고 했을 때

f = (x₁ V x₂) Λ (x₁ V ~x₂) Λ (~x₁ V x₃) Λ (~x₁ V ~x₃)

해당 논리식이 참이되는 해가 존재하는지, 그렇다면 그 해는 무엇인지 구할 때 2-SAT 문제를 푼다고 한다.

여기서 각 원소는 bool 값을 가지며 V는 or를 의미하고 Λ은 and를 의미한다. (x1 V x2)라는 원소의 의미는 전체 식이 참이 되기 위해서 x₁이 false라면 x₂가 true가 되거나 x₂가 false라면 x₁이 참이 되어야 함을 의미한다. 따라서 두 x값 간에 선행조건이 생기게 되고 이는 위상정렬 문제로 생각할 수 있다.

false를 표현하기 위해서 우리는 등장하는 모든 x_n에 대해 true node와 false node 2개를 생성해준다. 예를 들자면 ~x₁ -> x₂ 로 간선을 긋고 ~x₂ -> x₁로 간선을 그어준다. 이를 식에 등장하는 모든 관계에 대해 간선을 그어준다.

간선 설정 코드

for _ in 0..<m {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    var N1 = line[0], N2 = line[1]
    N1 = (N1 < 0 ? -(2*N1) : 2*N1-1)
    N2 = (N2 < 0 ? -(2*N2) : 2*N2-1)
    edge[makeNot(n: N1)].append(N2)
    edge[makeNot(n: N2)].append(N1)
}
//makeNot은 x값에 대해서 다른 부호를 갖는 노드로 바꿔주는 역할을 한다. true -> false / false -> true

그래프를 성공적으로 만들었다면 주어진 논리그래프에 대해 SCC를 구한다. 만약 하나의 SCC에 x₁와 ~x₁가 모두 속한다고 생각해보자. 그럴 경우 x₁은 true도 되야하고 false도 되야한다. 따라서 모든 x값에 대해서 true 노드와 false 노드가 한 SCC에 속하지 않는지를 확인하면 f라는 식을 참으로 만드는 해가 존재하는지 확인할 수 있다.

실제 해를 구하고자 한다면 위상정렬 상에서 앞에 오는 SCC부터 차례대로 그 해를 구하면 된다. 각 x에 대해서 true 노드가 먼저 등장하면 그 해를 false로 false 노드가 먼저오면 x값을 true로 설정한다.

이 부분이 참 중요한데 선행 조건이 없다면 bool식을 false로 만들도록 해야한다. (x1 V x2)라는 조건과 ~x₁ -> x₂라는 간선을 다시 생각해보자. 이 간선의 의미는 x₁이 false가 되버린다면 x₂는 무조건 참이여야 한다는 것을 의미한다고 했다.

그렇다면 x₁이 true가 되버린다면? x₂가 무엇이 오든 아무 문제가 없는 것이다. 따라서 그래프 상에서 선행 조건이 없는 노드를 만난다면 해당 노드를 false가 되도록 설정해주면 뒤에 등장하는 조건식에 아무런 영향을 미치지 않기 때문에 적합한 해를 찾을 수 있다.

2-SAT 전체 코드

let n = 20, m = 10
var edge:[[Int]] = Array(repeating: [], count: 2*n)
var visited:[Int] = Array(repeating: 0, count: 2*n)
var finished:[Bool] = Array(repeating: false, count: 2*n)
var NodeSCC:[Int] = Array(repeating: 0, count: 2*n)
var index = 1
var SCC:[[Int]] = []
var stack:[Int] = []

for _ in 0..<m {
    let line = readLine()!.split(separator: " ").map{Int(String($0))!}
    var N1 = line[0], N2 = line[1]
    N1 = (N1 < 0 ? -(2*N1)-1 : 2*(N1-1))
    N2 = (N2 < 0 ? -(2*N2)-1 : 2*(N2-1))
    edge[NotOper(n: N1)].append(N2)
    edge[NotOper(n: N2)].append(N1)
}
//조건식 간선 설정 코드

for i in 0..<2*n {
    if visited[i] == 0 {
        dfs(n: i)
    }
}
//SCC생성

var possible = true
for i in 0..<n {
    if NodeSCC[2*i] == NodeSCC[2*i+1] {
        possible = false
        break
    }
}
//참이 되는 해 존재 여부 파악

var result = Array(repeating: -1, count: n)
if possible {
    for i in 0..<SCC.count {
        let currentSCC = SCC[SCC.count-1-i]
        for s in currentSCC {
            if result[s/2] == -1 {
                result[s/2] = s%2
            }
        }
    }
}
//최종 해 계산

func dfs(n: Int) -> Int {
    visited[n] = index
    index += 1
    stack.append(n)
    var parent = visited[n]
    for e in edge[n] {
        if visited[e] == 0 {
            parent = min(parent, dfs(n: e))
        }
        else if !finished[e] {
            parent = min(parent, visited[e])
        }
    }
    if parent == visited[n] {
        var tmpScc:[Int] = []
        let count = SCC.count
        while !stack.isEmpty {
            let tmpNode = stack.popLast()!
            tmpScc.append(tmpNode)
            finished[tmpNode] = true
            NodeSCC[tmpNode] = count
            if tmpNode == n {
                break
            }
        }
        SCC.append(tmpScc)
    }
    return parent
}

func NotOper(n: Int) -> Int {
    return (n%2 == 0 ? n+1 : n-1)
}

위상 정렬

2021-06-22T00:00:00+00:00

우리는 일상에서 일의 순서를 정해야 할 때가 있다. 예를 들어 프린터에서 종이를 뽑는다하면 프린터를 설치한다 -> 종이를 넣는다 -> 컴퓨터에서 출력 버튼을 누른다 와 같이 순서를 정할 때가 많다. 만약 어떤 일을 할 때 선제 조건이 필요하다면 그 조건들에 맞춰서 일의 순서를 짜는 것이 중요하다.

만약 위와 같은 그래프가 주어졌을 때 화살표의 의미는 뒤의 노드를 방문하기 전에 앞의 노드를 처리해야한다는 뜻이라고 하자. 그렇다면 우리는 어떤 순서로 노드를 방문해야 할것인가에 대해 정해주는 알고리즘이 바로 위상정렬이다. 여기서는 큐를 활용한 위상정렬 방법에 대해 설명하겠다.

모든 노드에 대해 본인을 가르키는 간선이 몇개 있는지 inDegree 배열에 저장한다.
inDegree 배열의 값이 0인 모든 노드를 queue에 넣어둔다.
큐를 하나씩 pop하면서 꺼내진 노드와 연결된 모든 간선의 inDegree 값을 1씩 뺀다.
이 때 배열값이 0이 된다면 queue에 집어넣는다.
3-4를 큐가 빌때까지 반복한다.

실제 구현도 간단하기 때문에 쉽게 이해할 수 있을 것으로 생각된다. 위상정렬 알고리즘은 사이클이 없는 방향 그래프(DAG)에서만 사용 가능하다는 것을 명심하자. 시간 복잡도는 모든 정점과 간선을 한번씩 살펴보므로 O(V+E) 에 해당한다.

Topological Sorting Code

var queue:[Int] = []
for i in 1...n {
    if inDegree[i] == 0 {
        queue.append(i)
    }
}

while !queue.isEmpty {
    let node = queue.removeFirst()
    print(node)
    for e in edge[node] {
        inDegree[e] -= 1
        if inDegree[e] == 0 {
            queue.append(e)
        }
    }
}

LCA (Lowest Common Ancestor)

2021-06-22T00:00:00+00:00

최소 공통 조상으로 두 정점의 가장 가까운 공통 조상을 찾는 알고리즘을 말한다. 다음 그림을 보면 6과 8의 LCA는 2고 9와 10의 LCA는 1이다.

만약 두 정점이 존재한다면 둘의 depth를 동일하게 맞춰주고 하나씩 부모로 거슬러 올라가면서 둘의 부모가 같은 지점을 찾아주면 될 것이다. 하지만 이렇게 구현을 할 경우 최대 O(n) 의 시간이 걸리게 된다.

이 시간을 단축하기 위해 우리는 각각의 노드별로 부모가 누군지를 저장할 것인데 이 때 2⁰번째 부모, 2¹번째 부모, 2²번째 부모, 2³번째 부모 이런식으로 2의 제곱수에 해당하는 위치의 부모에 대해서 저장할 것이다. 이렇게 해주는 이유는 이분탐색과 비슷하게 동작하도록 위함이다. 구현하는 방법은 어떤 노드의 2ⁿ 부모는 그 노드의 1번째 부모의 2^n-1와 같다는 것을 이용한다.

DFS를 이용해 parent 정보를 포함한 tree 만들기

func dfs(n: Int, p: Int) {
    depth[n] = depth[p] + 1
    check[n] = true
    parent[n][0] = p
    for i in 1...maxK {
        parent[n][i] = parent[parent[n][i-1]][i-1]
    }
    //이 부분이 parent에 대해 저장하는 부분이다.
    for e in edge[n] {
        if !check[e] {
            dfs(n: e, p: n)
        }
    }
}

이제 부모의 정보가 저장되어 있다고 했을 때 두 정점의 LCA를 구하고자 한다. 이 때 먼저 depth가 큰 노드를 작은 노드에 맞춰 부모로 이동시킬 것인데 만약 두 노드의 depth 차이가 7이라면 4번째 부모로 이동 -> 2번째 부모로 이동 -> 1번째 부모로 이동 하는 방식을 택하면 depth를 동일하게 맞출 수 있다.

Depth 동일화 code

for i in 0...maxK {
    if depth[a] <= depth[parent[b][maxK-i]] {
        b = parent[b][maxK-i]
    }
}

그 후 두 노드가 동일하다면 한쪽이 다른쪽의 부모가 되는 경우로 해당 노드를 return해주면 된다.

그렇지 않을 경우 2의 제곱수에 해당하는 부모들을 제곱수가 큰 부모부터 하나씩 비교해가면서 두 개의 부모가 다르다면 해당 위치로 노드를 옮겨가면서 계속 비교하는 방식을 사용한다. 최종적으로 변경된 노드의 위치는 LCA의 child node에 해당하기 때문에 첫번째 부모를 return 해주면 된다.

부모 노드 비교 code

if a == b {
    return a
}
for i in 0...maxK {
    if parent[a][maxK-i] != parent[b][maxK-i] {
        a = parent[a][maxK-i]
        b = parent[b][maxK-i]
    }
}
return parent[a][0]

MST (Minimum Spanning Tree)

2021-06-22T00:00:00+00:00

Spanning Tree (신장 트리) 란 원래 그래프 중 모든 노드가 연결되어 있으면서 트리의 속성을 만족하는 그래프이다. 1개의 그래프에 대해서 여러개의 신장 트리가 나올 수 있다. MST란 만약 간선에 가중치가 있을 때 가중치의 합이 최소가 되는 spanning tree를 의미한다.

구하는 방법으로는 크게 크루스칼 알고리즘과 프림 알고리즘이 존재한다. 최단 경로와 헤깔릴 수 있는데 MST는 트리를 만드는데 드는 최소 비용인 것이고 최단 경로는 정점에서 다른 정점으로 가는 최단 비용을 찾는 것이기 때문에 다르다.

1. 크루스칼 알고리즘

그리디 알고리즘의 하나로 union-find을 사용해 트리를 만드는 기법이다.

모든 정점을 하나의 독립적인 집합으로 만든다.
모든 간선을 비용 순으로 정렬한다. 
작은 비용부터 간선을 보는데 간선의 양 끝 점이 서로 다른 집합에 속할 경우 두 집합을 union 시킨다.

그림을 보면 알겠지만 4번째 순서로 D와 E를 잇는 가중치 5의 간선은 이미 D와 E가 같은 집합에 속해있어서 skip이 되었다.

크루스칼 code

edge.sort(by: {$0.d < $1.d})
var i = 0, totalCost = 0
while i < edge.count {
    let current = edge[i]
    i += 1
    if !disjoint.union(current.0, current.1) { //두 점이 같은 집합에 속할 시
        continue
    }
    else {
        totalCost += current.d
    }
}

2. 프림 알고리즘

그리디 알고리즘의 하나로 하나의 정점으로부터 시작해 가장 작은 비용을 갖는 간선을 확장해나가는 방식이다.

임의의 정점을 선택하여 리스트에 넣은 후 연결된 모든 간선을 min heap에 삽입
가장 가중치가 작은 간선을 꺼내고 간선 set에서 제거
간선의 인접 점이 list에 들어있지 않다면 해당 점을 list에 추가하고 연결된 모든 간선을 min heap에 삽입.
살펴볼 간선이 없을때까지 2-3 반복

프림 code

minHeap.insert((node: 0, cost: 0))
var totalCost = 0
while !minHeap.isEmpty {
    let current = minHeap.pop()!
    if check[current.node] {
        continue
    }
    totalCost += current.cost
    check[current.node] = true
    for e in edge[current.node] {
        if check[e] {
            continue
        }
        else {
            minHeap.insert((e, cost[current.node][e]))
        }
    }
}

최단 경로

2021-06-22T00:00:00+00:00

가중치가 있는 그래프가 주어지면 정점 u와 정점 v로 연결하는 경로 중 간선들의 가중치 합이 최소가 되는 경로를 찾는 알고리즘이다. 최단 경로를 구하는 알고리즘으로는 다익스트라, 벨만포드, 플로이드 와샬 3가지의 알고리즘이 존재한다.

1. Dijkstra Algorithm

하나의 정점에서 다른 모든 정점들로의 최단 경로를 찾고자 할 때 사용할 수 있는 알고리즘이다. 다익스트라를 사용하려면 간선들의 weight 값은 음의 값을 가질 수 없다는 특징이 있다.

위의 그림을 예시로 설명할 것이다. 먼저 시작 정점으로부터 다른 정점까지 걸리는 최단 경로의 값을 dist 라고 부르는 배열에 저장해 둘 것이다. 모든 정점으로의 최단 경로를 INF로 설정해놓고 시작 정점의 최단 경로는 0으로 설정해놓자. 그렇다면 0을 시작 정점으로 잡은 dist 배열은 다음과 같다.

이제 다음의 방법을 반복적으로 수행해서 배열을 채워나갈 것이다.

dist배열에서 선택하지 않은 정점 중에 가장 작은 값을 가지는 정점을 선택한다.
해당 정점과 연결된 모든 정점들의 dist값을 최솟값으로 update 해준다.
update는 다음 식을 따른다. min(dist[v], dist[u] + weight[u][v])

순서대로 표를 채우면 다음과 같다.

만약 p라는 정점이 가장 작은 최단 경로값을 가져서 선택이 되었다고하자. 이후에 q라는 정점이 선택이 되었을 때 p로 향하는 경로가 있다면 p의 dist값이 update될 것이다.

하지만 q는 p보다 나중에 선택이 됬기 때문에 dist[p] ≤ dist[q] 이다. weight의 값은 음이 아니라고 했으므로 p의 최단 경로값이 update 될 일이 없다. 따라서 다익스트라 알고리즘의 유효성을 확인할 수 있다.

이 때 dist배열에서 가장 작은 값을 가지는 정점을 선택하는 과정을 일일히 확인하면 시간이 오래 걸린다. 따라서 앞에서 공부한 min heap을 활용하여 가장 작은 최단 경로를 갖는 노드들을 찾아 줄 것이다.

min heap을 활용하면 시간 복잡도는 heap에 O(E) 개의 점이 들어갈 수 있고 매번 heap에서 최솟값을 꺼낼때마다 O(logE) 의 시간이 걸리므로 O(ElogE) 가 걸리게 된다. E ≤ V² 이므로 최종 시간복잡도는 O(ElogV) 이다.

Dijkstra Code

var PQ = PriorityQueue()
PQ.insert((startNode,0))
Dist[startNode] = 0
while !PQ.isEmpty {
    let current = PQ.pop()!
    let currentIndex = current.0, currentDist = current.1
    for i in 0..<Edge[currentIndex].count {
        let nextIndex = Edge[currentIndex][i].0, nextWeight = Edge[currentIndex][i].1
        if Dist[nextIndex] > currentDist + nextWeight {
            Dist[nextIndex] = currentDist + nextWeight
            PQ.insert((nextIndex, currentDist + nextWeight))
        }
    }
}

2. Bellman-Ford Algorithm

다익스트라와 마찬가지로 한 정점에서 다른 모든 정점으로의 최단 경로를 찾고자 한다고하자. 이 때 이번에는 음의 가중치를 갖는 간선이 존재한다고 하자. 이럴 경우 다익스트라는 사용할 수 없게되고 새로운 방법이 필요하게 된다.

모든 dist 값을 INF로 만들고 시작 정점만 0을 입력한다.
모든 간선에 대해 dist 값을 업데이트 해준다. 이 때 간선의 시작 정점의 dist값이 INF인 경우는 생략한다.
2를 V-1번 반복한다.
2를 1번 더 시행하는데 dist값이 하나라도 바뀐다면 음의 cycle이 존재한다는 의미이다.

핵심 아이디어는 사이클이 존재하지 않는다면 V개의 정점이 있을 때 최단 경로는 최대 V-1개의 정점을 거친다는 것이다. 따라서 모든 간선을 V-1번 살펴보게 되면 최단 경로를 전부 찾을 수 있다. 만약 음의 사이클이 존재할 경우 모든 간선을 1번 더 살펴봤을때 값이 변할 것이다.

실제 예시를 들어 벨만포드를 사용한 결과이다. 간선의 업데이트 순서는 항상 5 -> 4 -> -3 -> 7 -> 2 -> 6 의 가중치를 가진 간선을 사용한다고 하자. 추가로 다익스트라 알고리즘을 사용하면 다른 결과가 나온다는 것을 직접 확인해보면 좋다.

전체 시간 복잡도는 E개의 간선을 V-1번 봐야하므로 O(VE) 가 된다. 따라서 속도는 다익스트라가 더 빠르기 때문에 상황에 맞게 알고리즘을 선택하는 것이 중요하다.

Bellman-Ford Code

Dist[1] = 0
for _ in 1..<n {
    for i in 1...n {
        if Dist[i] == INF {
            continue
        }
        for e in Edge[i] {
            Dist[e.0] = min(Dist[e.0], Dist[i] + e.1)
        }
    }
}

//음의 cycle 확인
var cycle = false
for i in 1...n {
    if Dist[i] == INF {
        continue
    }
    for e in Edge[i] {
        if Dist[e.0] > Dist[i] + e.1 {
            cycle = true
            break
        }
    }
}

3. Floyd Warshall Algorithm

우리는 여지껏 한개의 정점에서 다른 모든 정점으로의 최단 경로를 구하는 알고리즘을 살펴보았다. 만약 모든 정점에 대해서 모든 정점으로의 최단 경로를 알고 싶다면 모든 정점에 대해 다익스트라 알고리즘을 적용할 수도 있겠다. 하지만 그렇게 될 경우 O(VElogV) 의 많은 시간이 소요된다.

그보다 적은 시간인 O(V³) 만에 최단 경로를 구할 수 있는 알고리즘이 바로 플로이드 와샬이다. 이번에는 앞에와 다르게 2차원 배열을 만들 것이다. 2차원 배열의 arr[1][2] 의 의미는 1번 정점에서 2번 정점으로 가는 최단 경로를 의미한다.

이 때 1 -> 2 로 이동하는 최단경로가 1 -> 3 -> 2 라고 해보자. 그렇다면 1 -> 2로 가는 최단 경로는 1 -> 3으로 가는 최단경로에 3 -> 2로가는 최단경로를 합친것과 같다. 이를 응용하여 모든 두 정점간에 최단 경로를 구하는 문제를 중간 경로를 거쳐 가는 문제로 나누어 구하는 것이다. 핵심 알고리즘은 다음과 같다.

배열의 모든 값을 INF로 설정한 뒤 알고있는 간선 값을 이용해 배열을 업데이트 한다.
자기 자신으로의 최단 경로는 0으로 설정한다.
모든 두 정점쌍에 대해 최단 경로를 구해줄 것인데 중간경로로 다른 모든 정점을 설정하고 최솟값을 찾아준다.

예시를 들어보면 다음과 같다.

이 때 1 -> 3으로 가는 최단 경로를 구하는 방법은 2와 4를 각각 중간경로로 하는 방법이 존재한다.

이렇게 모든 정점쌍에 대해서 최솟값을 구해주면 모든 정점쌍의 최단 경로를 구해낼 수 있다. 플로이드 와샬은 벨만 포드와 마찬가지로 음의 가중치를 가지는 간선이 있어도 값을 구해낼 수 있다.

만약 음의 사이클이 존재한다면 자기 자신으로의 경로가 음의 값이 존재하게 되므로 쉽게 파악할 수 있다. 양의 사이클을 알아내고 싶다면 자기 자신으로의 최단 경로를 INF로 설정하면 쉽게 파악할 수 있다.

시간 복잡도는 V²개의 정점 쌍에 대해서 V개의 중간 경로를 확인해야 하므로 O(V³)이 된다.

Floyd Warshall Code

for i in 1...n {
    for j in 1...n {
        for k in 1...n {
            if k == i || k == j {continue}
            Edge[j][k] = min(Edge[j][k], Edge[j][i] + Edge[i][k])
        }
    }
}

Segment Tree

2021-06-22T00:00:00+00:00

배열의 구간에 대한 합이라던지 가장 큰 값이라던지를 구하려면 그동안은 매번 구간 전체를 보면서 처리해줘야 했었다. 이렇게 될 경우 O(n) 의 시간이 매번 걸리게 된다. segment tree는 이런 구간에 대한 작업을 O(logn) 만에 해낼 수 있게 도와주는 자료구조이다. 세그먼트 트리를 사용하기 위해 배열을 이진 트리의 형태로 변화를 시킬 것이다. 다음 그림을 보자.

주어진 이진 트리의 각 노드는 배열의 각 구간을 나타내고 있다. 만약 우리가 3-7 구간을 보고 싶다면 3 과 4-7 구간에 해당하는 노드를 살펴보면 된다. 그렇다면 어떻게 구현을 해야할까? 먼저 우리는 트리의 시작 index를 0이 아닌 1로 설정해줄 것이다. 이렇게 해주는 이유는 좌측 child와 우측 child를 찾아갈 때 현재 노드의 2node 와 2node+1로 표현이 되어서 간단하기 때문이다.

한가지 유의할 점은 segment tree의 전체 배열 길이는 넣고자 하는 원래 배열의 구간 길이보다 크거나 같은 2의 제곱수의 2배로 설정한다는 점이다. 예를들어 5~8 의 길이를 가질 수 있다고 한다면 가장 가까운 2의 제곱수는 8이 되고 그 2배인 16 만큼의 길이를 갖는 배열이 필요하게 된다. 단 기존 길이에 4배를 해서 사용해도 무방하다고 알려져있기 때문에 본인의 스타일에 맞게 구현하면 된다.

이 앞에서부터는 구간합을 구하는 segment tree를 가지고 설명을 할 것이다. 만약 구간합이 아닌 다른 것을 구하려고 한다면 함수의 내부 구현이 달라질 수 있다는 것을 명심하고 보길 바란다.

1. MakeTree

이 함수는 맨처음에 호출해서 기존 배열로부터 세그먼트 트리를 만들어주는 함수이다. 각 노드에는 해당하는 구간의 구간합이 저장되어있다. 우리는 start와 end, 그리고 node라는 변수를 활용할 것이다. arr은 기존 배열, seg는 새롭게 만든 트리 배열이라는 것을 알고 다음 코드를 보길 바란다.

makeTree Function

mutating func makeTree(start: Int, end: Int, node: Int) -> Int {
    if start == end {
        seg[node] = arr[start]
        return seg[node]
    }
    let mid = (start+end)/2
    let l = makeTree(start: start, end: mid, node: 2*node)
    let r = makeTree(start: mid+1, end: end, node: 2*node+1)
    seg[node] = l+r
    return seg[node]
}

먼저 start와 end에는 현재 위치한 노드의 구간을 나타내주고 node는 seg에서의 index가 들어있다. 만약 우리가 0-7 구간을 나타내주는 root node에 위치해있다면 start = 0, end = 7, node = 1인 상태일 것이다. 만약 start와 end가 같아진다면 현재 leaf 노드에 해당한다는 것이고 arr 배열에서의 값을 입력해주면 된다.

그러나 leaf가 아닐경우 길이가 2이상인 구간에 해당한다. 위의 그림을 보면 구간의 정중앙값을 기준으로 구간이 나뉘어서 왼쪽 child와 오른쪽 child가 생성된다는 것을 알 수 있다. 따라서 mid 값을 기준으로 구간을 나눠 각 구간에 대해 재귀적으로 구간합을 설정해주고 그 결과의 합을 현재 노드에 저장시켜주도록 구현한다. 만약 구간합이 아니라 다른 것을 구하는 문제라면 그에 맞는 처리를 해주면 된다.

2. Find

이 함수는 구간을 주면 해당 구간의 값을 구해주는 함수이다. 위의 makeTree와 똑같이 start, end, node 변수를 쓰고 추가적으로 어떤 구간의 구간합을 구할것인지 알려주는 left, right 변수를 사용한다.

find Function

mutating func find(start: Int, end: Int, node: Int, left: Int, right: Int) -> Int {
    if left > end || start > right {
        return 0
    }
    if left <= start && end <= right {
        return seg[node]
    }
    let mid = (start+end)/2
    let l = find(start: start, end: mid, node: 2*node, left: left, right: right)
    let r = find(start: mid+1, end: end, node: 2*node+1, left: left, right: right)
    return l+r
}

이 때 찾고자 하는 구간과 현재 구간이 아예 겹치지 않는다면 0을 return하고 찾고자 하는 구간에 완벽히 포함되면 그 때의 seg[node] 값을 return 해준다. 만약 구간이 일부는 겹치고 일부는 겹치지 않는다면 왼쪽, 오른쪽으로 나눠서 각각 구해준다. 만약 3-7을 구한다고 하면 0-7 root 구간은 0-3과 4-7로 나뉘어지고 4-7은 완벽하게 일치하기 때문에 값을 return 해주고 0-3 구간은 계속 구간이 쪼개져서 3 구간을 찾아가게 되는 것이다. 탐색하는 깊이가 최대 logn 이기 때문에 시간 복잡도는 O(logn) 이 소요된다.

3. Update

만약 원래 배열에서 값이 변경된다고 하자. 그 경우 해당 index를 포함하는 모든 구간은 값이 변경되야 할 것이다. 여기서는 구간합이기 때문에 위에서부터 찾아 내려가면서 노드의 구간에 변경하고자하는 index가 포함되어 있다면 값을 변경해주도록 구현이 되어있다. 하지만 구간합이 아닌 다른 경우에는 형태가 달라질 수 있으므로 유의하자. 마찬가지로 탐색하는 깊이가 최대 logn 이기 때문에 O(logn) 의 시간이 소요된다.

update Function

mutating func update(start: Int, end: Int, node: Int, index: Int, val: Int) {
    if index < start || index > end {
        return
    }
    seg[node] += val
    if start == end {
        return
    }
    let mid = (start+end)/2
    update(start: start, end: mid, node: 2*node, index: index, val: val)
    update(start: mid+1, end: end, node: 2*node+1, index: index, val: val)
}

4. Lazy Propagation

그런데 업데이트 함수를 사용해서 구간을 업데이트 했지만 해당 변경점을 단 한번도 부르지 않을 경우 update를 하기위해 모든 노드를 변경해주는 것이 낭비일 수 있다. 다른 경우로는 update함수를 굉장히 많이 호출한다고 하자. 하지만 정작 find 함수는 마지막에 단 한번 일어난다고 했을 때 그동안 모든 노드를 update마다 수정해주는 것은 연산 낭비이다.

이를 해결하기 위해서 lazy propagation 이라는 개념이 도입되었다. 이는 update가 들어왔을 경우 update를 밑의 노드로 전파하지 않고 쌓아두는 방식이다. 만약 밑의 노드를 호출할 일이 생길 경우 그 때 누적된 update들을 한번에 전파해준다. 이렇게 될 경우 쓸모없는 구간에 대한 update로 인한 연산 낭비를 방지할 수 있게 된다. 이제 우리는 lazy라는 새로운 배열을 하나 더 쓸 것인데 이는 해당 노드로 전파되어야할 update 값들을 쌓아두는 배열이다.

updateLazy Function

func updateLazy(start: Int, end: Int, node: Int) {
    if lazy[node] != 0 {
        seg[node] += lazy[node]*(end-start+1)
        if start != end {
            lazy[2*node] += lazy[node]
            lazy[2*node+1] += lazy[node]
        }
        lazy[node] = 0
    }
}

함수를 보면 알겠지만 lazy update는 update나 find 함수에서 해당 노드를 처음 방문했을 경우 쌓여있는 값을 업데이트 해주는 함수이다. 만약 노드를 업데이트 했다면 노드에 연결된 왼쪽 자식과 오른쪽 자식에게도 lazy 값을 전파해주고 본인의 lazy값은 0으로 만들어야 한다는 것을 명심하자. lazy를 적용하면 find와 update 함수도 변화한다는 것을 명심하자.

5. Fenwick Tree

이번에는 segment tree와 유사하게 구간에 대한 결과를 얻을 수 있는 두번째 구조인 fenwick tree에 대해서 알아볼 것이다. segment와 마찬가지로 구간 query 구하기와 update 모두 O(logn) 이 걸리는 효율적인 자료구조이다. segment와 차이점으로는 n개의 길이를 갖는 배열만 필요하기 때문에 seg보다 공간 복잡도가 작다는 장점이 있다.

위의 그림은 fenwick tree를 실제로 만든 모습이다. 파란색으로 되어있는 부분이 fenwick tree이다. 이 때 써져있는 번호는 array에서의 index를 의미한다. 예를들어 12번 index는 기존 배열에서 9-12번 구간에 대한 결과가 들어있다. 한가지 유의할 점으로는 fenwick에서의 index가 주어지면 그 구간에는 반드시 해당 index를 포함하고 있다는 것이다.

Fenwick Find

fenwick 함수는 find와 update로 구성이 된다. find에 대해서 먼저 알아보자. 만약 우리가 1-13 구간에 대해서 알고 싶다고 하자. 그렇다면 우리는 8번과 12번과 13번 노드를 택하면 된다. 이 때 13 -> 12 -> 8 으로 넘어갈때 이진법으로 표현하면 1101 -> 1100 -> 1000 이 된다. 그런데 유심히 보면 맨 끝에 존재하는 1값이 하나씩 사라지는 것을 확인할 수 있다. 맨 우측에 존재하는 1을 나타내기 위해서는 (index & -index)로 표현하는데 이는 signed bit를 고려해서 이진법으로 숫자를 나타내보면 간단하니 한번 생각해보길 바란다.

func fenwick_find(tree: [Int], idx: Int) -> Int {
    var res = 0
    var index = idx
    while index > 0 {
        res += tree[index]
        index -= (index & -index)
    }
    return res
}

따라서 fenwick find 함수는 위와 같다. 만약 구간 7-11을 구하고 싶다면 11에 대한 find를 구한 후 6에 대한 find를 빼주면 7-11 구간에 대해 구할 수 있다.

Fenwick Update

이번에는 값을 업데이트 해줄 것이다. 만약 우리가 index 9에 값을 변경했다고하자. 그렇다면 해당 정보는 9를 구간으로 포함하는 모든 노드에 대해서 업데이트가 이루어져야 할 것이다. 예시를 보면 9 -> 10 -> 12 -> 16에 해당하고 이진법으로 나타내면 1001 -> 1010 -> 1100 -> 10000 이 된다. 그런데 자세히 보면 find와 비슷하게 맨 마지막 1이 존재하는 자리에 1을 더해준 형태로 증가하고 있다는 것을 확인할 수 있다. 따라서 간단하게 코드를 짜보면 다음과 같다.

func fenwick_update(tree: inout [Int], idx: Int, val: Int) {
    var index = idx
    while index <= n {
        tree[index] += val
        index += (index & -index)
    }
}

fenwick : 시간복잡도 O(logn) / 공간복잡도 O(n)
segment : 시간복잡도 O(logn) / 공간복잡도 O(4n)

위의 결과를 보면 fenwick이 메모리도 덜 잡아먹고 구현 자체도 간단하기 때문에 fenwick을 쓰는게 무조건 좋다고 생각할 수 있다. 하지만 fenwick은 구간내 최댓값, 최솟값을 구하기 등 몇몇 문제의 경우 사용할 수가 없다. 즉 다양한 case에 적용하기가 segment보다 어렵다는 것이다. 둘 다 장단점이 있으므로 우리는 상황에 맞는 자료구조를 선택하는 것이 중요하다.

Segment Tree 전체 코드

struct Segment {
    var arr = [Int]()
    var seg = [Int]()
    mutating func makeTree(start: Int, end: Int, node: Int) -> Int {
        if start == end {
            seg[node] = arr[start]
            return seg[node]
        }
        let mid = (start+end)/2
        let l = makeTree(start: start, end: mid, node: 2*node)
        let r = makeTree(start: mid+1, end: end, node: 2*node+1)
        seg[node] = l+r
        return seg[node]
    }
    mutating func find(start: Int, end: Int, node: Int, left: Int, right: Int) -> Int {
        if left > end || start > right {
            return 0
        }
        if left <= start && end <= right {
            return seg[node]
        }
        let mid = (start+end)/2
        let l = find(start: start, end: mid, node: 2*node, left: left, right: right)
        let r = find(start: mid+1, end: end, node: 2*node+1, left: left, right: right)
        return l+r
    }
    mutating func update(start: Int, end: Int, node: Int, index: Int, val: Int) {
        if index < start || index > end {
            return
        }
        seg[node] += val
        if start == end {
            return
        }
        let mid = (start+end)/2
        update(start: start, end: mid, node: 2*node, index: index, val: val)
        update(start: mid+1, end: end, node: 2*node+1, index: index, val: val)
    }
    init(arr: [Int]) {
        self.arr = arr
        self.seg = Array(repeating: 0, count: 4*arr.count)
        makeTree(start: 0, end: arr.count-1, node: 1)
    }
}

Segment Tree with Lazy Propagation 전체 코드

struct Segment {
    var arr = [Int]()
    var seg = [Int]()
    var lazy = [Int]()
    mutating func makeTree(start: Int, end: Int, node: Int) -> Int {
        if start == end {
            seg[node] = arr[start]
            return seg[node]
        }
        let mid = (start+end)/2
        let l = makeTree(start: start, end: mid, node: 2*node)
        let r = makeTree(start: mid+1, end: end, node: 2*node+1)
        seg[node] = l+r
        return seg[node]
    }
    mutating func updateLazy(start: Int, end: Int, node: Int) {
        if lazy[node] != 0 {
            seg[node] += lazy[node]*(end-start+1)
            if start != end {
                lazy[2*node] += lazy[node]
                lazy[2*node+1] += lazy[node]
            }
            lazy[node] = 0
        }
    }
    mutating func find(start: Int, end: Int, node: Int, left: Int, right: Int) -> Int {
        updateLazy(start: start, end: end, node: node)
        if left > end || start > right {
            return 0
        }
        if left <= start && end <= right {
            return seg[node]
        }
        let mid = (start+end)/2
        let l = find(start: start, end: mid, node: 2*node, left: left, right: right)
        let r = find(start: mid+1, end: end, node: 2*node+1, left: left, right: right)
        return l+r
    }
    mutating func update(start: Int, end: Int, node: Int, left: Int, right: Int, val: Int) {
        updateLazy(start: start, end: end, node: node)
        if right < start || left > end {
            return
        }
        if left <= start && end <= right {
            lazy[node] += val
            updateLazy(start: start, end: end, node: node)
            return
        }
        let mid = (start+end)/2
        update(start: start, end: mid, node: 2*node, left: left, right: right, val: val)
        update(start: mid+1, end: end, node: 2*node+1, left: left, right: right, val: val)
        seg[node] = seg[2*node] + seg[2*node+1]
    }
    init(arr: [Int]) {
        self.arr = arr
        self.seg = Array(repeating: 0, count: 4*arr.count)
        self.lazy = Array(repeating: 0, count: 4*arr.count)
        makeTree(start: 0, end: arr.count-1, node: 1)
    }
}

Union-Find

2021-06-22T00:00:00+00:00

Disjoint Set을 구현할 때 사용하는 자료구조로 두 집합을 하나로 합쳐주는 것을 용이하게 해주는 자료구조이다. 두 집합이 한 집합이 된다면 한 집합의 root 노드가 다른 집합의 child로 들어가게되는 형태이다.

크게 union 함수와 find 함수 구현으로 이루어져있다. Array를 이용하여 구현할 것인데 본인의 parent의 array index가 무엇인지를 저장해주는 parent array 하나를 이용할 것이다. 초기값으로는 자기 자신이 본인의 부모가 되도록 구현한다.

1. Find 함수

먼저 find 함수를 알아보자. 만약 어떤 노드에 find를 하게된다면 본인이 속한 집합의 root node가 나올때까지 재귀적으로 반복해서 find함수를 호출한다. 그 후 해당 root node를 return 해준다. 이 때 시간 단축을 위해 path compression 이라는 기법을 사용한다.

Path Compression

Path Compression이란 find함수를 거쳐 재귀적으로 root를 찾았을 경우 거쳐온 경로의 노드들이 root를 바로 가르키도록 경로를 압축시켜주는 것을 의미한다. 이렇게 될 경우 한번이라도 find 함수를 거친 노드들은 parent 배열에 root를 저장하고 있기 때문에 후에 find 함수가 일어날 경우 O(1) 만에 root를 찾아줄 수 있다.

Find Function

mutating func find(_ n: Int) -> Int {
    if n == parent[n] {
        return n
    }
    else {
        let root = find(parent[n])
        parent[n] = root
        return root
    }
}

2. Union 함수

두 집합을 하나로 합쳐주는 방법으로 한 집합의 root가 다른 집합의 일부분이 되도록 구현한다. 이 때 union by rank 라는 기법을 사용해서 집합을 합친다. 여기서는 node index가 작은 root에 큰 root가 child로 합쳐지도록 union을 구현했다.

Union by Rank

Union by Rank란 두 집합을 합칠 때 rank의 값이 작은 집합이 rank가 큰 집합 root의 자식으로 들어가는 방식이다. 이렇게 구현할 경우 계속해서 집합을 합칠 때 전체 rank가 logN 이상 길어지지 않도록 조절해주는 역할을 한다. rank가 길어지는 것은 후에 find 함수에서 성능 저하를 불러일으키기 때문에 중요한 부분이다.

Union Function

mutating func union(_ a: Int, _ b: Int) {
    let findA = find(a), findB = find(b)
    if findA < findB {
        parent[findB] = findA
    }
    else {
        parent[findA] = findB
    }
}

전체 코드

struct DisjointSet {
    var parent:[Int]
    init(_ n: Int) {
        parent = [Int](0...n)
    }
    mutating func find(_ n: Int) -> Int {
        if n == parent[n] {
            return n
        }
        else {
            let root = find(parent[n])
            parent[n] = root
            return root
        }
    }
    mutating func union(_ a: Int, _ b: Int) {
        let findA = find(a), findB = find(b)
        if findA < findB {
            parent[findB] = findA
        }
        else {
            parent[findA] = findB
        }
    }
}

Priority Queue

2021-06-22T00:00:00+00:00

우선순위 큐란 데이터들이 우선순위를 가지고 있고 높은 우선순위를 가진 데이터가 먼저 나가는 자료구조이다. 그렇다면 이런 구조를 어떻게 구성해야 할까? 우리는 heap이라는 구조를 사용할 예정이다.

Heap이란 완전 이진 트리로 부모의 값이 자식의 값보다 우선순위가 높은 형태로 되어있는 자료구조이다. heap에서의 push와 pop은 모두 O(logn) 이 걸리게 되서 굉장히 빠른 연산이 가능해진다. 우리는 Array를 활용해서 구현할 예정이다. pop의 경우 항상 heap에서 root에 있는 값을 꺼내오게 되는데 이는 전체 데이터 중에서 우선순위가 가장 높은 값을 반환하므로 우선순위 큐를 구현할 수 있게 된다.

1. ShiftUp 함수

만약 배열의 끝에 새로운 원소를 집어넣는다 생각해보자. 어떻게하면 새로운 원소가 heap의 우선순위 규칙을 따르는 위치로 가게 될까? 우리는 노드와 부모를 비교해서 부모보다 현재의 노드가 우선순위가 높다면 부모와 위치를 바꿔주는 일을 반복적으로 할 것이다. 이 때 부모와 자식을 바꿔가며 만들어지는 새로운 subtree는 heap의 조건을 만족한다고 가정하자. 그렇다면 다음과같이 부모와 두 subtree가 있다고 하자.

이 때 한쪽 subtree에 새로운 원소가 집어넣어져서 shiftup 연산을 거쳐서 새로운 subtree가 되었다고 하자. 이 때 회색의 의미는 새로운 원소가 포함되어있다는 의미이다. 만약 새로운 원소가 오른쪽 subtree의 root에 도달했다고 하자. 부모와 오른쪽 subtree의 root는 서로를 비교해서 우선순위가 높은 것을 위로 보낼 것이다.

만약 부모 노드가 우선순위가 더 높아서 새로운 노드와 자리를 바꿀 필요가 없을 경우는 어떻게 될까? subtree는 heap의 조건을 만족한다고 가정했었기 때문에 새롭게 형성된 오른쪽 subtree의 모든 원소보다 부모 노드의 우선순위가 높게된다. 따라서 전체 tree는 heap의 조건을 만족하게 된다.

새로운 노드가 부모보다 우선순위가 더 높다면 둘의 위치가 바뀔 것이다. 그렇게 될 경우 왼쪽 subtree는 기존의 부모보다 우선순위가 전부 낮았기 때문에 새롭게 바뀐 부모보다도 전부 우선순위가 낮을 것이다. 그렇다면 오른쪽 subtree를 보자. 기존의 부모 노드는 새로운 원소가 들어오기 전에 오른쪽 subtree의 모든 원소보다 우선순위가 높았었다. 따라서 새롭게 형성된 오른쪽 subtree도 heap조건을 만족하게 되고 전체 트리는 heap조건을 만족하게 된다.

이렇게 새로운 원소부터 하나씩 subtree를 만들어간다면 ShiftUp 함수를 통해 새로운 heap을 만들 수 있다는 것을 알 수 있다. 이 때 최대 shiftup 하는 횟수는 이진트리의 높이와 같고 이는 최대 O(logn) 이다.

ShiftUp Function

mutating func shiftUp(_ a: Int) {
    var now = a
    while now > 0 {
        let parent = (now-1)/2
        if compare(pq[now], pq[parent]) {
            pq.swapAt(now, parent)
            now = parent
        }
        else {
            break
        }
    }
}

2. Push 함수

배열의 맨 끝에 새로운 원소를 집어넣고 ShiftUp 연산을 거치면 새로운 heap이 생기는 것을 위에서 확인했다. 따라서 간단하게 다음과 같이 구현할 수 있다. 전체 걸리는 시간은 ShiftUp에 걸리는 O(logn) 만큼이다.

Push Function

mutating func push(_ a: T) {
    pq.append(a)
    shiftUp(pq.count-1)
}

3. ShiftDown 함수

그렇다면 shift up과 반대로 heap의 root가 임의의 값으로 변경된다고 하자. 그렇다면 해당 root는 적절한 위치를 찾아서 내려가야 할 것이다. 이 때 사용되는 연산이 shift down 함수이다. 새롭게 바뀐 노드를 제외한 양쪽 subtree는 heap의 조건을 만족하고 있다.

양쪽 subtree의 root보다 현재의 노드가 우선순위가 높다면 그대로 두면 전체 tree는 heap의 조건을 만족하게 된다. 만약 그렇지 않다면? 양쪽 subtree의 root중 현재의 노드보다 우선순위가 작은 노드가 존재한다고 하자. 둘의 위치를 바꾸게 된다면 새롭게 형성되는 subtree는 똑같은 형태가 반복될 것이고 양쪽 subtree의 root보다 현재의 노드의 우선순위가 높을때까지 반복적으로 계산하면 된다.

이 때 두 subtree의 root가 모두 새롭게 바뀐 노드보다 우선순위가 높다면 두 subtree 중 우선순위가 더 높은 것을 바꾸도록 한다. 그렇게 할 시 한쪽 subtree보다 새로운 부모 노드가 우선순위가 높기 때문에 heap의 조건을 만족하면서 tree를 구성해 나갈 수 있게 된다.

ShiftDown Function

mutating func shiftDown(_ a: Int) {
    var now = a
    var child = 2*a+1
    while child < pq.count {
        if child+1 < pq.count && compare(pq[child+1], pq[child]) {
            child += 1
        }
        if compare(pq[child], pq[now]) {
            pq.swapAt(child, now)
            now = child
            child = 2*now+1
        }
        else {
            break
        }
    }
}

4. Pop 함수

위에서 설명한 ShiftDown을 활용한다. 먼저 root에 있는 원소를 배열의 맨 끝 원소와 swap한다. 그 후 배열에서 removeLast를 수행한다. 이렇게 할 경우 O(1) 만에 원소 제거가 가능해져 효과적이다. 그 후 새롭게 바뀐 root 원소를 적절한 위치를 찾아 ShiftDown 시켜준다. 전체 걸리는 시간은 ShiftDown에서 소요되는 O(logn) 만큼 걸리게 된다.

Pop Function

mutating func pop() -> T? {
    if pq.isEmpty {
        return nil
    }
    else {
        pq.swapAt(0, pq.count-1)
        let result = pq.removeLast()
        shiftDown(0)
        return result
    }
}

전체 코드

struct PriorityQueue <T> {
    var pq:[T]
    var compare:(T, T) -> Bool
    mutating func shiftUp(_ a: Int) {
        var now = a
        while now > 0 {
            let parent = (now-1)/2
            if compare(pq[now], pq[parent]) {
                pq.swapAt(now, parent)
                now = parent
            }
            else {
                break
            }
        }
    }
    mutating func shiftDown(_ a: Int) {
        var now = a
        var child = 2*a+1
        while child < pq.count {
            if child+1 < pq.count && compare(pq[child+1], pq[child]) {
                child += 1
            }
            if compare(pq[child], pq[now]) {
                pq.swapAt(child, now)
                now = child
                child = 2*now+1
            }
            else {
                break
            }
        }
    }
    mutating func push(_ a: T) {
        pq.append(a)
        shiftUp(pq.count-1)
    }
    mutating func pop() -> T? {
        if pq.isEmpty {
            return nil
        }
        else {
            pq.swapAt(0, pq.count-1)
            let result = pq.removeLast()
            shiftDown(0)
            return result
        }
    }
    init(pq: [T] = [], compare: @escaping (T, T) -> Bool) {
        self.pq = pq
        self.compare = compare
    }
}

Tree

2021-06-22T00:00:00+00:00

트리란 그래프의 일종으로 서로 다른 두 노드를 잇는 길이 하나뿐인 그래프를 트리라고 부른다. 트리의 최상위 노드는 root node 라고 불리며 각각의 노드들은 parent node와 child node의 관계로 정의된다. 이 때 자식 노드가 없는 노드를 leaf node라고 부른다. 트리는 루트는 무조건 1개이고 각각의 노드별 자식의 갯수가 정해져 있지 않다.

그 중에서 자식의 갯수를 최대 2개로 제한한 트리를 이진트리라고 부른다. 완전 이진 트리란 이진 트리 중에서도 새로운 값이 추가되면 왼쪽 아래부터 채워진 이진트리를 말한다. 트리의 구현은 링크드리스트, Array 등 방법이 다양해서 경우에 맞게 사용하는 것이 좋다. 특히 완전 이진 트리의 경우 Array로 구현을 하는 경우가 많다.

Stack & Queue & Deque

2021-06-22T00:00:00+00:00

1. Stack

스택이란 LIFO(Last In First Out)의 자료구조로 가장 나중에 들어온 데이터가 가장 먼저 나갈 수 있는 자료구조를 의미한다. LinkedList나 Array로 주로 구현을 한다.

주 기능으로는 push와 pop이 있으며 push는 값을 stack의 top에 데이터를 추가하는 행동을 의미하고 pop은 stack의 top에 존재하는 데이터를 꺼내는 행동을 의미한다. 모두 O(1) 의 시간이 걸리며 스위프트에서는 Array로 구현할 예정이다.

struct Stack <T> {
    var stack:[T] = []
    mutating func push(_ a: T) {
        stack.append(a)
    }
    mutating func pop() -> T? {
        return stack.popLast()
    }
}

2. Queue

큐는 FIFO(First In First Out)의 자료구조로 가장 먼저 들어온 데이터가 가장 먼저 나갈 수 있는 자료구조를 의미한다. 스택과 마찬가지로 Linked List나 Array로 주로 구현을 하지만 두 경우의 성능차이가 존재한다.

push는 값을 queue의 제일 끝쪽에 추가하는 행동을 의미하고 pop은 queue의 제일 앞쪽에 존재하는 원소를 제거하고 꺼내는 행동을 의미한다. 이 때 Array로 구현을 할 경우 pop시 모든 원소를 한칸씩 앞쪽으로 이동시켜야하기 때문에 stack때와는 다르게 O(n) 의 pop 시간이 걸리게 된다. Linked List의 경우 O(1) 만에 해결할 수 있어 성능 차이가 난다. 여기서는 구현이 간편하도록 Array로 구현을 했다.

struct Queue <T> {
    var queue:[T] = []
    mutating func push(_ a: T) {
        queue.append(a)
    }
    mutating func pop() -> T? {
        if queue.isEmpty {
            return nil
        }
        else {
            return queue.removeFirst()
        }
    }
}

3. Deque

큐와 스택을 합친거 같은 자료구조로 맨 앞과 맨 뒤 모두에서 push와 pop이 가능한 구조이다. 마찬가지로 맨 앞에서 push와 pop을 하는것이 Array에서는 O(n) 이 걸리기 때문에 LinkedList로 구현하는 것이 좋다. 여기서는 구현이 편하도록 array로 구현하였다.

struct Deque <T> {
    var deque:[T] = []
    mutating func pushFront(_ a: T) {
        deque = [a] + deque
    }
    mutating func popFront() -> T? {
        if deque.isEmpty {
            return nil
        }
        else {
            return deque.removeFirst()
        }
    }
    mutating func pushBack(_ a: T) {
        deque.append(a)
    }
    mutating func popBack() -> T? {
        return deque.popLast()
    }
}

Mo's Algorithm

2021-06-21T00:00:00+00:00

변하지 않는 수열이 있다고 할 때 쿼리가 엄청나게 많이 들어온다고 하자. 이 때 각각의 쿼리마다 새롭게 모든 것을 구해주면 굉장히 시간이 오래걸릴 것이다. 만약 쿼리들을 어떤 순서로 정렬해서 이전 결과를 다음 결과에 활용할 수 있다면 시간 단축에 큰 도움이 될 것이다. 이런 방식으로 시작하는게 바로 mo’s algorithm이다.

위의 그림을 보자. 4-6, 3-8, 3-5 구간을 구하는 쿼리가 들어온다고하자. 그렇게되면 그림처럼 4-6 쿼리에서 3-8 쿼리로 갈때는 왼쪽을 한칸 오른쪽을 2칸 이동시키면 결과를 구할 수 있다. 마찬가지로 3-5 구간도 오른쪽을 세칸 감소시키면 이전 결과에서 새로운 결과를 얻어낼 수 있다. 이처럼 이전 쿼리의 결과를 활용하여 새로운 쿼리를 구하는 방법을 mo’s algorithm이라고 부른다.

그렇다면 어떤 규칙으로 정렬을 시켜야할까? 바로 시작 지점에 대해 평방 분할을 사용해서 정렬하면 된다. 평방 분할이란 주어진 구간을 sqrt(n)으로 나누어 관리를 하는 것이다.

그림의 색깔이 다른 부분은 서로 다른 평방 영역에 해당하게 된다. 이렇게 평방 분할을 하면 뭐가 좋을까? 쿼리들을 두개의 조건으로 정렬한다고 하자.

1) Q[i].e < Q[i+1].e
2) Q[i].s / sqrt(n) < Q[i+1] / sqrt(n)

평방 영역이 같을 경우 내부에서 구간을 이동시켜봤자 최대 sqrt(n)밖에 되지 않는다. 총 n개에 대해서 실시하므로 O(n sqrt(n)) 의 시간이 걸리게 된다. e의 이동은 증가하도록 정렬했기 때문에 최대 n밖에 이동하지 않는다.

평방 영역이 다를 경우 구간 이동을 최대 n하게 된다. 하지만 구간 자체가 sqrt(n)개로 쪼개졌기 때문에 다른 평방으로의 구간이동을 하는 횟수는 전체 통틀어서 sqrt(n)이다. 따라서 전체 걸리는 시간은 O(n sqrt(n)) 의 시간이 걸리게 된다.

비트마스크

2021-06-21T00:00:00+00:00

전구가 5개가 있을 때 어떤 전구들이 켜져있는지 나타내는 방법은 무엇이 있을까? 전구의 각 상태를 arr로 저장해서 켜져있으면 1 아니면 0으로 나타내는 방법을 생각해보자. 만약 2, 3번째 전구가 켜져있다면 배열은 [0 0 1 1 0]으로 나타날 것이다.

배열을 다시보니 0과 1로만 표현되는 이진법과 형태가 같다는 것을 알 수 있다. 그렇다면 배열의 상태를 이진법 숫자로 변환해보자. 00110₂ -> 6 이렇게 표현하고 나니 배열을 쓰지 않고도 전체 상태를 간결히 확인 할 수 있을 것이란 생각이 든다.

이렇듯 비트마스크는 이진법을 이용한 숫자표현으로 배열의 상태를 나타내는 기법이다. 비트마스크를 활용하면 비트 연산을 활용하여 집합 상태의 추가, 삭제, 조회 등의 연산을 간단히 처리할 수 있다. 비트연산에는 크게 AND, OR, XOR, NOT, SHIFT가 있다.

AND(&) 연산

대응하는 bit가 모두 1일때 1 반환, 그외에는 0

1010 & 1100 = 1000

OR(|) 연산

대응하는 bit 중 하나라도 1이면 1 반환, 둘 다 0이면 0

1010 | 1100 = 1110

XOR(^) 연산

대응하는 bit가 서로 다르면 1, 서로 같으면 0

1010 ^ 1100 = 0110

NOT(~) 연산

비트 값을 전부 뒤집는 연산

~1010 = 0101

Shift(«, ») 연산

비트값을 전부 왼쪽(«)으로 혹은 오른쪽(»)으로 주어진 숫자만큼 옮기는 연산 주목할만한건 <<1 or >>1은 주어진 숫자를 *2 or /2 하는것과 같다는 것이다.

1010 >> 2 = 0010
1010 << 2 = 101000

앞으로 우리는 상태 저장을 비트마스크로 하는 문제들을 풀어 볼 것이다. 비트마스크는 이곳저곳에 섞여서 많이 쓰이므로 정확히 개념을 잡고 넘어가는걸 추천드린다.

스위핑

2021-06-21T00:00:00+00:00

어느 한 기점으로부터 끝까지 쭉 살펴보면서 답을 구하는 방식으로 입력을 특정 기준으로 정렬시킨 후 문제를 해결하는 방식을 의미한다.

이 기법은 다른 기법과 함께 같이 등장하여 자주 쓰이는데 주로 세그먼트 트리와 많이 응용된다. 따라서 몇몇 문제는 세그먼트 트리 파트를 보고 문제풀이를 보는 것을 추천한다.

동적 계획법

2021-06-21T00:00:00+00:00

동적 계획법이란 주어진 문제를 해결하기 위해 여러 하위 문제들로 분할한 뒤 이를 합쳐서 문제를 해결하는 방식을 말한다. 이 때 하위 문제들의 결과를 배열같은 공간에 저장해주어 같은 연산을 여러번하지 않도록 하는 메모이제이션 기법이 같이 사용된다.

동적 계획법은 피보나치 수, LCI, LCS, Knapsack 등 다양한 문제에 활용되고 있으며 tech 파트 외에도 그래프나 자료구조, 수학 파트에서도 등장해 사용될 예정이므로 확실히 이해를 하고 넘어가는 것이 중요하다.

1. 피보나치 수

피보나치 수란 다음의 조건을 만족하는 수열을 의미한다.

F₀ = 0, F₁ = 1, F_n+2 = F_n+1 + F_n

이를 함수로 나타내면 다음과 같다.

func fibo(n: Int) -> Int {
    if n == 1 || n == 2 {
        return 1
    }
    return fibo(n: n-1) + fibo(n: n-2)
}

일반적으로 F₁₀을 호출하게 되면 F₉와 F₈의 값이 필요하게 되고, 또 F₉는 F₈과 F₇의 값이 필요하게 된다. 이 때 F₈이 반복해서 나온다는 것을 알 수 있는데 계속해서 계산해보면 F₈ 밑에 있는 다른 값들 역시 여러 번 쓰인다는 것을 알 수 있다.

이 때 우리는 처음 계산할 때 그 결과를 저장해두고 다음번에 호출할 때 그 값을 불러 와서 쓰면 좋겠다는 생각을 할 수 있다. 이 발상에서 시작하여 주어진 문제를 하위 문제로 나누고 dp 배열을 활용하여 중복 연산을 줄이는 방법을 동적 계획법이라 부른다.

동적계획법에는 크게 top-down 방식과 bottom-up 방식이 있다.

1) Top-down 방식

var dp = Array(repeating: -1, count: MAXN)
func fibo(n: Int) -> Int {
    if n == 1 || n == 2 {
        return 1
    }
    if dp[n] != -1 {
        return dp[n]
    }
    dp[n] = fibo(n: n-1) + fibo(n: n-2)
    return dp[n]
}

주어진 식을 보면 알겠지만 기존의 재귀 호출방식에서 dp라는 배열이 추가된 것을 확인할 수 있다. 만약 해당 연산을 한번이라도 수행 했다면 해당 결과를 dp에 저장하고 이 후 연산 들에 대해서는 저장된 값을 불러와 해결하는 방식이다.

Top-down 방식은 점화식을 그대로 사용하면 되서 이해하기 쉽고 구현이 쉽다는 장점이 있지만 함수 호출이 여러번 이루어질시 약간의 overhead가 발생한다는 단점이 있다.

2) Bottom-up 방식

func fibo(n: Int) -> Int {
    var a = 1, b = 0
    for _ in 2...n {
        let tmp = a
        a = a+b
        b = tmp
    }
    return a
}

Bottom-up 방식은 불필요한 함수 호출을 줄이기 위해서 가장 작은 문제부터 하나씩 쌓아가는 방식을 의미한다. F_n을 구하기 위해 F₂부터 순서대로 F₃, F₄ … F_n순으로 구해나가는 것이 이에 해당한다.

2. LIS (Longest Increasing Subsequence)

LIS는 가장 긴 증가하는 부분 수열을 나타낸다. 증가하는 부분 수열이란 수열의 특정 부분을 지워 부분 수열을 만들때 앞에서부터 뒤로갈수록 값이 증가하는 형태를 띈 수열을 의미한다. 이 중 가장 길이가 긴 수열을 찾는 문제라고 할 수 있다.

1) O(n²) LIS

먼저 다음과 같은 수열이 있다고 생각해보자.

A = [1, 3, 5, 7, 2, 1, 4, 8]

i = 0 일때 A[0] = 1 이고 그 때의 dp값을 0로 설정하자.
그러면 i를 하나씩 증가 시켜갈때 점화식은 다음과 같다.

dp[i] = max(dp[j]) + 1, where A[j] < A[i]

이 경우 n개의 수열 값 각각에 대해 본인보다 작은 원소들을 모두 살펴봐야하므로 O(n²) 의 시간이 걸리게된다.

2) O(nlogn) LIS

위의 방법을 사용하면 본인보다 작은 index의 수열을 모두 살펴보는 것은 비효율적이란 생각이 든다. 그렇다면 dp에 A[i]를 포함하는 최장 부분 수열의 길이를 저장하는 것이 아닌 현재까지 이어온 최장 부분 수열의 A 값들을 저장해보자. 먼저 i = 0 부터 3까지를 보면 이전 값보다 현재값이 크기때문에 dp에는 다음과 같이 저장이 된다.

dp = [1, 3, 5, 7]

이제 i = 4 의 경우를 보자. 2의 경우 3보다 작고 1보다 큰 값이기 때문에 들어가야 할 위치는 1과 3 사이가 될 것이다. 이 때 1과 3 사이에 2를 집어넣는 것이 아닌 3 대신에 2를 덮어씌우는 방식을 사용한다. 그 결과는 다음과 같다.

dp = [1, 2, 5, 7]

왜 이런 방식을 사용하는 것인가 하면 1과 2로 이어지는 새로운 부분 수열을 우리가 만든다고 할 때 기존의 3, 5, 7은 2보다 큰 값이기 때문에 1과 2 사이에 위치할 수 없다. 따라서 매번 A[i]값이 들어갈 위치를 dp에서 찾아서 바꿔주고 그때의 dp의 index가 A[i]를 마지막 원소로 갖는 LIS의 길이가 된다. 이 때 dp 안에서 A[i]가 들어갈 위치를 찾는 것은 lower bound을 이용한다. 자세한 설명은 이분탐색 파트를 살펴보기 바란다.

모든 원소에 각각에 대해서 dp 안에 들어갈 위치를 찾으면 해결되는 문제로 총 nlogn의 시간이 소요된다. (Lower bound 탐색에 logn이 소요된다) 이 때 최종 결과로 나온 dp 배열은 LIS 수열이 아님을 명심하자. 중간에 삽입된 다른 값으로 대체가 되어 있을수도 있기 때문에 최장길이에 해당하는 A[i]부터 거꾸로 내려가면서 최장 수열을 찾아야한다.

let n = 7
var dp = Array(repeating: -1, count: n)
var A = [1, 3, 5, 7, 2, 4, 8]
dp[0] = A[0]
var dpCount = 1
for i in 1..<n {
    let index = lowerBound(down: 0, up: dpCount, key: A[i], arr: dp)
    if dp[index] == -1 {
        dpCount += 1
    }
    dp[index] = A[i]
}
print(dpCount)

3. LCS (Longest Common Subsequence)

최장 공통 부분 수열이란 두 수열이 주어졌을 때 두개의 공통되는 부분 수열 중에서 가장 긴 것을 찾는 문제이다. 예를들어 ACAYKP 와 CAPCAK 의 LCS는 ACAK가 된다. 다음과 같은 2차원 LCS dp배열을 생각해보자.

	A	C	A	Y	K	P
C
A
P
C
A
K

CAPCAK순으로 왼쪽에서 오른쪽으로 배열을 채워 넣을 것이며 규칙은 다음과 같다.만약 두 문자가 일치할경우 row, col 모두 해당 문자를 뺀 부분까지의 LCS값에 1을 더한것이 구하고자 하는 dp 값일것이다.

if character same {
    dp[row][col] = dp[row-1][col-1] + 1
}
else {
    dp[row][col] = max(dp[row][col-1], dp[row-1][col])
}

결과는 다음과 같으며 dp[row.max][col.max]이 구하고자하는 LCS값이다.

	A	C	A	Y	K	P
C	0	1	1	1	1	1
A	1	1	2	2	2	2
P	1	1	2	2	2	3
C	1	2	2	2	2	3
A	1	2	3	3	3	3
K	1	2	3	3	4	4

let a = "ACAYKP".map{Character(String($0))}
let b = "CAPCAK".map{Character(String($0))}
var board:[[Int]] = Array(repeating: Array(repeating: 0, count: b.count+1), count: a.count+1)
for i in 1...a.count {
    for j in 1...b.count {
        if b[j-1] == a[i-1] {
            board[i][j] = board[i-1][j-1] + 1
        }
        else {
            board[i][j] = max(board[i][j-1], board[i-1][j])
        }
    }
}
print(board[a.count][b.count])

4. Knapsack

가방싸기 문제라고 불리는 knapsack은 가방의 최대 용량이 k라고 주어졌을 때 각 물건별로 무게와 가치가 주어지면 주어진 가방 용량 안에서 가치가 최대가 되도록 가방을 싸는 방법을 찾는 문제이다.

w라는 무게를 갖고 v라는 가치를 가지는 물건을 가방에 넣으려고 한다고하자. 생각해보면 w라는 무게를 넣고 싶다면 w만큼의 무게 자리를 확보해 준 후 그 때의 가치에서 v만큼을 더한것과 같다.

이를 점화식으로 나타내면 다음과 같다.
dp[i] = max(dp[i-w] + v, dp[i]) where i in w…k

var dp = Array(repeating: 0, count: k+1)
for wv in objects {
    let w = wv.weight, v = wv.value
    if w > k {continue}
    var tmp = dp
    for i in w...k {
        if dp[i] < dp[i-w] + v {
            tmp[i] = dp[i-w] + v
        }
    }
    dp = tmp
}
print(dp[k])

5. 컨벡스 헐 트릭

동적 계획법에서 특정 점화식이 쓰였을 경우 시간을 획기적으로 줄여주는 기법. 컨벡스 헐을 구하는 것처럼 보이기 때문에 컨벡스 헐 트릭이란 이름이 붙었다. (컨벡스 헐에 대해서 몰라도 쓸 수 있지만 내용이 어려우므로 다른것 먼저 다뤄보고 공부하는 것을 추천한다)

DP[i] = min(A[i]∗B[j] + DP[j]) where j < i

이 함수를 우리는 직선방정식의 형태로 변화시킬 것이다. A[i] 를 x로 DP[i] 를 f(x)로 바꾸면 f(x) = B[j]∗x + dp[j] 와 같이 변한다. j에 따라 변하는 B[j] 와 dp[j]를 직선의 기울기와 절편으로 삼고 선분으로 표현하면 다음과 같다.

여기서 우리가 구하고자 하는 부분은 각 선분들 중 가장 아랫부분이다. 왜냐하면 구하고자하는 DP[i]는 여러 j에 대해 min값을 구하는 형태로 되어있기 때문이다.

j는 i보다 작거나 같은 값이기 때문에 i를 1씩 증가시키면서 DP[i]를 구할때마다 해당 결과를 이용해서 선분을 추가시켜주면 다음 i에 대해서 모든 j에 대한 선분들이 저장되어있을 것이기 때문에 문제를 간단히 풀 수 있다.

B[j] ≥ B[j+1]

이 때 위의 조건이 있다면 기울기가 점차 감소하는 형태이므로 이전 직선들과의 최하단 부분을 구하는데 용이하다. 다음 그림 세개를 보자.

먼저 새로운 직선과 이전 직선의 교점이 새로운 직선과 전전 직선의 교점보다 클 경우이다. 이 경우 이전 직선이 최하단 부분을 담당하는 곳이 있기 때문에 새로운 직선을 단순히 추가시켜주기만 하면 된다.

이 경우는 두 교점이 일치하는 경우이다. case에 따라서 이전 직선을 삭제할지 남겨둘지 정하면 된다.

이제 두 교점이 일치하는 경우에서 새로운 직선이 조금 아래로 내려온다고 생각해보자. 그러면 새로운 직선과 이전 직선의 교점이 새로운 직선과 전전 직선의 교점보다 왼쪽에 위치하는 것을 알 수 있다. 게다가 자세히 보면 최하단 부분을 구하는데에 이전 직선의 영향력이 아예 없어진 것을 알 수 있다. 이 경우 이전 직선을 직선 Set에서 제거시켜준다.

이렇게 최하단 직선 set를 구성했다면 우리가 원하는 x값에 대해서 이분탐색을 통해 어떤 직선을 써야하는지 찾아주고 그때의 dp값을 구해주면 O(nlogn) 만에 구할 수 있게 된다. 단 A[i] < A[i+1]라는 조건 있다면 새로운 입력의 적합한 직선은 이전에 사용한 직선 이후의 직선이 될것이기 때문에 이분탐색이 필요없어 O(n) 만에 문제를 해결할 수 있다.

6. 분할 정복 트릭

다음의 점화식을 만족하는 dp문제에 대해서 적용이 가능한 기법이다.

dp[i][j] = min(dp[i-1][k] + c[k][j]) (where k < j && c[i][j] is Monge Array)

Monge Array란 임의의 a ≤ b ≤ c ≤ d에 대해 C[a][c] + C[b][d] ≤ C[a][d] + C[b][c]를 만족하는 것을 의미한다. 그렇다면 임의의 p < q에 대해서 dp[i][p]가 최소가 되게하는 k인 opt_p는 dp[i][q]가 최소가 되게하는 k인 opt_q에 대해서 opt_p ≤ opt_q를 만족한다.

이를 통해 우리는 점화식을 찾을 때 연산 횟수를 상당부분 줄일 수 있게 된다. 원래대로라면 모든 i에 대해 모든 j를 살펴봐야하므로 O(n²) 가 걸려야하지만 O(nlogn) 까지 줄일 수 있게 된다. 이론만 보고서는 크게 이해가 안가는 파트니 꼭 문제를 풀어보고 이해하기 바란다.

7. 크누스 최적화

다음 세 조건을 만족하는 경우 크누스 최적화를 적용할 수 있다.

d[i][j] = min(d[i][k] + d[k][j]) + c[i][j] where i < k < j
c[a][c] + c[b][d] <= c[a][d] + c[b][c] where a<=b<=c<=d
c[b][c] <= c[a][d] where a<=b<=c<=d

이를 만족하면 A[i][j]가 d[i][j]가 답이 되도록 만드는 k의 위치(opt)라고 했을 때 A[i][j]는 다음을 만족한다.
A[i][j-1] ≤ A[i][j] ≤A[i+1][j]

이를 이용하여 d[i][j]를 구할 때 탐색 범위를 줄일 수 있고 속도를 향상 시킬 수 있다.

DFS & BFS

2021-06-21T00:00:00+00:00

DFS & BFS는 그래프 파트에 있어야 할 것 같지만 DP문제에도 활용되고 다양한 분야에 섞여서 많이 쓰이는 개념이기 때문에 미리 다루었다.

1. DFS (Depth First Search)

그래프 상에서 가장 깊은 지점까지 탐색한 후 분기점까지 돌아와 다른 경로를 마찬가지로 탐색하는 방식. 이미 방문한 노드에 대해서는 check함수를 이용해 다시 방문하지 않도록하여 무한루프를 돌지 않도록 한다. 주로 스택을 이용해서 구현을 하거나 재귀함수 호출을 이용하여 구현을 한다. 다음과 같은 그래프가 있다고 하자.

B -> D -> E 순으로 들어갈 수 있는 최대한의 깊이까지 탐색을 한다.
이때 E에서는 다른 곳으로 갈수가 없으므로 D로 돌아간다. 
마찬가지로 D에서도 E 이외의 다른 경로가 없기 때문에 B로 돌아가고 B에서도 A로 돌아간다.
A에서 다시 다른 경로인 D를 확인한다. 이 때 D는 이미 방문을 했으므로 넘어간다.
C이라는 경로로 이동 후 C에서 E를 바라보지만 E는 이미 방문을 했으므로 A로 돌아간 후 실행이 종료된다.

func dfs(n: Int) {
    check[n] = true
    str += "\(n) "
    for e in edge[n] {
        if !check[e] {
            dfs(n: e)
        }
    }
}

2. BFS (Breadth First Search)

DFS와는 다르게 이번에는 큐라는 구조체를 이용할 것이다.
DFS와 같은 그래프를 보도록 하자.

시작 노드를 먼저 큐에 집어넣는다.
큐에 가장 앞에 있는 노드를 pop해주고 해당 노드와 연결된 방문하지않은 모든 노드들을 큐에 집어넣는다.
큐가 빌때까지 2를 반복한다.

이렇게 구현을 하면 DFS에서는 “A B D E C” 의 순서로 방문했던것과는 다르게 “A B C D E” 로 방문한다는 것을 확인할 수 있다.

func bfs(n: Int) -> String {
    var queue = [Int]()
    var result = ""
    queue.append(n)
    check[n] = true
    while !queue.isEmpty {
        let curr = queue.removeFirst()
        result += "\(curr) "
        for e in edge[curr] {
            if !check[e] {
                queue.append(e)
                check[e] = true
            }
        }
    }
    return result
}

이분 탐색

2021-06-21T00:00:00+00:00

원하는 탐색범위를 두부위로 분할한 뒤 적합한 부위로 이동해 계속해서 찾는 탐색 기법을 의미한다. 일반적으로 분할하는 위치는 start index와 end index의 중앙값인 mid를 기점으로 분할한다. 단 이분 탐색을 할 때 값들이 정렬되어있어야 한다는 조건이 필요하다. 대표적인 이분 탐색 기법으로는 lower bound, upper bound가 있으며 그 외에도 다양한 분야에 적용되고 있다.

1. Lower bound

찾고자하는 key값이 주어졌을때 주어진 범위 안에서 key값보다 크거나 같은 가장 작은 index를 가진 값을 찾아주는 방법이다.

start와 end 중앙값인 mid를 정의한다.
key값이 A[mid] 보다 클 경우 start를 mid+1로 이동시키고 작거나 같을 경우 end를 mid로 이동시킨다.
1, 2 과정을 새로운 범위에 대해 반복한다.
end <= start가 될시 end index를 return한다.

이 때 유의할 것은 key값보다 크거나 같은 가장 작은 index를 찾는 것이기 때문에 2번과정에서 같을 경우 end를 mid로 땡겨오는 것이다. 또 맨 처음 end 값을 찾고자하는 범위의 끝이 아닌 끝+1로 해줘야 한다는 것인데 이는 주어진 배열의 모든 원소보다 key값이 클 경우 배열의 끝+1 index를 나타내줘야하기 때문에 이렇게 구현하였다.

let A = [1, 2, 3, 4, 4, 5, 6, 7]
print(lowerbound(start: 0, end: A.count, key: 4))

func lowerbound(start: Int, end: Int, key: Int) -> Int {
    var s = start, e = end
    while s < e {
        let mid = (s+e)/2
        if A[mid] < key {
            s = mid+1
        }
        else {
            e = mid
        }
    }
    return e
}

2. Upper bound

Lower bound와 동작은 비슷하지만 key값보다 큰 값을 가진 가장 작은 index를 찾는다는 점에서 차이를 갖는다. Lower bound 2번 과정에서 A[mid]보다 key값이 크거나 같을 경우 start를 mid+1로 이동시키도록 수정만 하면 구현 완료다.

분할 정복

2021-06-21T00:00:00+00:00

분할정복이란 어떤 결과를 얻고자할때 이를 여러개의 작은 문제들로 나누고(divide) 그 결과들을 결합시켜(conquer) 해답을 찾는 방법을 말한다. 얼핏보면 동적계획법과 동일해보이지만 분할정복은 쪼개지는 작은 문제가 중복되지 않는다는 차이점이 있다. 분할정복을 적용하는 문제로는 쿼드트리, 거듭제곱, 머지소트 등 다양하지만 여기서는 거듭제곱을 위주로 설명하겠다.

1. 거듭제곱

A라는 행렬을 1024번 곱한다고 생각하자. A¹⁰²⁴를 구하기 위해서 A를 하나씩 곱하게 되면 1024번의 연산을 하게 된다. 하지만 A⁵¹²를 구하고 이를 제곱해주면 A¹⁰²⁴를 구할수 있다. 이렇게 주어진 행렬을 두개로 쪼개어 계산해주게되면 총 logN의 시간만에 계산을 완료할 수 있게된다.

1024라는 숫자는 작아서 큰 차이가 안나보이겠지만 만약 n이 100,000,000과 같이 큰 수가 된다면 그 차이는 엄청나다는 것을 깨닫게 될 것이다. 이처럼 주어진 문제를 작은 문제로 나누어 다시 결합하는 방식을 분할 정복이라고 하고 다양한 분야에서 사용된다.

다음은 2x2 A행렬의 거듭제곱을 구하는 코드이다. 크게 A와 B 행렬을 곱해주는 multA함수와 A행렬을 m번 제곱하는 powA함수로 이루어져 있다.

multA함수

func multA(A: [[Int]], B: [[Int]], n: Int) -> [[Int]] {
    var resultArr = Array(repeating: Array(repeating: 0, count: n), count: n)
    for i in 0..<n {
        for j in 0..<n {
            var result = 0
            for k in 0..<n {
                result += (A[i][k] * B[k][j])
            }
            resultArr[i][j] = result
        }
    }
    return resultArr
}

powA함수

func powA(A: [[Int]], n: Int, m: Int) -> [[Int]] {
    if m == 0{
        return I
    }
    else if m == 1 {
        return A
    }
    else {
        let p1 = powA(A: A, n: n, m: m/2)
        let p2 = powA(A: A, n: n, m: m%2)
        return multA(A: mulA(A: p1, B: p1, n: n), B: p2, n: n)
    }
}

메인코드

let n = 2, m = 10
var I = [[1, 0], [0, 1]]
var A = [[3, 3], [4, 4]]
let result = powA(A: A, n: n, m: m)
print(result)

2. 점화식 분할정복

위에서 구한 분할정복을 활용하여 피보나치를 O(n) 이 아닌. O(logN) 만에 가능하다는 사실을 안 후 굉장히 충격을 받았다. 피보나치는 동적계획법에서 봤겠지만 다음과 같은 식을 갖는다.

F₀ = 0, F₁ = 1, F_n+2 = F_n+1 + F_n

이 때 주어진 식을 행렬로 표현하게되면 다음과 같다.

이 식을 활용하면 (1 1)(1 0) 으로 이루어진 행렬의 곱으로 피보나치 행렬을 표현할 수 있게되고 위에서 사용한 분할정복 행렬곱셈을 사용하게 되면 O(logN) 만에 피보나치 행렬을 구할 수 있게된다. 피보나치 점화식 뿐만 아니라 다른 점화식도 행렬로 표현만 한다면 적용가능하므로 다른 문제에서도 종종 쓰이는 기법이다.

백준 2261 가장 가까운 두 점

2021-06-21T00:00:00+00:00

https://www.acmicpc.net/problem/2261

2차원 좌표평면상의 여러 점들 중에서 가장 가까운 두 점 사이의 거리를 출력하는 문제이다. 대학교 시절에도 과제로 나왔었을 정도로 유명한 문제이다. 핵심 포인트는 스위핑과 분할정복이 사용된다. 스위핑이 뭔지 모르더라도 특정 좌표순으로 정렬한 후에 좌표값이 작은놈부터 하나씩 확인한다고 알고있으면 된다.

findMin함수 (비교대상수 4 미만)

func findMin(start:Int, end:Int) -> Int {
    if end - start < 3 {
        var result = 1_000_000_000
        for i in start...end {
            for j in start...i {
                if i == j {continue}
                let xdis = arr[j].x-arr[i].x
                let ydis = arr[j].y-arr[i].y
                result = min(result, xdis*xdis + ydis*ydis)
            }
        }
        return result
    }

이번 코드의 핵심이 되는 findMin 함수이다. 좌표상의 좌표들을 x좌표가 작은 것 순으로 0번부터 n-1번까지 번호를 매겼을때 시작 번호와 끝 번호를 주면 해당 번호 사이에서 가장 작은 거리를 출력해주는 기능을 한다. 먼저 두 번호 차이가 2이하일 경우 해당 점들간의 거리를 일일히 계산해준 후 가장 작은 값을 넘겨주도로 구현했다. 이 때 d² 을 구하도록해서 소수점 문제를 무시하도록 구현했다.

findMin함수 (비교대상수 4 이상)

    else {
        let d = min(findMin(start: start, end: (start+end)/2-1), findMin(start: (start+end)/2+1, end: end))
        if d == 0 {return 0}
        let sqrtD = Int(sqrt(Double(d))) + 1
        var result = d
        let xdis = arr[(start+end)/2]
        var list:[(x:Int, y:Int)] = []
        //왼쪽구역 list 추가
        for i in 0...(end-start)/2 {
            let idis = arr[(start+end)/2 - i]
            if xdis.x - idis.x >= sqrtD {
                break
            }
            list.append(idis)
        }
        //오른쪽 구역 list 추가
        for i in 1...(end-(start+end)/2) {
            let idis = arr[(start+end)/2 + i]
            if idis.x - xdis.x >= sqrtD {
                break
            }
            list.append(idis)
        }
        //y좌표순으로 정렬 후 거리비교
        list.sort(by: {$0.y < $1.y})
        for i in 0..<list.count {
            for j in i+1..<list.count {
                if list[j].y - list[i].y >= sqrtD {
                    break
                }
                else {
                    let xdis = list[j].x-list[i].x
                    let ydis = list[j].y-list[i].y
                    result = min(result, xdis*xdis + ydis*ydis)
                }
            }
        }
        return result
    }

이어서 확인해야할 좌표수가 4개 이상일 경우 else 구문에서 처리하도록 하였다. 핵심 아이디어는 정중앙 인덱스를 기준으로 좌측과 우측 각각에 대해서 분할정복을 실시한다는 것이다.

하지만 왼쪽 구역, 오른쪽 구역의 최솟값을 각각 구해 전체 최솟값인 d를 구했다하더라도 이것이 정답이 되지는 않는다. 왼쪽 구역과 오른쪽 구역의 점 간에 d보다 작은 거리가 나타날수도 있기 때문이다. 따라서 정중앙 점을 기준으로 해당 점으로부터 x축으로 d만큼 떨어진 녀석들간의 거리를 추가로 비교해줘야한다. 이 때 x좌표 기준으로 오름차순 정렬을 했기 때문에 어떤 점이 정중앙 점과 d보다 더 멀리 떨어져있다면 반대측 영역과도 d보다 멀리 떨어져있기 때문에 고려해줄 필요가 없다.

mid의 x좌표를 정중앙으로 하는 2d의 영역을 생각해보자. mid index로부터 1씩 감소시키면서 mid 좌표와 해당 좌표간의 거리가 d이하인 좌표들을 모두 list에 추가시켜준다. 마찬가지로 mid부터 1씩 증가시키면서 오른쪽 구간도 모두 추가해준다. 위의 사진에서 두 선 사이의 있는 영역에 있는 점들은 모두 list에 추가가 된 것이다.

이제 list안의 점들중에서 d보다 작은 거리를 찾아주기만 하면 끝이다. 하지만 단순히 모든 점을 비교하면 너무 많은 계산을 하게 된다. 그렇기 때문에 앞서 사용했던 개념을 y좌표에 대해서도 적용시킨다. list를 y좌표 순으로 다시 정렬을 한 후 두 점 사이의 y거리가 d이하인 녀석들간의 거리를 비교해줄 것이다. 즉 list의 모든 점들에 대해서 사진의 주황색 영역처럼 일정 범위내의 점들과만 비교해주는 것이다.

전체 코드

import Foundation
let n = Int(readLine()!)!
var arr:[(x:Int, y:Int)] = []
for _ in 1...n {
    let l = readLine()!.split(separator: " ").map{Int($0)!}
    arr.append((x:l[0], y:l[1]))
}
arr.sort(by: {$0.x < $1.x})
print(findMin(start: 0, end: n-1))

func findMin(start:Int, end:Int) -> Int {
    if end - start < 3 {
        var result = 1_000_000_000
        for i in start...end {
            for j in start...i {
                if i == j {continue}
                let xdis = arr[j].x-arr[i].x
                let ydis = arr[j].y-arr[i].y
                result = min(result, xdis*xdis + ydis*ydis)
            }
        }
        return result
    }
    else {
        let d = min(findMin(start: start, end: (start+end)/2-1), findMin(start: (start+end)/2+1, end: end))
        if d == 0 {return 0}
        let sqrtD = Int(sqrt(Double(d))) + 1
        var result = d
        let xdis = arr[(start+end)/2]
        var list:[(x:Int, y:Int)] = []
        //왼쪽구역 list 추가
        for i in 0...(end-start)/2 {
            let idis = arr[(start+end)/2 - i]
            if xdis.x - idis.x >= sqrtD {
                break
            }
            list.append(idis)
        }
        //오른쪽 구역 list 추가
        for i in 1...(end-(start+end)/2) {
            let idis = arr[(start+end)/2 + i]
            if idis.x - xdis.x >= sqrtD {
                break
            }
            list.append(idis)
        }
        //y좌표순으로 정렬 후 거리비교
        list.sort(by: {$0.y < $1.y})
        for i in 0..<list.count {
            for j in i+1..<list.count {
                if list[j].y - list[i].y >= sqrtD {
                    break
                }
                else {
                    let xdis = list[j].x-list[i].x
                    let ydis = list[j].y-list[i].y
                    result = min(result, xdis*xdis + ydis*ydis)
                }
            }
        }
        return result
    }
}

백준 11444 피보나치수6

2021-06-21T00:00:00+00:00

https://www.acmicpc.net/problem/11444

n이 입력으로 주어질 때 n번째 피보나치 수의 값을 출력하는 문제이다. n값이 최대 1,000,000,000,000,000,000까지 나올 수 있으므로 O(n) 의 방식을 이용하면 시간초과가 뜨게된다.

DnC Algorithm에서 설명했듯이 피보나치를 행렬로 표현해서 O(logn) 안에 해결하는 것이 포인트다. 이때 값이 굉장히 커질 수 있으므로 문제에서 주어진 1,000,000,007로 나눈 나머지를 출력한다.

전체 코드

let n = Int(readLine()!)!
let A = [[1, 1], [1, 0]]
let I = [[1, 0], [0, 1]]
let result = powA(A: A, m: n)
print(result[0][1])

func powA(A: [[Int]], m: Int) -> [[Int]] {
    if m == 0 {
        return I
    }
    else if m == 1 {
        return A
    }
    else {
        let p1 = powA(A: A, m: m/2)
        let p2 = powA(A: A, m: m%2)
        return multA(A: multA(A: p1, B: p1), B: p2)
    }
}

func multA(A: [[Int]], B: [[Int]]) -> [[Int]] {
    var resultArr = [[0, 0], [0, 0]]
    for i in 0..<2 {
        for j in 0..<2 {
            var result = 0
            for k in 0..<2 {
                result += (A[i][k] * B[k][j]) % 1_000_000_007
            }
            resultArr[i][j] = result % 1_000_000_007
        }
    }
    return resultArr
}