{"data":{"allMarkdownRemark":{"edges":[{"node":{"frontmatter":{"order":1,"friendlyName":"Current Cost","solverKey":"currentCost","type":"bounding-strategy","defaults":{"evaluatingDetailLevel":2,"maxEvaluatingDetailLevel":2}},"html":"

Current Cost

\n

Even more naive than Cheapest Edges, in this strategy, the current lower bound for each node is set to the current cost of the path to\nthat node. This works because if a city were to be appended to the path after this node, the path distance\nafter the addition must be at least as long as after the addition, therefore the current distance to\nthe node can act as a very naive lower bound.

"}},{"node":{"frontmatter":{"order":1,"friendlyName":"Cheapest Edges","solverKey":"cheapestEdges","type":"bounding-strategy","defaults":{"evaluatingDetailLevel":2,"maxEvaluatingDetailLevel":2}},"html":"

Cheapest Edges

\n

In this naive approach to relaxing the traveling salesman problem, the TSP is relaxed so that the graph resulting from this algorithm does not need to result in a single cycle. Furthermore, the resulting graph does not need to be complete, in other words not all nodes need to be connected to another node. The only requirement is to create a path that has as many edges as there are nodes to be visited n. To find the minimum distance for this path, simply sort the list of all edges by distance, then select the n edges with the lowest distance and calculate the sum of the distance costs of these edges.

\n

Implementation

\n
export function calculateLowerBound(costToPoint, pathIncludingPoint, points, boundingStrategy, edges) {\n  if (boundingStrategy === \"cheapestEdges\") {\n    if(pathIncludingPoint.length === points.length){\n      return costToPoint;\n    }\n    // Add the cheapest edges that are not yet part of the given path, \n    // until as many edges have been selected as there are nodes. \n    let cheapestEdgesLowerBound = costToPoint;\n    let edgesToAdd = (points.length) - (pathIncludingPoint.length - 1);\n    let startCheckingHere = 0;\n    let edgesCopy = edges.copy();\n    let nextEdge;\n    while (edgesToAdd !== 0) {\n      nextEdge = edgesCopy.pop()\n      if (!containsEdge(pathIncludingPoint, nextEdge)) {\n        cheapestEdgesLowerBound += nextEdge.cost; \n        edgesToAdd--;\n      }\n    }\n    return cheapestEdgesLowerBound;\n  }
"}},{"node":{"frontmatter":{"order":1,"friendlyName":"1-Tree (Kruskal)","solverKey":"oneTree","type":"bounding-strategy","defaults":{"evaluatingDetailLevel":2,"maxEvaluatingDetailLevel":2}},"html":"

1-Tree (Kruskal)

\n

One approach that does come closer to the optimum solution is to use a 1-tree, formed\nincluding the path to the current node, as the lower bound. This 1-tree is the answer to\na relaxation problem which requires a graph that is complete and includes a single cycle,\nbut does not require that all nodes be visited exactly once, which means that not all nodes\nneed to be part of this single cycle (although they can be) [4].

\n

One way to begin the process of creating a 1-tree is via Kruskal’s Algorithm, a type of\ngreedy algorithm which outputs a minimum spanning tree. This minimum spanning tree is by definition the combination of those edges which results in a complete graph at\nthe lowest distance. This graph can then be expanded upon to create a 1-tree by simply\nadding a single edge (the next cheapest edge) to create the required cycle.

\n

The input of Kruskal’s algorithm requires an undirected and weighted graph environment.\nThis is achieved in the TSP with the distance as the weight for each edge and, since the\ncost of each edge is considered in this example to be equal in both directions (Berlin to\nMunich is the same distance as Munich to Berlin), graphs resulting from this problem are\nalso undirected. As stated previously, the resulting output of this algorithm is a minimum\nspanning tree. To achieve a minimum spanning tree with one cycle, the shortest path\nfrom one city to another that is not currently included in the spanning tree is added to\nthe graph

\n

To calculate the lower bound with Kruskal for a path that already includes more than one\ncity, the start and end points of the path as well as any nodes in the cities to be visited which are\nnot already part of the path are used to construct an MST with Kruskal.

\n

Implementation

\n
export function calculateLowerBound(costToPoint, pathIncludingPoint, points, boundingStrategy, edges) {\n  if(pathIncludingPoint.length === points.length){\n      return costToPoint;\n    }\n    // this implementation of Kruskal uses a simplified union/find tactic\n    let oneTreeLowerBound = costToPoint;\n    let edgesToAdd = (points.length) - (pathIncludingPoint.length - 1);\n    let edgesCopy = edges.copy();\n    let currentEdge = \"\";\n    let pointsToBuildMST = selectMSTPoints(pathIncludingPoint, points);\n    const pointToIndexMap = new Map();\n    // save the values of pointsToBuild in a map, index -> point\n    pointsToBuildMST.forEach((point, index) => pointToIndexMap.set(point.join(','), index));\n    let groupRepArray = [];\n    // initialize the group representative for each point to be included in the MST. At the start, every point is its own representative\n    pointsToBuildMST.forEach((point, index) => groupRepArray[index] = index);\n\n    let counter = 0;\n\n    while (edgesToAdd !== 0) {\n      counter++;\n      currentEdge = edgesCopy.pop();\n      if(edgeIncludesForbiddenPoint(pointsToBuildMST, currentEdge)) {\n        // in this case, the currentEdge contains at least one point on the inner part of the current path, which we don't want to use for the MST.\n        continue;\n      }\n      if(pathIncludingPoint.length === 2 && containsEdge(pathIncludingPoint, currentEdge)) {\n        // edge case: even though we would normally ignore the portion of the current path between the start and end node by not including these points in the creation of the MST, in the case of the current path containing just two nodes, this edge needs to be manually ignored.\n        continue;\n      }\n      if(nodesAreConnected(currentEdge, groupRepArray, pointToIndexMap)) {\n        // nodes have the same group rep and are therefore connected through some path already. Adding this edge would create a cycle, which we don't want!\n          continue;\n      }\n      // updating one of the point's group rep to the point's group rep connects the two groups\n      updateGroupReps(currentEdge, groupRepArray, pointToIndexMap);\n      // add the edge to the mst, but we only need the lower bound, so just calculate this.\n      // currentEdge.lowerBound is actually the cost of the edge!\n      oneTreeLowerBound += currentEdge.lowerBound;\n      edgesToAdd--;\n    }\n    return oneTreeLowerBound;\n  }\n  // could add: boundingStrategy === \"oneTreeWithAscent\" \n  else {\n    return 0;\n  }\n}
"}},{"node":{"frontmatter":{"order":1,"friendlyName":"Nearest Neighbor","solverKey":"nearestNeighbor","type":"initial-solution","defaults":{"evaluatingDetailLevel":1,"maxEvaluatingDetailLevel":1}},"html":"

Nearest Neighbor

\n

This is a heuristic, greedy algorithm also known as nearest neighbor. It continually chooses the best looking option from the current state.

\n
    \n
  1. From the starting point
    2. \n
  2. sort the remaining available points based on cost (distance)
    3. \n
  3. Choose the closest point and go there
    4. \n
  4. Chosen point is no longer an \"available point\"
    5. \n
  5. Continue this way until there are no available points, and then return to the start.
    6. \n
\n

Implementation

\n
const nearestNeighbor = async points => {\n  const path = [points.shift()];\n\n  while (points.length > 0) {\n    // sort remaining points in place by their\n    // distance from the last point in the current path\n    points.sort(\n      (a, b) =>\n        distance(path[path.length - 1], b) - distance(path[path.length - 1], a)\n    );\n\n    // go to the closest remaining point\n    path.push(points.pop());\n  }\n\n  // return to start after visiting all other points\n  path.push(path[0]);\n  const cost = pathCost(path);\n};
"}},{"node":{"frontmatter":{"order":1,"friendlyName":"(none)","solverKey":"none","type":"initial-solution","defaults":{"evaluatingDetailLevel":2,"maxEvaluatingDetailLevel":2}},"html":"

No Initial Solution

\n

Having this option selected will effectively \"skip\" running any heuristic before running the Branch\nand Bound algorithm. This means that instead of calculating a reasonable upper bound, the upper\nbound will be set to infinity.

"}},{"node":{"frontmatter":{"order":1,"friendlyName":"Breadth First Search (FIFO)","solverKey":"fifo","type":"search-strategy","defaults":{"evaluatingDetailLevel":2,"maxEvaluatingDetailLevel":2}},"html":"

Breadth First Search

\n

A common counterpart to DFS, Breadth First Search (BFS) chooses the node which was first added to the list as the next node, hence it is also known as first in, first out (FIFO). New nodes are appended to the end of the problem list, and the next node is plucked from the front, creating a tree which grows level-by-level.

\n

For the branch and bound algorithm, this means that each time a new node should be added to a data structure for storage before it is explored, it is stored in a Queue. A new node can be stored at the end of the Queue as the new tail via the push function and the oldest node in the Queue can be removed from the start, or head, via push.

\n

Implementation

\n
export class Queue {\n\n  constructor() {\n    this.head = null;\n    this.last = null;\n    this.size = 0;\n  }\n\n  push(node) {\n    if(this.head === null) {\n      this.head = node;\n      this.last = node;\n    } else {\n      let oldLast = this.last;\n      this.last = node;\n      oldLast.next = node;\n    }\n    return ++this.size;\n  }\n  \n  pop() {\n    let prevHead = this.head;\n    // queue has only one object and will be empty\n    if(this.head === this.last) { \n      this.last = null;\n    }\n    this.head = this.head.next;\n    this.size--;\n    return prevHead;\n  }\n}
"}},{"node":{"frontmatter":{"order":1,"friendlyName":"Depth First Search (LIFO)","solverKey":"lifo","type":"search-strategy","defaults":{"evaluatingDetailLevel":2,"maxEvaluatingDetailLevel":2}},"html":"

Depth First Search

\n

When employing Depth-First Search (DFS), also known as last in, first out (LIFO), the node that was last added to the tree is chosen as the next to be explored. This leads to a tree where the depth is explored first.

\n

For the branch and bound algorithm, this means that each time a new node should be added to a data\nstructure for storage before it is explored, it is stored in a Stack. A new node can be stored at\nthe top of the Stack as the new head via the push function and removed from the Stack via pop.

\n

Implementation

\n
export class Stack {\n\n  constructor() {\n    this.head = null;\n    this.last = null;\n    this.size = 0;\n  }\n\n  push(node) {\n    if(this.head === null) {\n      this.head = node;\n      this.last = node;\n    } else {\n      let oldHead = this.head; \n      this.head = node;\n      this.head.next = oldHead;\n    }\n    return ++this.size;\n  }\n\n  pop() {\n    if(this.head === null) \n      return null;\n    let prevHead = this.head;\n    // stack has only one object and will be empty\n    if(this.head === this.last) {\n      this.last = null;\n    }\n    this.head = this.head.next;\n    this.size--;\n    return prevHead;\n  }\n\n}
"}},{"node":{"frontmatter":{"order":1,"friendlyName":"Minimum Lower Bound (MLB)","solverKey":"mlb","type":"search-strategy","defaults":{"evaluatingDetailLevel":2,"maxEvaluatingDetailLevel":2}},"html":"

Minimum Lower Bound

\n

A variant of Best First Search, in this strategy, the next node to be examined is always the node with the smallest lower bound. This is based on the idea that following the smallest lower bound might allow the algorithm to be more likely to reach the actual optimum more quickly than other search strategies. When using this search strategy, there is a possibility for memory problems when compared to DFS/LIFO, however, the first incumbent solution found is generally close to the final optimum

\n

In the context of the branch and bound algorithm, this means that each time a new node should be added to a data structure for storage before it is explored, it is stored in a PriorityQueue. A new node can be sorted into the the Priority Queue based on its lower bound value via the push function. The pop function provides the node with the lowest lower bound before removing it from the Priority Queue.

\n

Implementation

\n
export class PriorityQueue {\n  constructor() {\n    this.head = null;\n    this.last = null;\n    this.size = 0;\n  }\n\n  push(node) {\n    // case: pq is empty\n    if(this.head === null) {\n      this.head = node;\n      this.last = node;\n    }\n    // case: pq has one entry. Insert node either before or after node and update head/last accordingly\n    else if (this.head === this.last) {\n      if (this.head.lowerBound < node.lowerBound) {\n        this.head.next = node;\n        this.last = node;\n      } else {\n        let prevHead = this.head\n        this.head = node\n        this.head.next = prevHead\n        this.last = prevHead\n      }\n    // case: pq has more than one entry. find before insertion point. edge cases: insertion point is head/last\n    } else {\n      let beforeInsert = this.head;\n      let afterInsert = this.head.next;\n      let headsOrTails = 0;\n      while(afterInsert !== null && afterInsert.lowerBound < node.lowerBound) {\n        beforeInsert = beforeInsert.next;\n        afterInsert = afterInsert.next;\n        ++headsOrTails;\n      }\n      if (headsOrTails === 0 && beforeInsert.lowerBound > node.lowerBound) {\n        this.head = node;\n        this.head.next = beforeInsert;\n      } else if (headsOrTails === this.size - 1) {\n        beforeInsert.next = node;\n        this.last = node;\n      } else {\n        beforeInsert.next = node;\n        node.next = afterInsert;\n      }\n    }\n    return ++this.size;\n  }\n\n  pop() {\n    let prevHead = this.head;\n    if (this.head === null)\n      return null;\n    // priority queue has only one object and will be empty\n    if(this.head === this.last) {\n      this.last = null;\n    }  \n    this.head = this.head.next;\n    this.size--;\n    return prevHead;\n  }\n\n  copy() {\n    let priorityQueueCopy = new PriorityQueue();\n    let nodeToCopy = this.head;\n    while(nodeToCopy !== null) {\n      priorityQueueCopy.push(nodeToCopy);\n      nodeToCopy = nodeToCopy.next;\n    }\n    priorityQueueCopy.head = this.head;\n    priorityQueueCopy.last = this.last;\n    return priorityQueueCopy;\n  }\n}
"}},{"node":{"frontmatter":{"order":2,"friendlyName":"Arbitrary Insertion","solverKey":"arbitraryInsertion","type":"initial-solution","defaults":{"evaluatingDetailLevel":1,"maxEvaluatingDetailLevel":1}},"html":"

Arbitrary Insertion

\n

This is a heuristic construction algorithm. It select a random point, and then figures out where the best place to put it will be.

\n
    \n
  1. From the starting point
    2. \n
  2. First, go to the closest point
    3. \n
  3. Choose a random point to go to
    4. \n
  4. Find the cheapest place to add it in the path
    5. \n
  5. Chosen point is no longer an \"available point\"
    6. \n
  6. Continue from #3 until there are no available points, and then return to the start.
    7. \n
\n

Implementation

\n
const arbitraryInsertion = async points => {\n  // from the starting point\n  const path = [points.shift()];\n\n  //\n  // INITIALIZATION - go to the nearest point\n  //\n  points.sort((a, b) => distance(path[0], b) - distance(path[0], a));\n  path.push(points.pop());\n\n  // randomly sort points - this is the order they will be added\n  // to the path\n  points.sort(() => Math.random() - 0.5);\n\n  while (points.length > 0) {\n    //\n    // SELECTION - choose a next point randomly\n    //\n    const nextPoint = points.pop();\n\n    //\n    // INSERTION -find the insertion spot that minimizes distance\n    //\n    let [bestCost, bestIdx] = [Infinity, null];\n    for (let i = 1; i < path.length; i++) {\n      const insertionCost = pathCost([path[i - 1], nextPoint, path[i]]);\n      if (insertionCost < bestCost) {\n        [bestCost, bestIdx] = [insertionCost, i];\n      }\n    }\n    path.splice(bestIdx, 0, nextPoint);\n  }\n\n  // return to start after visiting all other points\n  path.push(path[0]);\n};
"}},{"node":{"frontmatter":{"order":3,"friendlyName":"Nearest Insertion","solverKey":"nearestInsertion","type":"initial-solution","defaults":{"evaluatingDetailLevel":1,"maxEvaluatingDetailLevel":1}},"html":"

Nearest Insertion

\n

This is a heuristic construction algorithm. It selects the closest point to the path, and then figures out where the best place to put it will be.

\n
    \n
  1. From the starting point
    2. \n
  2. First, go to the closest point
    3. \n
  3. Choose the point that is nearest to the current path
    4. \n
  4. Find the cheapest place to add it in the path
    5. \n
  5. Chosen point is no longer an \"available point\"
    6. \n
  6. Continue from #3 until there are no available points, and then return to the start.
    7. \n
\n

Implementation

\n
const nearestInsertion = async points => {\n  // from the starting point\n  const path = [points.shift()];\n\n  //\n  // INITIALIZATION - go to the nearest point first\n  //\n  points.sort((a, b) => distance(path[0], b) - distance(path[0], a));\n  path.push(points.pop());\n\n  while (points.length > 0) {\n    //\n    // SELECTION - nearest point to the path\n    //\n    let [selectedDistance, selectedIdx] = [Infinity, null];\n    for (const [freePointIdx, freePoint] of points.entries()) {\n      for (const pathPoint of path) {\n        const dist = distance(freePoint, pathPoint);\n        if (dist < selectedDistance) {\n          [selectedDistance, selectedIdx] = [dist, freePointIdx];\n        }\n      }\n    }\n\n    // get the next point to add\n    const [nextPoint] = points.splice(selectedIdx, 1);\n\n    //\n    // INSERTION - find the insertion spot that minimizes distance\n    //\n    let [bestCost, bestIdx] = [Infinity, null];\n    for (let i = 1; i < path.length; i++) {\n      const insertionCost = pathCost([path[i - 1], nextPoint, path[i]]);\n      if (insertionCost < bestCost) {\n        [bestCost, bestIdx] = [insertionCost, i];\n      }\n    }\n    path.splice(bestIdx, 0, nextPoint);\n  }\n\n  // return to start after visiting all other points\n  path.push(path[0]);\n};
"}},{"node":{"frontmatter":{"order":4,"friendlyName":"Farthest Insertion","solverKey":"farthestInsertion","type":"initial-solution","defaults":{"evaluatingDetailLevel":1,"maxEvaluatingDetailLevel":1}},"html":"

Farthest Insertion

\n

This is a heuristic construction algorithm. It selects the farthest point from the path, and then figures out where the best place to put it will be.

\n
    \n
  1. From the starting point
    2. \n
  2. First, go to the closest point
    3. \n
  3. Choose the point that is farthest from any of the points on the path
    4. \n
  4. Find the cheapest place to add it in the path
    5. \n
  5. Chosen point is no longer an \"available point\"
    6. \n
  6. Continue from #3 until there are no available points, and then return to the start.
    7. \n
\n

Implementation

\n
const farthestInsertion = async points => {\n  // from the starting point\n  const path = [points.shift()];\n\n  //\n  // INITIALIZATION - go to the nearest point first\n  //\n  points.sort((a, b) => distance(path[0], b) - distance(path[0], a));\n  path.push(points.pop());\n\n  while (points.length > 0) {\n    //\n    // SELECTION - farthest point from the path\n    //\n    let [selectedDistance, selectedIdx] = [0, null];\n    for (const [freePointIdx, freePoint] of points.entries()) {\n      // find the minimum distance to the path for freePoint\n      let [bestCostToPath, costToPathIdx] = [Infinity, null];\n      for (const pathPoint of path) {\n        const dist = distance(freePoint, pathPoint);\n        if (dist < bestCostToPath) {\n          [bestCostToPath, costToPathIdx] = [dist, freePointIdx];\n        }\n      }\n\n      // if this point is further from the path than the currently selected\n      if (bestCostToPath > selectedDistance) {\n        [selectedDistance, selectedIdx] = [bestCostToPath, costToPathIdx];\n      }\n    }\n    const [nextPoint] = points.splice(selectedIdx, 1);\n\n    //\n    // INSERTION - find the insertion spot that minimizes distance\n    //\n    let [bestCost, bestIdx] = [Infinity, null];\n    for (let i = 1; i < path.length; i++) {\n      const insertionCost = pathCost([path[i - 1], nextPoint, path[i]]);\n      if (insertionCost < bestCost) {\n        [bestCost, bestIdx] = [insertionCost, i];\n      }\n    }\n    path.splice(bestIdx, 0, nextPoint);\n  }\n\n  // return to start after visiting all other points\n  path.push(path[0]);\n};
"}},{"node":{"frontmatter":{"order":5,"friendlyName":"Convex Hull","solverKey":"convexHull","type":"initial-solution","defaults":{"evaluatingDetailLevel":2,"maxEvaluatingDetailLevel":2}},"html":"

Convex Hull

\n

This is a heuristic construction algorithm. It starts by building the convex hull, and adding interior points from there. This implmentation uses another heuristic for insertion based on the ratio of the cost of adding the new point to the overall length of the segment, however any insertion algorithm could be applied after building the hull.

\n

There are a number of algorithms to determine the convex hull. This implementation uses the gift wrapping algorithm.

\n

In essence, the steps are:

\n
    \n
  1. Determine the leftmost point
    2. \n
  2. Continually add the most counterclockwise point until the convex hull is formed
    3. \n
  3. For each remaining point p, find the segment i => j in the hull that minimizes cost(i -> p) + cost(p -> j) - cost(i -> j)
    4. \n
  4. Of those, choose p that minimizes cost(i -> p -> j) / cost(i -> j)
    5. \n
  5. Add p to the path between i and j
    6. \n
  6. Repeat from #3 until there are no remaining points
    7. \n
\n

Implementation

\n
const convexHull = async points => {\n  const sp = points[0];\n\n  // Find the \"left most point\"\n  let leftmost = points[0];\n  for (const p of points) {\n    if (p[1] < leftmost[1]) {\n      leftmost = p;\n    }\n  }\n\n  const path = [leftmost];\n\n  while (true) {\n    const curPoint = path[path.length - 1];\n    let [selectedIdx, selectedPoint] = [0, null];\n\n    // find the \"most counterclockwise\" point\n    for (let [idx, p] of points.entries()) {\n      if (!selectedPoint || orientation(curPoint, p, selectedPoint) === 2) {\n        // this point is counterclockwise with respect to the current hull\n        // and selected point (e.g. more counterclockwise)\n        [selectedIdx, selectedPoint] = [idx, p];\n      }\n    }\n\n    // adding this to the hull so it's no longer available\n    points.splice(selectedIdx, 1);\n\n    // back to the furthest left point, formed a cycle, break\n    if (selectedPoint === leftmost) {\n      break;\n    }\n\n    // add to hull\n    path.push(selectedPoint);\n  }\n\n  while (points.length > 0) {\n    let [bestRatio, bestPointIdx, insertIdx] = [Infinity, null, 0];\n\n    for (let [freeIdx, freePoint] of points.entries()) {\n      // for every free point, find the point in the current path\n      // that minimizes the cost of adding the point minus the cost of\n      // the original segment\n      let [bestCost, bestIdx] = [Infinity, 0];\n      for (let [pathIdx, pathPoint] of path.entries()) {\n        const nextPathPoint = path[(pathIdx + 1) % path.length];\n\n        // the new cost minus the old cost\n        const evalCost =\n          pathCost([pathPoint, freePoint, nextPathPoint]) -\n          pathCost([pathPoint, nextPathPoint]);\n\n        if (evalCost < bestCost) {\n          [bestCost, bestIdx] = [evalCost, pathIdx];\n        }\n      }\n\n      // figure out how \"much\" more expensive this is with respect to the\n      // overall length of the segment\n      const nextPoint = path[(bestIdx + 1) % path.length];\n      const prevCost = pathCost([path[bestIdx], nextPoint]);\n      const newCost = pathCost([path[bestIdx], freePoint, nextPoint]);\n      const ratio = newCost / prevCost;\n\n      if (ratio < bestRatio) {\n        [bestRatio, bestPointIdx, insertIdx] = [ratio, freeIdx, bestIdx + 1];\n      }\n    }\n\n    const [nextPoint] = points.splice(bestPointIdx, 1);\n    path.splice(insertIdx, 0, nextPoint);\n  }\n\n  // rotate the array so that starting point is back first\n  const startIdx = path.findIndex(p => p === sp);\n  path.unshift(...path.splice(startIdx, path.length));\n\n  // go back home\n  path.push(sp);\n};
"}},{"node":{"frontmatter":{"order":6,"friendlyName":"Simulated Annealing","solverKey":"simulatedAnnealing","type":"initial-solution","defaults":{"evaluatingDetailLevel":1,"maxEvaluatingDetailLevel":1}},"html":"

Simulated Annealing

\n

Simulated annealing (SA) is a probabilistic technique for approximating the global optimum of a given function. Specifically, it is a metaheuristic to approximate global optimization in a large search space for an optimization problem.

\n

For problems where finding an approximate global optimum is more important than finding a precise local optimum in a fixed amount of time, simulated annealing may be preferable to exact algorithms

\n

Implementation

\n
const simulatedAnnealing = async points => {\n  const sp = points[0];\n  const path = points;\n\n  const tempCoeff =\n    path.length < 10\n      ? 1 - 1e-4\n      : path.length < 15\n      ? 1 - 1e-5\n      : path.length < 25\n      ? 1 - 1e-6\n      : 1 - 5e-7;\n\n  const deltaDistance = (aIdx, bIdx) => {\n    const aPrev = (aIdx - 1 + path.length) % path.length;\n    const aNext = (aIdx + 1 + path.length) % path.length;\n    const bPrev = (bIdx - 1 + path.length) % path.length;\n    const bNext = (bIdx + 1 + path.length) % path.length;\n    let diff =\n      distance(path[bPrev], path[aIdx]) +\n      distance(path[aIdx], path[bNext]) +\n      distance(path[aPrev], path[bIdx]) +\n      distance(path[bIdx], path[aNext]) -\n      distance(path[aPrev], path[aIdx]) -\n      distance(path[aIdx], path[aNext]) -\n      distance(path[bPrev], path[bIdx]) -\n      distance(path[bIdx], path[bNext]);\n\n    if (bPrev === aIdx || bNext === aIdx) {\n      diff += 2 * distance(path[aIdx], path[bIdx]);\n    }\n    return diff;\n  };\n\n  const changePath = temperature => {\n    // 2 random points\n    const a = 1 + Math.floor(Math.random() * (path.length - 1));\n    const b = 1 + Math.floor(Math.random() * (path.length - 1));\n\n    const delta = deltaDistance(a, b);\n    if (delta < 0 || Math.random() < Math.exp(-delta / temperature)) {\n      // swap points\n      [path[a], path[b]] = [path[b], path[a]];\n    }\n  };\n\n  const initialTemp = 100 * distance(path[0], path[1]);\n  let i = 0;\n\n  for (\n    let temperature = initialTemp;\n    temperature > 1e-6;\n    temperature *= tempCoeff\n  ) {\n    changePath(temperature);\n    if (i % 10000 == 0) {\n      self.setEvaluatingPaths(() => ({\n        paths: [{ path, color: EVALUATING_PATH_COLOR }],\n        cost: pathCost(path)\n      }));\n      await self.sleep();\n    }\n    if (i % 100000 == 0) {\n      path.push(sp);\n      self.setBestPath(path, pathCost(path));\n      path.pop();\n    }\n    i++;\n  }\n\n  // rotate the array so that starting point is back first\n  rotateToStartingPoint(path, sp);\n\n  // go back home\n  path.push(sp);\n  const cost = pathCost(path);\n\n  self.setEvaluatingPaths(() => ({\n    paths: [{ path }],\n    cost\n  }));\n  self.setBestPath(path, cost);\n};\n\nmakeSolver(simulatedAnnealing);
"}}]}}}