Fringe Search

function fringePathfind(grid, start, end, allowDiag, hFn) {
  const h = hFn || HEURISTICS.manhattan;
  const prev = new Map();
  const bestCost = new Map([[key(start[0], start[1]), 0]]);
  const startNode = {
    r: start[0],
    c: start[1],
    g: 0
  };
  let fringe = [startNode];
  let threshold = h(start[0], start[1], end[0], end[1]);
  while (fringe.length) {
    const nextFringe = [];
    let minNext = Infinity;
    for (const node of fringe) {
      const f = node.g + h(node.r, node.c, end[0], end[1]);
      if (f > threshold) {
        if (f < minNext) minNext = f;
        continue;
      }
      visitNode(node.r, node.c);
      if (node.r === end[0] && node.c === end[1]) {
        reconstructPath(prev, start, end);
        return;
      }
      for (const [nr, nc] of getNeighbors(grid, node.r, node.c, allowDiag)) {
        const ng = node.g + stepCost(grid, node.r, node.c, nr, nc);
        const neighborKey = key(nr, nc);
        if (!bestCost.has(neighborKey) || ng < bestCost.get(neighborKey)) {
          bestCost.set(neighborKey, ng);
          prev.set(neighborKey, [node.r, node.c]);
          nextFringe.push({
            r: nr,
            c: nc,
            g: ng
          });
          pushFrontier(nr, nc);
        }
      }
    }
    if (!nextFringe.length) {
      if (minNext === Infinity) break;
      threshold = minNext;
    }
    fringe = nextFringe;
  }
  reportNoPath();
}

def fringePathfind(grid, start, end, allowDiag, hFn):
    h = (hFn or HEURISTICS.manhattan)
    prev = Map()
    bestCost = Map([[key(start[0], start[1]), 0]])
    startNode = {r: start[0], c: start[1], g: 0}
    fringe = [startNode]
    threshold = h(start[0], start[1], end[0], end[1])
    while fringe.length:
        nextFringe = []
        minNext = Infinity
        for node in fringe:
            f = (node.g + h(node.r, node.c, end[0], end[1]))
            if (f > threshold):
                if (f < minNext):
                    minNext = f
                continue
            visitNode(node.r, node.c)
            if ((node.r == end[0]) and (node.c == end[1])):
                reconstructPath(prev, start, end)
                return
            for nr, nc in getNeighbors(grid, node.r, node.c, allowDiag):
                ng = (node.g + stepCost(grid, node.r, node.c, nr, nc))
                neighborKey = key(nr, nc)
                if (not bestCost.has(neighborKey) or (ng < bestCost.get(neighborKey))):
                    bestCost.set(neighborKey, ng)
                    prev.set(neighborKey, [node.r, node.c])
                    nextFringe.push({r: nr, c: nc, g: ng})
                    pushFrontier(nr, nc)
        if not nextFringe.length:
            if (minNext == Infinity):
                break
            threshold = minNext
        fringe = nextFringe
    reportNoPath()

#include <vector>
#include <algorithm>
void fringePathfind(int grid, int start, int end, int allowDiag, int hFn) {
    auto h = (hFn || HEURISTICS.manhattan);
    auto prev = Map();
    auto bestCost = Map([[key(start[0], start[1]), 0]]);
    auto startNode = {r: start[0], c: start[1], g: 0};
    auto fringe = [startNode];
    auto threshold = h(start[0], start[1], end[0], end[1]);
    while(fringe.length) {
        auto nextFringe = [];
        auto minNext = Infinity;
        /* for-of not directly supported */
        if(!nextFringe.length) {
            if((minNext == Infinity)) {
                break;
            }
            threshold = minNext;
        }
        fringe = nextFringe;
    }
    reportNoPath();
}

public void fringePathfind(int grid, int start, int end, int allowDiag, int hFn) {
    var h = (hFn || HEURISTICS.manhattan);
    var prev = Map();
    var bestCost = Map([[key(start[0], start[1]), 0]]);
    var startNode = {r: start[0], c: start[1], g: 0};
    var fringe = [startNode];
    var threshold = h(start[0], start[1], end[0], end[1]);
    while(fringe.length) {
        var nextFringe = [];
        var minNext = Infinity;
        /* for-of not directly supported */
        if(!nextFringe.length) {
            if((minNext == Infinity)) {
                break;
            }
            threshold = minNext;
        }
        fringe = nextFringe;
    }
    reportNoPath();
}

#include <stdio.h>
void fringePathfind(int grid, int start, int end, int allowDiag, int hFn) {
    var h = (hFn || HEURISTICS.manhattan);
    var prev = Map();
    var bestCost = Map([[key(start[0], start[1]), 0]]);
    var startNode = {r: start[0], c: start[1], g: 0};
    var fringe = [startNode];
    var threshold = h(start[0], start[1], end[0], end[1]);
    while(fringe.length) {
        var nextFringe = [];
        var minNext = Infinity;
        /* for-of not directly supported in C */
        if(!nextFringe.length) {
            if((minNext == Infinity)) {
                break;
            }
            threshold = minNext;
        }
        fringe = nextFringe;
    }
    reportNoPath();
}