Greedy Best-First

function greedyPathfind(grid, start, end, allowDiag, hFn) {
  const h = hFn || HEURISTICS.manhattan;
  const visited = new Set([key(start[0], start[1])]);
  const prev = new Map();
  const heap = PriorityQueue("priority");
  priorityQueuePush(heap, {
    priority: h(start[0], start[1], end[0], end[1]),
    row: start[0],
    col: start[1]
  });
  while (priorityQueueSize(heap)) {
    const __pattern1 = priorityQueuePop(heap);
    const cr = __pattern1.row;
    const cc = __pattern1.col;
    visitNode(cr, cc);
    if (cr === end[0] && cc === end[1]) {
      reconstructPath(prev, start, end);
      return;
    }
    for (const [nr, nc] of getNeighbors(grid, cr, cc, allowDiag)) {
      const neighborKey = key(nr, nc);
      if (visited.has(neighborKey)) continue;
      visited.add(neighborKey);
      prev.set(neighborKey, [cr, cc]);
      priorityQueuePush(heap, {
        priority: h(nr, nc, end[0], end[1]),
        row: nr,
        col: nc
      });
      pushFrontier(nr, nc);
    }
  }
  reportNoPath();
}

def greedyPathfind(grid, start, end, allowDiag, hFn):
    h = (hFn or HEURISTICS.manhattan)
    visited = Set([key(start[0], start[1])])
    prev = Map()
    heap = PriorityQueue("priority")
    priorityQueuePush(heap, {priority: h(start[0], start[1], end[0], end[1]), row: start[0], col: start[1]})
    while priorityQueueSize(heap):
        __pattern1 = priorityQueuePop(heap)
        cr = __pattern1.row
        cc = __pattern1.col
        visitNode(cr, cc)
        if ((cr == end[0]) and (cc == end[1])):
            reconstructPath(prev, start, end)
            return
        for nr, nc in getNeighbors(grid, cr, cc, allowDiag):
            neighborKey = key(nr, nc)
            if visited.has(neighborKey):
                continue
            visited.add(neighborKey)
            prev.set(neighborKey, [cr, cc])
            priorityQueuePush(heap, {priority: h(nr, nc, end[0], end[1]), row: nr, col: nc})
            pushFrontier(nr, nc)
    reportNoPath()

#include <vector>
#include <algorithm>
void greedyPathfind(int grid, int start, int end, int allowDiag, int hFn) {
    auto h = (hFn || HEURISTICS.manhattan);
    auto visited = Set([key(start[0], start[1])]);
    auto prev = Map();
    auto heap = PriorityQueue("priority");
    priorityQueuePush(heap, {priority: h(start[0], start[1], end[0], end[1]), row: start[0], col: start[1]});
    while(priorityQueueSize(heap)) {
        auto __pattern1 = priorityQueuePop(heap);
        auto cr = __pattern1.row;
        auto cc = __pattern1.col;
        visitNode(cr, cc);
        if(((cr == end[0]) && (cc == end[1]))) {
            reconstructPath(prev, start, end);
            return;
        }
        for(auto& [nr, nc] : getNeighbors(grid, cr, cc, allowDiag)) {
            auto neighborKey = key(nr, nc);
            if(visited.has(neighborKey)) {
                continue;
            }
            visited.add(neighborKey);
            prev.set(neighborKey, [cr, cc]);
            priorityQueuePush(heap, {priority: h(nr, nc, end[0], end[1]), row: nr, col: nc});
            pushFrontier(nr, nc);
        }
    }
    reportNoPath();
}

public void greedyPathfind(int grid, int start, int end, int allowDiag, int hFn) {
    var h = (hFn || HEURISTICS.manhattan);
    var visited = Set([key(start[0], start[1])]);
    var prev = Map();
    var heap = PriorityQueue("priority");
    priorityQueuePush(heap, {priority: h(start[0], start[1], end[0], end[1]), row: start[0], col: start[1]});
    while(priorityQueueSize(heap)) {
        var __pattern1 = priorityQueuePop(heap);
        var cr = __pattern1.row;
        var cc = __pattern1.col;
        visitNode(cr, cc);
        if(((cr == end[0]) && (cc == end[1]))) {
            reconstructPath(prev, start, end);
            return;
        }
        foreach(var (nr, nc) in getNeighbors(grid, cr, cc, allowDiag)) {
            var neighborKey = key(nr, nc);
            if(visited.has(neighborKey)) {
                continue;
            }
            visited.add(neighborKey);
            prev.set(neighborKey, [cr, cc]);
            priorityQueuePush(heap, {priority: h(nr, nc, end[0], end[1]), row: nr, col: nc});
            pushFrontier(nr, nc);
        }
    }
    reportNoPath();
}

#include <stdio.h>
void greedyPathfind(int grid, int start, int end, int allowDiag, int hFn) {
    var h = (hFn || HEURISTICS.manhattan);
    var visited = Set([key(start[0], start[1])]);
    var prev = Map();
    var heap = PriorityQueue("priority");
    priorityQueuePush(heap, {priority: h(start[0], start[1], end[0], end[1]), row: start[0], col: start[1]});
    while(priorityQueueSize(heap)) {
        var __pattern1 = priorityQueuePop(heap);
        var cr = __pattern1.row;
        var cc = __pattern1.col;
        visitNode(cr, cc);
        if(((cr == end[0]) && (cc == end[1]))) {
            reconstructPath(prev, start, end);
            return;
        }
        for(int _fod_i = 0; _fod_i < getNeighbors(grid, cr, cc, allowDiag)_len; _fod_i++) {
            int nr = getNeighbors(grid, cr, cc, allowDiag)[_fod_i][0];
            int nc = getNeighbors(grid, cr, cc, allowDiag)[_fod_i][1];
            var neighborKey = key(nr, nc);
            if(visited.has(neighborKey)) {
                continue;
            }
            visited.add(neighborKey);
            prev.set(neighborKey, [cr, cc]);
            priorityQueuePush(heap, {priority: h(nr, nc, end[0], end[1]), row: nr, col: nc});
            pushFrontier(nr, nc);
        }
    }
    reportNoPath();
}