Simulated Annealing

function annealingPathfind(grid, start, end, allowDiag, hFn) {
  const h = hFn || HEURISTICS.manhattan;
  const prev = new Map();
  let r = start[0];
  let c = start[1];
  let temp = 1.0;
  for (let step = 0; step < grid.length * grid[0].length * 2; step++) {
    visitNode(r, c);
    if (r === end[0] && c === end[1]) {
      reconstructPath(prev, start, end);
      return;
    }
    const neighbors = getNeighbors(grid, r, c, allowDiag);
    if (!neighbors.length) break;
    const __pattern1 = neighbors[Math.floor(Math.random() * neighbors.length)];
    const nr = __pattern1[0];
    const nc = __pattern1[1];
    const delta = h(r, c, end[0], end[1]) - h(nr, nc, end[0], end[1]);
    if (delta > 0 || Math.exp(delta / temp) > Math.random()) {
      const nk = key(nr, nc);
      if (!prev.has(nk) && !(nr === start[0] && nc === start[1])) prev.set(nk, [r, c]);
      r = nr;
      c = nc;
      pushFrontier(r, c);
    }
    temp *= 0.99;
    if (temp < 0.001) temp = 0.001;
  }
  reportNoPath();
}

def annealingPathfind(grid, start, end, allowDiag, hFn):
    h = (hFn or HEURISTICS.manhattan)
    prev = Map()
    r = start[0]
    c = start[1]
    temp = 1
    for step in range(((grid.length * grid[0].length) * 2)):
        visitNode(r, c)
        if ((r == end[0]) and (c == end[1])):
            reconstructPath(prev, start, end)
            return
        neighbors = getNeighbors(grid, r, c, allowDiag)
        if not neighbors.length:
            break
        __pattern1 = neighbors[int((random() * neighbors.length))]
        nr = __pattern1[0]
        nc = __pattern1[1]
        delta = (h(r, c, end[0], end[1]) - h(nr, nc, end[0], end[1]))
        if ((delta > 0) or (exp((delta / temp)) > random())):
            nk = key(nr, nc)
            if (not prev.has(nk) and not ((nr == start[0]) and (nc == start[1]))):
                prev.set(nk, [r, c])
            r = nr
            c = nc
            pushFrontier(r, c)
        temp *= 0.99
        if (temp < 0.001):
            temp = 0.001
    reportNoPath()

#include <vector>
#include <algorithm>
#include <cmath>
void annealingPathfind(int grid, int start, int end, int allowDiag, int hFn) {
    auto h = (hFn || HEURISTICS.manhattan);
    auto prev = Map();
    auto r = start[0];
    auto c = start[1];
    auto temp = 1;
    for(int step=0; step<((grid.length * grid[0].length) * 2); step++) {
        visitNode(r, c);
        if(((r == end[0]) && (c == end[1]))) {
            reconstructPath(prev, start, end);
            return;
        }
        auto neighbors = getNeighbors(grid, r, c, allowDiag);
        if(!neighbors.length) {
            break;
        }
        auto __pattern1 = neighbors[(int)std::floor((std::random() * neighbors.length))];
        auto nr = __pattern1[0];
        auto nc = __pattern1[1];
        auto delta = (h(r, c, end[0], end[1]) - h(nr, nc, end[0], end[1]));
        if(((delta > 0) || (std::exp((delta / temp)) > std::random()))) {
            auto nk = key(nr, nc);
            if((!prev.has(nk) && !((nr == start[0]) && (nc == start[1])))) {
                prev.set(nk, [r, c]);
            }
            r = nr;
            c = nc;
            pushFrontier(r, c);
        }
        temp *= 0.99;
        if((temp < 0.001)) {
            temp = 0.001;
        }
    }
    reportNoPath();
}

public void annealingPathfind(int grid, int start, int end, int allowDiag, int hFn) {
    var h = (hFn || HEURISTICS.manhattan);
    var prev = Map();
    var r = start[0];
    var c = start[1];
    var temp = 1;
    for(int step=0; step<((grid.length * grid[0].length) * 2); step++) {
        visitNode(r, c);
        if(((r == end[0]) && (c == end[1]))) {
            reconstructPath(prev, start, end);
            return;
        }
        var neighbors = getNeighbors(grid, r, c, allowDiag);
        if(!neighbors.length) {
            break;
        }
        var __pattern1 = neighbors[(int)Math.Floor((double)(random() * neighbors.length))];
        var nr = __pattern1[0];
        var nc = __pattern1[1];
        var delta = (h(r, c, end[0], end[1]) - h(nr, nc, end[0], end[1]));
        if(((delta > 0) || (exp((delta / temp)) > random()))) {
            var nk = key(nr, nc);
            if((!prev.has(nk) && !((nr == start[0]) && (nc == start[1])))) {
                prev.set(nk, [r, c]);
            }
            r = nr;
            c = nc;
            pushFrontier(r, c);
        }
        temp *= 0.99;
        if((temp < 0.001)) {
            temp = 0.001;
        }
    }
    reportNoPath();
}

#include <stdio.h>
#include <math.h>
void annealingPathfind(int grid, int start, int end, int allowDiag, int hFn) {
    var h = (hFn || HEURISTICS.manhattan);
    var prev = Map();
    var r = start[0];
    var c = start[1];
    var temp = 1;
    for(int step=0; step<((grid.length * grid[0].length) * 2); step++) {
        visitNode(r, c);
        if(((r == end[0]) && (c == end[1]))) {
            reconstructPath(prev, start, end);
            return;
        }
        var neighbors = getNeighbors(grid, r, c, allowDiag);
        if(!neighbors.length) {
            break;
        }
        var __pattern1 = neighbors[(int)floor((random() * neighbors.length))];
        var nr = __pattern1[0];
        var nc = __pattern1[1];
        var delta = (h(r, c, end[0], end[1]) - h(nr, nc, end[0], end[1]));
        if(((delta > 0) || (exp((delta / temp)) > random()))) {
            var nk = key(nr, nc);
            if((!prev.has(nk) && !((nr == start[0]) && (nc == start[1])))) {
                prev.set(nk, [r, c]);
            }
            r = nr;
            c = nc;
            pushFrontier(r, c);
        }
        temp *= 0.99;
        if((temp < 0.001)) {
            temp = 0.001;
        }
    }
    reportNoPath();
}