SPFA (Queue BF)

function spfaPathfind(grid, start, end, allowDiag) {
  const rows = grid.length;
  const cols = grid[0].length;
  const dist = Matrix(rows, cols, Infinity);
  const inQueue = Matrix(rows, cols, false);
  const prev = new Map();
  const queue = [[start[0], start[1]]];
  dist[start[0]][start[1]] = 0;
  inQueue[start[0]][start[1]] = true;
  while (queue.length) {
    const __pattern1 = queue.shift();
    const r = __pattern1[0];
    const c = __pattern1[1];
    inQueue[r][c] = false;
    visitNode(r, c);
    for (const [nr, nc] of getNeighbors(grid, r, c, allowDiag)) {
      const nd = dist[r][c] + stepCost(grid, r, c, nr, nc);
      if (nd < dist[nr][nc]) {
        dist[nr][nc] = nd;
        prev.set(key(nr, nc), [r, c]);
        if (!inQueue[nr][nc]) {
          queue.push([nr, nc]);
          inQueue[nr][nc] = true;
          pushFrontier(nr, nc);
        }
      }
    }
  }
  if (dist[end[0]][end[1]] !== Infinity) {
    reconstructPath(prev, start, end);
  } else {
    reportNoPath();
  }
}

def spfaPathfind(grid, start, end, allowDiag):
    rows = grid.length
    cols = grid[0].length
    dist = Matrix(rows, cols, Infinity)
    inQueue = Matrix(rows, cols, False)
    prev = Map()
    queue = [[start[0], start[1]]]
    dist[start[0]][start[1]] = 0
    inQueue[start[0]][start[1]] = True
    while queue.length:
        __pattern1 = queue.shift()
        r = __pattern1[0]
        c = __pattern1[1]
        inQueue[r][c] = False
        visitNode(r, c)
        for nr, nc in getNeighbors(grid, r, c, allowDiag):
            nd = (dist[r][c] + stepCost(grid, r, c, nr, nc))
            if (nd < dist[nr][nc]):
                dist[nr][nc] = nd
                prev.set(key(nr, nc), [r, c])
                if not inQueue[nr][nc]:
                    queue.push([nr, nc])
                    inQueue[nr][nc] = True
                    pushFrontier(nr, nc)
    if (dist[end[0]][end[1]] != Infinity):
        reconstructPath(prev, start, end)
    else:
        reportNoPath()

#include <vector>
#include <algorithm>
void spfaPathfind(int grid, int start, int end, int allowDiag) {
    auto rows = grid.length;
    auto cols = grid[0].length;
    auto dist = Matrix(rows, cols, Infinity);
    auto inQueue = Matrix(rows, cols, false);
    auto prev = Map();
    auto queue = [[start[0], start[1]]];
    dist[start[0]][start[1]] = 0;
    inQueue[start[0]][start[1]] = true;
    while(queue.length) {
        auto __pattern1 = queue.shift();
        auto r = __pattern1[0];
        auto c = __pattern1[1];
        inQueue[r][c] = false;
        visitNode(r, c);
        for(auto& [nr, nc] : getNeighbors(grid, r, c, allowDiag)) {
            auto nd = (dist[r][c] + stepCost(grid, r, c, nr, nc));
            if((nd < dist[nr][nc])) {
                dist[nr][nc] = nd;
                prev.set(key(nr, nc), [r, c]);
                if(!inQueue[nr][nc]) {
                    queue.push([nr, nc]);
                    inQueue[nr][nc] = true;
                    pushFrontier(nr, nc);
                }
            }
        }
    }
    if((dist[end[0]][end[1]] != Infinity)) {
        reconstructPath(prev, start, end);
    } else {
        reportNoPath();
    }
}

public void spfaPathfind(int grid, int start, int end, int allowDiag) {
    var rows = grid.length;
    var cols = grid[0].length;
    var dist = Matrix(rows, cols, Infinity);
    var inQueue = Matrix(rows, cols, false);
    var prev = Map();
    var queue = [[start[0], start[1]]];
    dist[start[0]][start[1]] = 0;
    inQueue[start[0]][start[1]] = true;
    while(queue.length) {
        var __pattern1 = queue.shift();
        var r = __pattern1[0];
        var c = __pattern1[1];
        inQueue[r][c] = false;
        visitNode(r, c);
        foreach(var (nr, nc) in getNeighbors(grid, r, c, allowDiag)) {
            var nd = (dist[r][c] + stepCost(grid, r, c, nr, nc));
            if((nd < dist[nr][nc])) {
                dist[nr][nc] = nd;
                prev.set(key(nr, nc), [r, c]);
                if(!inQueue[nr][nc]) {
                    queue.push([nr, nc]);
                    inQueue[nr][nc] = true;
                    pushFrontier(nr, nc);
                }
            }
        }
    }
    if((dist[end[0]][end[1]] != Infinity)) {
        reconstructPath(prev, start, end);
    } else {
        reportNoPath();
    }
}

#include <stdio.h>
void spfaPathfind(int grid, int start, int end, int allowDiag) {
    var rows = grid.length;
    var cols = grid[0].length;
    var dist = Matrix(rows, cols, Infinity);
    var inQueue = Matrix(rows, cols, false);
    var prev = Map();
    var queue = [[start[0], start[1]]];
    dist[start[0]][start[1]] = 0;
    inQueue[start[0]][start[1]] = true;
    while(queue.length) {
        var __pattern1 = queue.shift();
        var r = __pattern1[0];
        var c = __pattern1[1];
        inQueue[r][c] = false;
        visitNode(r, c);
        for(int _fod_i = 0; _fod_i < getNeighbors(grid, r, c, allowDiag)_len; _fod_i++) {
            int nr = getNeighbors(grid, r, c, allowDiag)[_fod_i][0];
            int nc = getNeighbors(grid, r, c, allowDiag)[_fod_i][1];
            var nd = (dist[r][c] + stepCost(grid, r, c, nr, nc));
            if((nd < dist[nr][nc])) {
                dist[nr][nc] = nd;
                prev.set(key(nr, nc), [r, c]);
                if(!inQueue[nr][nc]) {
                    queue.push([nr, nc]);
                    inQueue[nr][nc] = true;
                    pushFrontier(nr, nc);
                }
            }
        }
    }
    if((dist[end[0]][end[1]] != Infinity)) {
        reconstructPath(prev, start, end);
    } else {
        reportNoPath();
    }
}