20/code.go

@@ -8,9 +8,8 @@ import (
 )
 
 type Point struct {
-	y, x      int
-	cost      int
-	cheatedAt *Point
+	y, x int
+	cost int
 }
 
 func (p *Point) key() string {
@@ -57,17 +56,18 @@ var directions [][]int = [][]int{
 	{0, -1}, {1, 0}, {0, 1}, {-1, 0},
 }
 
-func getMoves(current Point, matrix [][]byte, xMax, yMax int, cheat bool, cheats map[string]bool) []Point {
+func getMoves(current Point, matrix [][]byte, xMax, yMax int, cheat bool, cheats map[string]bool) ([]Point, bool) {
 	var moves []Point
 	for _, direction := range directions {
-		move := Point{x: current.x + direction[0], y: current.y + direction[1], cost: current.cost + 1, cheatedAt: current.cheatedAt}
+		move := Point{x: current.x + direction[0], y: current.y + direction[1], cost: current.cost + 1}
 		if move.x <= 0 || move.y <= 0 || move.x >= xMax || move.y >= yMax {
 			continue
 		}
 
 		if matrix[move.y][move.x] == '#' {
-			if cheat && !cheats[move.key()] && move.cheatedAt == nil {
-				move.cheatedAt = &move
+			if cheat && !cheats[move.key()] {
+				cheat = false
+				cheats[move.key()] = true
 				moves = append(moves, move)
 			}
 
@@ -77,7 +77,7 @@ func getMoves(current Point, matrix [][]byte, xMax, yMax int, cheat bool, cheats
 		moves = append(moves, move)
 	}
 
-	return moves
+	return moves, cheat
 }
 
 func hike(start *Point, matrix [][]byte, xMax, yMax int, cheat bool, cheats map[string]bool, bestWithoutCheating int, savings map[int]int) int {
@@ -92,23 +92,21 @@ func hike(start *Point, matrix [][]byte, xMax, yMax int, cheat bool, cheats map[
 		if matrix[current.y][current.x] == 'E' {
 			if current.cost <= cost {
 				cost = current.cost
-				if cheat && current.cost < bestWithoutCheating {
+				if current.cost < bestWithoutCheating {
 					saving := bestWithoutCheating - current.cost
 					savings[saving]++
-
-					cheats[current.cheatedAt.key()] = true
 				}
 			}
 
 			continue
 		}
 
-		newMoves := getMoves(current, matrix, xMax, yMax, cheat, cheats)
-		for _, newMove := range newMoves {
-			if cheat && newMove.cost >= bestWithoutCheating {
-				continue
-			}
+		newMoves, cheated := getMoves(current, matrix, xMax, yMax, cheat, cheats)
+		if !cheated {
+			cheat = false
+		}
 
+		for _, newMove := range newMoves {
 			if visited[newMove.key()] == 0 || visited[newMove.key()] >= newMove.cost {
 				moves = append(moves, newMove)
 				visited[newMove.key()] = newMove.cost
@@ -126,12 +124,15 @@ func part1(start *Point, matrix [][]byte, atLeast int) int {
 	cheats := make(map[string]bool)
 	savings := make(map[int]int)
 	bestWithoutCheating := hike(start, matrix, xMax, yMax, false, cheats, 0, savings)
-	haltAt := bestWithoutCheating - atLeast
+	var prevCheats int
 	for {
-		score := hike(start, matrix, xMax, yMax, true, cheats, bestWithoutCheating, savings)
-		if score >= haltAt {
+		hike(start, matrix, xMax, yMax, true, cheats, bestWithoutCheating, savings)
+		increase := len(cheats)
+		if prevCheats == increase {
 			break
 		}
+
+		prevCheats = increase
 	}
 
 	var count int

20/description.txt

@@ -121,3 +121,65 @@ In this example, the total number of cheats (grouped by the amount of time they
     There is one cheat that saves 64 picoseconds.
 
 You aren't sure what the conditions of the racetrack will be like, so to give yourself as many options as possible, you'll need a list of the best cheats. How many cheats would save you at least 100 picoseconds?
+
+The first half of this puzzle is complete! It provides one gold star: *
+--- Part Two ---
+
+The programs seem perplexed by your list of cheats. Apparently, the two-picosecond cheating rule was deprecated several milliseconds ago! The latest version of the cheating rule permits a single cheat that instead lasts at most 20 picoseconds.
+
+Now, in addition to all the cheats that were possible in just two picoseconds, many more cheats are possible. This six-picosecond cheat saves 76 picoseconds:
+
+###############
+#...#...#.....#
+#.#.#.#.#.###.#
+#S#...#.#.#...#
+#1#####.#.#.###
+#2#####.#.#...#
+#3#####.#.###.#
+#456.E#...#...#
+###.#######.###
+#...###...#...#
+#.#####.#.###.#
+#.#...#.#.#...#
+#.#.#.#.#.#.###
+#...#...#...###
+###############
+
+Because this cheat has the same start and end positions as the one above, it's the same cheat, even though the path taken during the cheat is different:
+
+###############
+#...#...#.....#
+#.#.#.#.#.###.#
+#S12..#.#.#...#
+###3###.#.#.###
+###4###.#.#...#
+###5###.#.###.#
+###6.E#...#...#
+###.#######.###
+#...###...#...#
+#.#####.#.###.#
+#.#...#.#.#...#
+#.#.#.#.#.#.###
+#...#...#...###
+###############
+
+Cheats don't need to use all 20 picoseconds; cheats can last any amount of time up to and including 20 picoseconds (but can still only end when the program is on normal track). Any cheat time not used is lost; it can't be saved for another cheat later.
+
+You'll still need a list of the best cheats, but now there are even more to choose between. Here are the quantities of cheats in this example that save 50 picoseconds or more:
+
+    There are 32 cheats that save 50 picoseconds.
+    There are 31 cheats that save 52 picoseconds.
+    There are 29 cheats that save 54 picoseconds.
+    There are 39 cheats that save 56 picoseconds.
+    There are 25 cheats that save 58 picoseconds.
+    There are 23 cheats that save 60 picoseconds.
+    There are 20 cheats that save 62 picoseconds.
+    There are 19 cheats that save 64 picoseconds.
+    There are 12 cheats that save 66 picoseconds.
+    There are 14 cheats that save 68 picoseconds.
+    There are 12 cheats that save 70 picoseconds.
+    There are 22 cheats that save 72 picoseconds.
+    There are 4 cheats that save 74 picoseconds.
+    There are 3 cheats that save 76 picoseconds.
+
+Find the best cheats using the updated cheating rules. How many cheats would save you at least 100 picoseconds?