scubbo/advent-of-code-2024
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Generic implementation of Dijkstra

Browse Source
This commit is contained in:
Jack Jackson 2025-01-21 18:54:53 -08:00
parent 68c38385ff
commit d85d294c58
1 changed files with 150 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

151
solutions/util.zig
View File

@ -3,6 +3,8 @@
// and that seems awful.
const std = @import("std");
const print = std.debug.print;
const expect = @import("std").testing.expect;
pub fn getInputFile(problemNumber: []const u8, isTestCase: bool) ![]u8 {
return concatString("inputs/", try concatString(problemNumber, try concatString("/", try concatString(if (isTestCase) "test" else "real", ".txt"))));
@ -132,7 +134,154 @@ pub fn log(comptime message: []const u8, args: anytype, debug: bool) void {
}
}
const expect = @import("std").testing.expect;
// Basic implementation of Dijkstra - given start and end, find the length of the shortest path that joins them.
// Assumes that all links have cost 1.
const DijkstraError = error{NoPathFound};
// I hate that I have to pass in an allocator to `neighbours`, but it seems necessary in order to be able to free
// whatever it returns.
pub fn dijkstra(T: type, neighbours: *const fn (t: *T, allocator: std.mem.Allocator) []T, start: T, end: T, debug: bool, allocator: std.mem.Allocator) DijkstraError!u32 {
var visited = std.AutoHashMap(T, void).init(allocator);
defer visited.deinit();
var distances = std.AutoHashMap(T, u32).init(allocator);
defer distances.deinit();
distances.put(start, 0) catch unreachable;
// Not strictly necessary - we could just iterate over all keys of `distances` and filter out those that are
// `visited` - but this certainly trims down the unnecessary debug logging, and I have an intuition (though haven't
// proved) that it'll slightly help performance.
var unvisited_candidates = std.AutoHashMap(T, void).init(allocator);
defer unvisited_candidates.deinit();
unvisited_candidates.put(start, {}) catch unreachable;
return while (true) {
var cand_it = unvisited_candidates.keyIterator();
var curr: T = undefined;
var lowest_distance_found: u32 = std.math.maxInt(u32);
while (cand_it.next()) |cand| {
const actual_candidate = cand.*; // Necessary to avoid pointer weirdness
log("Considering {s} as the next curr ", .{actual_candidate}, debug);
const distance_of_candidate = distances.get(actual_candidate) orelse std.math.maxInt(u32);
if (distance_of_candidate < lowest_distance_found) {
log("and it is a possibility!\n", .{}, debug);
curr = actual_candidate;
lowest_distance_found = distance_of_candidate;
} else {
log("but rejecting it because it already has a shorter minimum-distance({} vs {})\n", .{ distance_of_candidate, lowest_distance_found }, debug);
}
}
if (lowest_distance_found == std.math.maxInt(u32)) {
log("ERROR - iterated over all candidates, but found none with non-infinite distance", .{}, debug);
break DijkstraError.NoPathFound;
}
log("Settled on {s} as the new curr", .{curr}, debug);
if (std.meta.eql(curr, end)) {
log(" and that is the target, so we're done!\n", .{}, debug);
break lowest_distance_found;
} else {
log(" - now exploring its neighbours\n", .{}, debug);
}
// Haven't terminated yet => we're still looking. Check neighbours, and update their min-distance
const distance_of_neighbour_from_current = lowest_distance_found + 1;
const neighbours_of_curr = neighbours(&curr, allocator);
for (neighbours_of_curr) |neighbour| {
if (visited.contains(neighbour)) {
continue;
}
const distance_response = distances.getOrPut(neighbour) catch unreachable;
if (!distance_response.found_existing) {
log("Adding a new (first) distance to {s} (via {s}) - {}\n", .{ neighbour, curr, distance_of_neighbour_from_current }, debug);
distance_response.value_ptr.* = distance_of_neighbour_from_current;
unvisited_candidates.put(neighbour, {}) catch unreachable;
} else {
if (distance_response.value_ptr.* > distance_of_neighbour_from_current) {
log("Overriding distance for neighbour {s} because distance of path from {s} ({}) is less than current value ({})\n", .{ neighbour, curr, distance_of_neighbour_from_current, distance_response.value_ptr.* }, debug);
distance_response.value_ptr.* = distance_of_neighbour_from_current;
}
}
}
allocator.free(neighbours_of_curr);
visited.put(curr, {}) catch unreachable;
_ = unvisited_candidates.remove(curr);
log("{s} has now been fully visited - loop begins again\n", .{curr}, debug);
};
}
// I tried declaring this within the `test "Dijkstra`", but this method of anonymous functions:
// https://gencmurat.com/en/posts/zig-anonymus-functions-and-closures/
// didn't work for me when trying to pass an Allocator down inside. The following attempt:
//
// ```
// const curry = struct {
// pub fn call(T: type, alloc: std.mem.Allocator) *const fn (t: T) []T {
// const Context = struct { alloc: std.mem.Allocator };
//
// const context = Context{ .alloc = alloc };
//
// return struct {
// pub fn call(p: Point) []Point {
// const response = std.ArrayList(Point).init(context.alloc);
// for (p.neighbours(15, 15, context.alloc)) |n| {
// if (data[16 * n.y + n.x] == '.') {
// response.append(n) catch unreachable;
// }
// }
// return response.toOwnedSlice() catch unreachable;
// }
// }.call;
// }
// }.call;
// ```
// gave `'context' not accessible from inner function`
fn private_dijkstra_test_neighbours_function(p: *Point, allocator: std.mem.Allocator) []Point {
// From AoC 2024 Day 20
const data =
\\###############
\\#...#...#.....#
\\#.#.#.#.#.###.#
\\#.#...#.#.#...#
\\#######.#.#.###
\\#######.#.#...#
\\#######.#.###.#
\\###...#...#...#
\\###.#######.###
\\#...###...#...#
\\#.#####.#.###.#
\\#.#...#.#.#...#
\\#.#.#.#.#.#.###
\\#...#...#...###
\\###############
;
var response = std.ArrayList(Point).init(allocator);
const ns = p.neighbours(15, 15, allocator);
for (ns) |n| {
if (data[16 * n.y + n.x] == '.') {
response.append(n) catch unreachable;
}
}
allocator.free(ns);
return response.toOwnedSlice() catch unreachable;
}
test "Dijkstra" {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
const start = Point{ .x = 1, .y = 3 };
const end = Point{ .x = 5, .y = 7 };
const result = dijkstra(Point, private_dijkstra_test_neighbours_function, start, end, false, allocator) catch unreachable;
// print("Dijkstra result is {}\n", .{result});
try expect(result == 84);
}
test {
const result = try concatString("abc", "def");