|
| 1 | +import Foundation |
| 2 | + |
| 3 | +struct Point: Hashable, Equatable { |
| 4 | + let x: Int |
| 5 | + let y: Int |
| 6 | + |
| 7 | + static let origin = Point(x: 0, y: 0) |
| 8 | + |
| 9 | + func manhattan(_ p: Point) -> Int { |
| 10 | + abs(p.x - x) + abs(p.y - y) |
| 11 | + } |
| 12 | + |
| 13 | + func neighbors() -> [Point] { |
| 14 | + return [ |
| 15 | + self, |
| 16 | + Point(x: x, y: y - 1), |
| 17 | + Point(x: x - 1, y: y), |
| 18 | + Point(x: x + 1, y: y), |
| 19 | + Point(x: x, y: y + 1), |
| 20 | + ] |
| 21 | + } |
| 22 | +} |
| 23 | + |
| 24 | +struct World { |
| 25 | + let start: Point |
| 26 | + let goal: Point |
| 27 | + let bound: Point |
| 28 | + var up: Set<Point> |
| 29 | + var down: Set<Point> |
| 30 | + var left: Set<Point> |
| 31 | + var right: Set<Point> |
| 32 | + |
| 33 | + func contains(_ p: Point) -> Bool { |
| 34 | + if p == goal || p == start { |
| 35 | + return true |
| 36 | + } |
| 37 | + if !(1...bound.x ~= p.x && 1...bound.y ~= p.y) { |
| 38 | + return false |
| 39 | + } |
| 40 | + return !(up.contains(p) || down.contains(p) || left.contains(p) || right.contains(p)) |
| 41 | + } |
| 42 | + |
| 43 | + mutating func step() { |
| 44 | + up = Set(up.map({ p in |
| 45 | + p.y == 1 ? Point(x: p.x, y: bound.y) : Point(x: p.x, y: p.y - 1) |
| 46 | + })) |
| 47 | + down = Set(down.map({ p in |
| 48 | + p.y == bound.y ? Point(x: p.x, y: 1) : Point(x: p.x, y: p.y + 1) |
| 49 | + })) |
| 50 | + left = Set(left.map({ p in |
| 51 | + p.x == 1 ? Point(x: bound.x, y: p.y) : Point(x: p.x - 1, y: p.y) |
| 52 | + })) |
| 53 | + right = Set(right.map({ p in |
| 54 | + p.x == bound.x ? Point(x: 1, y: p.y) : Point(x: p.x + 1, y: p.y) |
| 55 | + })) |
| 56 | + } |
| 57 | + |
| 58 | + func show() -> String { |
| 59 | + var result = [Character]() |
| 60 | + for y in 0...(1 + bound.y) { |
| 61 | + for x in 0...(1 + bound.x) { |
| 62 | + let p = Point(x: x, y: y) |
| 63 | + if up.contains(p) { |
| 64 | + result.append("^") |
| 65 | + } else if down.contains(p) { |
| 66 | + result.append("v") |
| 67 | + } else if left.contains(p) { |
| 68 | + result.append("<") |
| 69 | + } else if right.contains(p) { |
| 70 | + result.append(">") |
| 71 | + } else if contains(p) { |
| 72 | + result.append(".") |
| 73 | + } else { |
| 74 | + result.append(" ") |
| 75 | + } |
| 76 | + } |
| 77 | + result.append("\n") |
| 78 | + } |
| 79 | + result.append("\n") |
| 80 | + return String(result) |
| 81 | + } |
| 82 | +} |
| 83 | + |
| 84 | +func inputData() -> World { |
| 85 | + var maxX = Int.min |
| 86 | + var maxY = Int.min |
| 87 | + var start = Point.origin |
| 88 | + var goal = Point.origin |
| 89 | + var up = Set<Point>() |
| 90 | + var down = Set<Point>() |
| 91 | + var left = Set<Point>() |
| 92 | + var right = Set<Point>() |
| 93 | + var y = 0 |
| 94 | + for line in stringsFromFile() where line != "" { |
| 95 | + maxY = max(y, maxY) |
| 96 | + var x = 0 |
| 97 | + for ch in line { |
| 98 | + maxX = max(x, maxX) |
| 99 | + let p = Point(x: x, y: y) |
| 100 | + switch ch { |
| 101 | + case ".": |
| 102 | + if y == 0 { |
| 103 | + start = p |
| 104 | + } |
| 105 | + goal = p |
| 106 | + case "<": |
| 107 | + left.insert(p) |
| 108 | + case ">": |
| 109 | + right.insert(p) |
| 110 | + case "^": |
| 111 | + up.insert(p) |
| 112 | + case "v": |
| 113 | + down.insert(p) |
| 114 | + default: |
| 115 | + break |
| 116 | + } |
| 117 | + x += 1 |
| 118 | + } |
| 119 | + y += 1 |
| 120 | + } |
| 121 | + return World( |
| 122 | + start: start, |
| 123 | + goal: goal, |
| 124 | + bound: Point(x: maxX - 1, y: maxY - 1), |
| 125 | + up: up, |
| 126 | + down: down, |
| 127 | + left: left, |
| 128 | + right: right |
| 129 | + ) |
| 130 | +} |
| 131 | + |
| 132 | +func bfs(world: World) -> Int { |
| 133 | + var canvas = world |
| 134 | + var queue = [Point]() |
| 135 | + queue.append(world.start) |
| 136 | + var nextQueue = Set<Point>() |
| 137 | + var t = -1 |
| 138 | + |
| 139 | + while !(queue.isEmpty && nextQueue.isEmpty) { |
| 140 | + if queue.isEmpty { |
| 141 | + queue = Array(nextQueue.sorted(by: { world.goal.manhattan($0) < world.goal.manhattan($1)}).prefix(2000)) |
| 142 | + nextQueue = [] |
| 143 | + canvas.step() |
| 144 | + t += 1 |
| 145 | + } |
| 146 | + let cur = queue.remove(at: 0) |
| 147 | + if world.goal == cur { |
| 148 | + return t |
| 149 | + } |
| 150 | + for n in cur.neighbors() where canvas.contains(n) { |
| 151 | + nextQueue.insert(n) |
| 152 | + } |
| 153 | + } |
| 154 | + return -1 |
| 155 | +} |
| 156 | + |
| 157 | +public func part1() -> Int { |
| 158 | + bfs(world: inputData()) |
| 159 | +} |
| 160 | + |
0 commit comments