//! Pathfinder algorithms on a grid. The grid is stack-based, we only use heap allocations
//! in solvers.

/// Various predefined valid neighbour directions on a 2D grid.

// XXX: 3D? More dimensions?

/// Grid for various pathfinder algorithms.
/// `T` is the type of Grid items.
/// `GRID_ROWS` and `GRID_COLS` defines the Grid size.
/// `dir` is an array of arrays defining the valid neighbour moves.

        /// Parses a grid-file located in `path`. The items must be separated with `sep`.

        pub fn dijkstra(self: @This(), allocator: std.mem.Allocator, start: [2]usize, end: [2]usize) !T {

        /// Finds shortest path between `start` and `goal` using Dijkstra's algorithm.
        /// Returns the path length or `error.PathNotFound`.
        pub fn dijkstra(self: @This(), allocator: std.mem.Allocator, start: [2]usize, goal: [2]usize) !T {

                if (std.meta.eql(curr.state, end)) {

                if (std.meta.eql(curr.state, goal)) {

    const end_str =

    const goal_str =

    const end = try parseInput(end_str);

    const goal = try parseInput(goal_str);

    const ret = try graph.dijkstra(start, end);

    const ret = try graph.dijkstra(start, goal);

        pub fn dijkstra(self: *@This(), start: T, end: T) !usize {

        pub fn dijkstra(self: *@This(), start: T, goal: T) !usize {

                if (std.meta.eql(curr.state, end)) {

                if (std.meta.eql(curr.state, goal)) {