pathFindDijkstra(Graph graph, int start, int goal) {\\n\\t\\tNodeRecord startRecord = new NodeRecord();\\r\\n\\t\\tstartRecord.setNode(start);\\r\\n\\t\\tstartRecord.setConnection(null);\\r\\n\\t\\tstartRecord.setCostSoFar(0);\\r\\n\\t\\tstartRecord.setCategory(OPEN);\\r\\n\\t\\t\\r\\n\\t\\tArrayList open = new ArrayList();\\r\\n\\t\\tArrayList close = new ArrayList();\\r\\n\\t\\topen.add(startRecord);\\r\\n\\t\\tNodeRecord current = null;\\r\\n\\t\\tdouble endNodeCost = 0;\\r\\n\\t\\twhile(open.size() > 0){\\r\\n\\t\\t\\tcurrent = getSmallestCSFElementFromList(open);\\r\\n\\t\\t\\tif(current.getNode() == goal){\\r\\n\\t\\t\\t\\tbreak;\\r\\n\\t\\t\\t}\\r\\n\\t\\t\\tGraphNode node = graph.getNodeById(current.getNode());\\r\\n\\t\\t\\tArrayList connections = node.getConnection();\\r\\n\\t\\t\\tfor( Connection connection :connections){\\r\\n\\t\\t\\t\\t// get the cost estimate for end node\\r\\n\\t\\t\\t\\tint endNode = connection.getToNode();\\r\\n\\t\\t\\t\\tendNodeCost = current.getCostSoFar() + connection.getCost();\\r\\n\\t\\t\\t\\tNodeRecord endNodeRecord = new NodeRecord();\\r\\n\\t\\t\\t\\t// if node is closed skip it\\r\\n\\t\\t\\t\\tif(listContains(close, endNode))\\r\\n\\t\\t\\t\\t\\tcontinue;\\r\\n\\t\\t\\t\\t// or if the node is in open list\\r\\n\\t\\t\\t\\telse if (listContains(open,endNode)){\\r\\n\\t\\t\\t\\t\\tendNodeRecord = findInList(open, endNode);\\r\\n\\t\\t\\t\\t\\t// print\\r\\n\\t\\t\\t\\t\\t// if we didn't get shorter route then skip\\r\\n\\t\\t\\t\\t\\tif(endNodeRecord.getCostSoFar() <= endNodeCost) {\\r\\n\\t\\t\\t\\t\\t\\tcontinue;\\r\\n\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t// else node is not visited yet\\r\\n\\t\\t\\t\\telse {\\r\\n\\t\\t\\t\\t\\tendNodeRecord = new NodeRecord();\\r\\n\\t\\t\\t\\t\\tendNodeRecord.setNode(endNode);\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t//update the node\\r\\n\\t\\t\\t\\tendNodeRecord.setCostSoFar(endNodeCost);\\r\\n\\t\\t\\t\\tendNodeRecord.setConnection(connection);\\r\\n\\t\\t\\t\\t// add it to open list\\r\\n\\t\\t\\t\\tif(!listContains(open, endNode)){\\r\\n\\t\\t\\t\\t\\topen.add(endNodeRecord);\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t}// end of for loop for connection\\r\\n\\t\\t\\topen.remove(current);\\r\\n\\t\\t\\tclose.add(current);\\r\\n\\t\\t}// end of while loop for open list\\r\\n\\t\\tif(current.getNode() != goal)\\r\\n\\t\\t\\treturn null;\\r\\n\\t\\telse { //get the path\\r\\n\\t\\t\\tArrayList path = new ArrayList<>();\\r\\n\\t\\t\\twhile(current.getNode() != start){\\r\\n\\t\\t\\t\\tpath.add(current.getConnection());\\r\\n\\t\\t\\t\\tint newNode = current.getConnection().getFromNode();\\r\\n\\t\\t\\t\\tcurrent = findInList(close, newNode);\\r\\n\\t\\t\\t}\\r\\n\\t\\t\\tCollections.reverse(path);\\r\\n\\t\\t\\treturn path;\\r\\n\\t\\t}\\r\\n\\t}\",\n \"private void calculateShortestRoute(String strSourceTerminal){\\n\\t\\tshortestTravelTime = new HashMap<>();\\n\\n //stores parent of every terminal in shortest travel time\\n parent = new HashMap<>();\\n \\n //heap + map data structure\\n MinimumHeap minHeap = new MinimumHeap<>();\\n\\n //initialize all terminal with infinite distance from source terminal\\n for(BaggageTerminal baggageTerminal : graph.getTerminals()){\\n minHeap.add(Integer.MAX_VALUE, baggageTerminal);\\n }\\n \\n BaggageTerminal sourceTerminal = graph.getTerminal(strSourceTerminal);\\n \\n //set distance of source terminal to itself 0\\n minHeap.decrease(sourceTerminal, 0);\\n\\n //put it in map\\n shortestTravelTime.put(sourceTerminal, 0);\\n\\n //source terminal parent is null\\n parent.put(sourceTerminal, null);\\n\\n //iterate till heap is not empty\\n while(!minHeap.empty()){\\n //get the min value from heap node which has vertex and distance of that vertex from source vertex.\\n MinimumHeap.Node heapNode = minHeap.extractMinNode();\\n BaggageTerminal currentTerminal = heapNode.key;\\n\\n //update shortest distance of current vertex from source vertex\\n shortestTravelTime.put(currentTerminal, heapNode.weight);\\n\\n //iterate through all connections of current terminal\\n for(Connection connection : currentTerminal.getConnections()){\\n\\n //get the adjacent terminal\\n BaggageTerminal adjacent = getConnectingTerminal(currentTerminal, connection);\\n\\n //if heap does not contain adjacent vertex means adjacent vertex already has shortest distance from source vertex\\n if(!minHeap.containsData(adjacent)){\\n continue;\\n }\\n\\n //add distance of current vertex to edge weight to get distance of adjacent vertex from source vertex\\n //when it goes through current vertex\\n int newDistance = shortestTravelTime.get(currentTerminal) + connection.getWeight();\\n\\n //see if this above calculated distance is less than current distance stored for adjacent vertex from source vertex\\n if(minHeap.getWeight(adjacent) > newDistance) {\\n minHeap.decrease(adjacent, newDistance);\\n parent.put(adjacent, currentTerminal);\\n }\\n }\\n }\\n return;\\n }\",\n \"@Override\\n\\tpublic List getShortestRoute(Location src, Location dest, String edgePropertyName) {\\n\\t\\t//array to keep track of visited vertexes\\n\\t\\tboolean[] visited = new boolean[locations.size()];\\n\\t\\t//array to store weights\\n\\t\\tdouble[] weight = new double[locations.size()];\\n\\t\\t//array to store predecessors\\n\\t\\tLocation[] pre = new Location[locations.size()];\\n\\t\\t//creates priority queue\\n\\t\\tPriorityQueue pq = new PriorityQueue();\\n\\t\\t// initializes every vertex misted mark to false\\n\\t\\tfor (int i = 0; i < visited.length; i++)\\n\\t\\t\\tvisited[i] = false;\\n\\t\\t// initializes every vertex's total weight to infinity\\n\\t\\tfor (int i = 0; i < weight.length; i++)\\n\\t\\t\\tweight[i] = Double.POSITIVE_INFINITY;\\n\\t\\t// initializes every vertex's predecessor to null\\n\\t\\tfor (int i = 0; i < pre.length; i++)\\n\\t\\t\\tpre[i] = null;\\n\\t\\t//sets start vertex's total weight to 0\\n\\t\\tweight[locations.indexOf(src)] = 0;\\n\\t\\t//insert start vertex in priroty queue\\n\\t\\tpq.add(new LocWeight(src, 0.0));\\n\\t\\t\\n\\t\\tString[] edgeNames = getEdgePropertyNames();\\n\\t\\tint indexProp = 0;\\n\\t\\tfor (int i = 0; i < edgeNames.length; i++) {\\n\\t\\t\\tif (edgeNames[i].equalsIgnoreCase(edgePropertyName))\\n\\t\\t\\t\\tindexProp = i;\\n\\t\\t}\\n\\t\\twhile (!pq.isEmpty()) {\\n\\t\\t\\tLocWeight c = pq.remove();\\n\\t\\t\\t//set C's visited mark to true\\n\\t\\t\\tvisited[locations.indexOf(c)] = true;\\n\\n\\t\\t\\tList neighbors = getNeighbors(c.getLocation());\\n\\t\\t\\t//for each unvisited successor adjacent to C\\n\\t\\t\\tfor (int i = 0; i < neighbors.size(); i++) {\\n\\t\\t\\t\\tif (visited[locations.indexOf(neighbors.get(i))] == false) {\\n\\t\\t\\t\\t\\t//change successor's total weight to equal C's weight + edge weight from C to successor\\n\\t\\t\\t\\t\\tweight[locations.indexOf(neighbors.get(i))] = c.getWeight() + getEdgeIfExists(c.getLocation(), neighbors.get(i)).getProperties().get(indexProp);\\n\\t\\t\\t\\t\\tpre[locations.indexOf(neighbors.get(i))] = c.getLocation();\\n\\t\\t\\t\\t\\tLocWeight succ = new LocWeight(neighbors.get(i), weight[locations.indexOf(neighbors.get(i))]);\\n\\t\\t\\t\\t\\t//if successor is already in pq, update its total weight\\n\\t\\t\\t\\t\\tif (pq.contains(succ)) {\\n\\t\\t\\t\\t\\t\\tpq.remove(succ);\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t//if not already there, add\\n\\t\\t\\t\\t\\tpq.add(succ);\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\t\\n\\n\\n\\t\\t}\\n\\t\\t\\n\\t\\tArrayList path = new ArrayList();\\n\\t\\t//find predecessor of each vertex and construct shortest path then return it\\n\\t\\tLocation curr1 = dest;\\n\\t\\twhile (pre[locations.indexOf(curr1)] != null) {\\n\\t\\t\\tpath.add(getEdgeIfExists(pre[locations.indexOf(curr1)], curr1));\\n\\t\\t\\tcurr1 = pre[locations.indexOf(curr1)];\\n\\t\\t}\\n\\t\\t//to show path from the start\\n\\t\\tfor (int i = path.size() - 1; i >= 0; i--)\\n\\t\\t\\tpath.add(path.remove(i));\\n\\n\\n\\t\\treturn path;\\n\\t}\",\n \"@Test\\n void testShortestPath(){\\n weighted_graph g = new WGraph_DS();\\n for(int i = 1; i <= 7; i++){\\n g.addNode(i);\\n }\\n g.connect(1,2,20);\\n g.connect(1,5,15);\\n g.connect(2,3,20);\\n g.connect(5,6,15);\\n g.connect(3,4,20);\\n g.connect(6,4,15);\\n g.connect(1,7,2);\\n g.connect(7,4,1);\\n weighted_graph_algorithms ga = new WGraph_Algo();\\n ga.init(g);\\n LinkedList expectedPath = new LinkedList<>(Arrays.asList(g.getNode(1),g.getNode(7),g.getNode(4)));\\n assertNull(ga.shortestPath(1,10));\\n assertEquals(expectedPath,ga.shortestPath(1,4));\\n assertEquals(1,ga.shortestPath(1,1).size());\\n }\",\n \"public static Dictionary> getShortestPathDijkstra(Graph graph, V value) {\\n V[] vertices = graph.getValuesAsArray();\\n double[][] matriz = graph.getGraphStructureAsMatrix();\\n\\n double[] distancias = new double[vertices.length];\\n V[] camino = (V[]) new Object[vertices.length];\\n int pos = buscarPosicion(value, vertices);\\n\\n for (int x = 0; x < vertices.length; x++) { // Se llenan los arreglos con la informacion de sus adyacentes.\\n if (pos == x) {\\n distancias[x] = 0;\\n camino[x] = null;\\n } else {\\n if (matriz[pos][x] == -1) {\\n distancias[x] = Integer.MAX_VALUE - 1;\\n camino[x] = vertices[pos];\\n } else {\\n distancias[x] = matriz[pos][x];\\n camino[x] = vertices[pos];\\n }\\n }\\n }\\n\\n Set revisados = new LinkedListSet<>();\\n revisados.put(value);\\n while (revisados.size() < vertices.length) {\\n double menor = Integer.MAX_VALUE;\\n V actual = null;\\n for (int x = 0; x < vertices.length; x++) {\\n if (distancias[x] < menor) {\\n if (!revisados.isMember(vertices[x])) {\\n menor = distancias[x];\\n actual = vertices[x];\\n }\\n }\\n }\\n\\n pos = buscarPosicion(actual, vertices);\\n for (int x = 0; x < vertices.length; x++) { // Se recorre la matriz para buscar adyacencias.\\n if (matriz[pos][x] != -1) { // Si existe arist\\n if (menor + matriz[pos][x] < distancias[x]) {\\n distancias[x] = menor + matriz[pos][x];\\n camino[x] = actual;\\n }\\n }\\n }\\n revisados.put(actual);\\n }\\n Dictionary> diccionario = new Hashtable<>();\\n for (int x = 0; x < vertices.length; x++) {\\n DijkstraResult aux = new DijkstraResult<>(vertices[x], camino[x], distancias[x]);\\n diccionario.put(vertices[x], aux);\\n }\\n return diccionario;\\n }\",\n \"public void computeAllPaths(String source)\\r\\n {\\r\\n Vertex sourceVertex = network_topology.get(source);\\r\\n Vertex u,v;\\r\\n double distuv;\\r\\n\\r\\n Queue vertexQueue = new PriorityQueue();\\r\\n \\r\\n \\r\\n // Switch between methods and decide what to do\\r\\n if(routing_method.equals(\\\"SHP\\\"))\\r\\n {\\r\\n // SHP, weight of each edge is 1\\r\\n sourceVertex.minDistance = 0;\\r\\n vertexQueue.add(sourceVertex);\\r\\n while(!vertexQueue.isEmpty())\\r\\n {\\r\\n u = vertexQueue.remove();\\r\\n for (String key : u.adjacentVertices.keySet())\\r\\n {\\r\\n v = network_topology.get(key);\\r\\n distuv = u.minDistance + 1;\\r\\n if(distuv < v.minDistance)\\r\\n {\\r\\n v.minDistance = distuv;\\r\\n v.previous = u;\\r\\n vertexQueue.add(v);\\r\\n }\\r\\n }\\r\\n \\r\\n }\\r\\n \\r\\n }\\r\\n \\r\\n else if (routing_method.equals(\\\"SDP\\\"))\\r\\n {\\r\\n // SDP, weight of each edge is it's propagation delay\\r\\n sourceVertex.minDistance = 0;\\r\\n vertexQueue.add(sourceVertex);\\r\\n while(!vertexQueue.isEmpty())\\r\\n {\\r\\n u = vertexQueue.remove();\\r\\n for (String key : u.adjacentVertices.keySet())\\r\\n {\\r\\n v = network_topology.get(key);\\r\\n distuv = u.minDistance + u.adjacentVertices.get(key).propDelay;\\r\\n if(distuv < v.minDistance)\\r\\n {\\r\\n v.minDistance = distuv;\\r\\n v.previous = u;\\r\\n vertexQueue.add(v);\\r\\n }\\r\\n } \\r\\n }\\r\\n }\\r\\n else if (routing_method.equals(\\\"LLP\\\"))\\r\\n {\\r\\n // LLP, weight each edge is activeCircuits/AvailableCircuits\\r\\n sourceVertex.minDistance = 0;\\r\\n vertexQueue.add(sourceVertex);\\r\\n while(!vertexQueue.isEmpty())\\r\\n {\\r\\n u = vertexQueue.remove();\\r\\n for (String key : u.adjacentVertices.keySet())\\r\\n {\\r\\n v = network_topology.get(key);\\r\\n distuv = Math.max(u.minDistance,u.adjacentGet(key).load());\\r\\n //System.out.println(u.adjacentGet(key).load());\\r\\n if(distuv < v.minDistance)\\r\\n {\\r\\n v.minDistance = distuv;\\r\\n v.previous = u;\\r\\n vertexQueue.add(v);\\r\\n }\\r\\n }\\r\\n }\\r\\n }\\r\\n }\",\n \"private void computeShortestPathsFromSource(V source) {\\n\\t\\tBFSDistanceLabeler labeler = new BFSDistanceLabeler();\\n\\t\\tlabeler.labelDistances(mGraph, source);\\n\\t\\tdistances = labeler.getDistanceDecorator();\\n\\t\\tMap currentSourceSPMap = new HashMap();\\n\\t\\tMap currentSourceEdgeMap = new HashMap();\\n\\n\\t\\tfor (V vertex : mGraph.getVertices()) {\\n\\n\\t\\t\\tNumber distanceVal = distances.get(vertex);\\n\\t\\t\\t// BFSDistanceLabeler uses -1 to indicate unreachable vertices;\\n\\t\\t\\t// don't bother to store unreachable vertices\\n\\t\\t\\tif (distanceVal != null && distanceVal.intValue() >= 0) {\\n\\t\\t\\t\\tcurrentSourceSPMap.put(vertex, distanceVal);\\n\\t\\t\\t\\tint minDistance = distanceVal.intValue();\\n\\t\\t\\t\\tfor (E incomingEdge : mGraph.getInEdges(vertex)) {\\n\\t\\t\\t\\t\\tfor (V neighbor : mGraph\\n\\t\\t\\t\\t\\t\\t\\t.getIncidentVertices(incomingEdge)) {\\n\\t\\t\\t\\t\\t\\tif (neighbor.equals(vertex))\\n\\t\\t\\t\\t\\t\\t {\\n\\t\\t\\t\\t\\t\\t\\tcontinue;\\n\\t\\t\\t\\t\\t\\t// V neighbor = mGraph.getOpposite(vertex,\\n\\t\\t\\t\\t\\t\\t// incomingEdge);\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tNumber predDistanceVal = distances.get(neighbor);\\n\\n\\t\\t\\t\\t\\t\\tint pred_distance = predDistanceVal.intValue();\\n\\t\\t\\t\\t\\t\\tif (pred_distance < minDistance && pred_distance >= 0) {\\n\\t\\t\\t\\t\\t\\t\\tminDistance = predDistanceVal.intValue();\\n\\t\\t\\t\\t\\t\\t\\tcurrentSourceEdgeMap.put(vertex, incomingEdge);\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\tmDistanceMap.put(source, currentSourceSPMap);\\n\\t\\tmIncomingEdgeMap.put(source, currentSourceEdgeMap);\\n\\t}\",\n \"public List dijkstra(GeographicPoint start, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t GeographicPoint goal, Consumer nodeSearched)\\n\\t{\\n\\t\\t// TODO: Implement this method in WEEK 4\\n\\n\\t\\t// Hook for visualization. See writeup.\\n\\t\\t//nodeSearched.accept(next.getLocation());\\n\\t\\t\\n\\t\\t//initialize distance of each MapNode from start to infinity\\n\\t\\t\\n\\t\\tSet visited = new HashSet();\\n\\t\\tPriorityQueue queue = new PriorityQueue();\\n\\t\\tHashMap> path = new HashMap>();\\n\\t\\tint count = 0;\\n\\t\\t\\n\\t\\tif (!map.containsKey(start) || !map.containsKey(goal))\\n\\t\\t\\treturn null;\\n\\t\\t\\n\\t\\tfor (GeographicPoint temp : map.keySet())\\n\\t\\t\\tpath.put(temp, new ArrayList());\\n\\t\\t\\n\\t\\tMapNode startNode = map.get(start);\\n\\t\\tstartNode.setTimeToStart(0.0);\\n\\t\\tstartNode.setDistanceToStart(0.0);\\n\\t\\tqueue.add(startNode);\\n\\t\\t\\n\\t\\twhile (!queue.isEmpty()) {\\n\\t\\t\\tMapNode currNode = queue.poll();\\n\\t\\t\\tnodeSearched.accept(currNode.getLocation());\\n\\t\\t\\t\\n\\t\\t\\tif (!visited.contains(currNode.getLocation())) {\\n\\t\\t\\t\\tvisited.add(currNode.getLocation());\\n\\t\\t\\t\\tcount++;\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif (currNode.getLocation().equals(goal))\\n\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tHashMap neighbours = currNode.getNeighbours();\\n\\t\\t\\t\\tfor (MapEdge edge : neighbours.keySet()) {\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif (!visited.contains(edge.getEnd())) {\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\tMapNode addNode = map.get(neighbours.get(edge));\\n\\t\\t\\t\\t\\t\\tdouble tempTime = currNode.getTimeToStart() + ((edge.getDistance())/(edge.getSpeedLimit()));\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\tif (tempTime < addNode.getTimeToStart()) {\\n\\t\\t\\t\\t\\t\\t\\taddNode.setTimeToStart(tempTime);\\n\\t\\t\\t\\t\\t\\t\\tqueue.add(addNode);\\n\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t\\tList temp = path.get(neighbours.get(edge));\\n\\t\\t\\t\\t\\t\\t\\ttemp.add(currNode.getLocation());\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\tSystem.out.println(\\\"Dijkstra: \\\" + count);\\n\\t\\treturn backTrack(path,goal);\\n\\t}\",\n \"public static void computePaths(Vertex source){\\n\\t\\tsource.minDistance=0;\\n\\t\\t//visit each vertex u, always visiting vertex with smallest minDistance first\\n\\t\\tPriorityQueue vertexQueue=new PriorityQueue();\\n\\t\\tvertexQueue.add(source);\\n\\t\\twhile(!vertexQueue.isEmpty()){\\n\\t\\t\\tVertex u = vertexQueue.poll();\\n\\t\\t\\tSystem.out.println(\\\"For: \\\"+u);\\n\\t\\t\\tfor (Edge e: u.adjacencies){\\n\\t\\t\\t\\tVertex v = e.target;\\n\\t\\t\\t\\tSystem.out.println(\\\"Checking: \\\"+u+\\\" -> \\\"+v);\\n\\t\\t\\t\\tdouble weight=e.weight;\\n\\t\\t\\t\\t//relax the edge (u,v)\\n\\t\\t\\t\\tdouble distanceThroughU=u.minDistance+weight;\\n\\t\\t\\t\\tif(distanceThroughU distanceTable,\\n int source, int destination)\\n {\\n // Backtrack using a stack, using the destination node\\n Stack stack = new Stack<>();\\n stack.push(destination);\\n\\n // Backtrack by getting the previous node of every node and putting it on the stack.\\n // Start at the destination.\\n int previousVertex = distanceTable.get(destination).getLastVertex();\\n while (previousVertex != -1 && previousVertex != source)\\n {\\n stack.push(previousVertex);\\n previousVertex = distanceTable.get(previousVertex).getLastVertex();\\n }\\n\\n if (previousVertex ==-1)\\n {\\n System.err.println(\\\"No path\\\");\\n }\\n else\\n {\\n System.err.println(\\\"Shortest path: \\\");\\n while (! stack.isEmpty())\\n {\\n System.err.println(stack.pop());\\n }\\n }\\n }\",\n \"@Override\\r\\n\\tpublic void Dijkstra(E src) {\\r\\n\\t\\tPriorityQueue> pq = new PriorityQueue>();\\r\\n\\t\\tif(containsVertex(src)) {\\r\\n\\t\\t\\tlastSrc = vertices.get(src);\\r\\n\\t\\t\\tvertices.forEach((E t, Vertex u) -> {\\r\\n\\t\\t\\t\\tu.setDistance(Integer.MAX_VALUE);\\r\\n\\t\\t\\t\\tu.setPredecessor(null);\\r\\n\\t\\t\\t\\tpq.offer(u);\\r\\n\\t\\t\\t});\\r\\n\\t\\t\\tpq.remove(lastSrc);\\r\\n\\t\\t\\tlastSrc.setDistance(0);\\r\\n\\t\\t\\tpq.offer(lastSrc);\\r\\n\\t\\t\\twhile(!pq.isEmpty()) {\\r\\n\\t\\t\\t\\tVertex u = pq.poll();\\r\\n\\t\\t\\t\\tfor(Edge ale : adjacencyLists.get(u.getElement())) {\\r\\n\\t\\t\\t\\t\\tVertex s = vertices.get(ale.getSrc());\\r\\n\\t\\t\\t\\t\\tVertex d = vertices.get(ale.getDst());\\r\\n\\t\\t\\t\\t\\tif(d.getDistance() > (long)s.getDistance() + (long)ale.getWeight()) {\\r\\n\\t\\t\\t\\t\\t\\tpq.remove(ale.getDst());\\r\\n\\t\\t\\t\\t\\t\\td.setDistance(s.getDistance() + ale.getWeight());\\r\\n\\t\\t\\t\\t\\t\\td.setPredecessor(s);\\r\\n\\t\\t\\t\\t\\t\\tpq.offer(d);\\r\\n\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n\\t}\",\n \"public void findShortestPathHeap( Graph gr,String sourceName, String destName)\\n {\\n \\tint vertex_size = gr.vertexMap.values().size();\\n \\tHeapImpl mh = new HeapImpl(vertex_size);\\n Vertex v = getVertex( sourceName );\\n Vertex processing;\\n for(Vertex ver: gr.vertexMap.values()){\\n \\tver.reset();\\n }\\n v.dist=0;\\n v.prev=null;\\n mh.insert(v);\\n while (mh!=null && !mh.isEmpty()){\\n \\t processing= mh.HeapExtractMin();\\n \\t if(processing.dist==Integer.MAX_VALUE){\\n \\t\\t break;\\n \\t }\\n \\t for(Edge adjEdge: processing.adjEdge.values()){\\n \\t\\t \\n \\t\\t if(!adjEdge.isDown && !adjEdge.adjVertex.isDown ){\\n \\t\\t\\t if(adjEdge.adjVertex.dist>(processing.dist+adjEdge.dist)){\\n \\t\\t\\t\\t //Q.delete(adjEdge.adjVertex);\\n \\t\\t\\t\\t adjEdge.adjVertex.dist= processing.dist+adjEdge.dist;\\n \\t\\t\\t\\t adjEdge.adjVertex.prev=processing;\\n \\t\\t\\t\\t if(adjEdge.adjVertex.vertexPosition==0)\\n \\t\\t\\t\\t\\t adjEdge.adjVertex.vertexPosition= mh.insert( adjEdge.adjVertex);\\n \\t\\t\\t\\t else\\n \\t\\t\\t\\t\\t mh.decreaseKey(adjEdge.adjVertex.vertexPosition-1, adjEdge.adjVertex);\\n \\t\\t\\t\\t \\n \\t\\t\\t }\\n \\t\\t }\\n \\t\\t \\n \\t\\t \\n \\t }\\n }\\n }\",\n \"public static void djikstra(int[][] graph, int src) {\\n\\t\\t/* output array */\\n\\t\\tint[] dist = new int[graph.length];\\n\\t\\tboolean[] visited = new boolean[graph.length];\\n\\n\\t\\tfor (int i = 0; i < graph.length; i++) {\\n\\t\\t\\tdist[i] = Integer.MAX_VALUE;\\n\\t\\t\\tvisited[i] = false;\\n\\t\\t}\\n\\n\\t\\tdist[src] = 0;\\n\\n\\t\\tfor (int i = 0; i < graph.length - 1; i++) {\\n\\n\\t\\t\\t// Pick the minimum distance vertex from the set of vertices not\\n\\t\\t\\t// yet processed. u is always equal to src in first iteration.\\n\\t\\t\\tint u = findMinDistanceVertex(dist, visited);\\n\\t\\t\\t// Mark the picked vertex as processed\\n\\t\\t\\tvisited[u] = true;\\n\\t\\t\\t\\n\\t\\t\\tfor(int j = 0; j < graph.length; j++) {\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t// Update dist[v] only if is not in sptSet, there is an edge from \\n\\t\\t // u to v, and total weight of path from src to v through u is \\n\\t\\t // smaller than current value of dist[v]\\n\\t\\t\\t\\tif(!visited[j] && graph[u][j] != 0\\n\\t\\t\\t\\t\\t\\t&& dist[u] != Integer.MAX_VALUE\\n\\t\\t\\t\\t\\t\\t&& dist[u] + graph[u][j] < dist[j]) {\\n\\t\\t\\t\\t\\tdist[j] = dist[u] + graph[u][j];\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\t\\n\\t\\tprintSolution(dist, graph.length);\\n\\t}\",\n \"@Test\\n void testShortestPathDist(){\\n weighted_graph g = new WGraph_DS();\\n for(int i = 1; i <= 7; i++){\\n g.addNode(i);\\n }\\n g.connect(1,2,20);\\n g.connect(1,5,15);\\n g.connect(2,3,20);\\n g.connect(5,6,15);\\n g.connect(3,4,20);\\n g.connect(6,4,15);\\n g.connect(1,7,2);\\n g.connect(7,4,50);\\n weighted_graph_algorithms ga = new WGraph_Algo();\\n ga.init(g);\\n assertTrue(Double.compare(45,ga.shortestPathDist(1,4)) == 0);\\n assertEquals(0,ga.shortestPathDist(1,1));\\n assertEquals(-1,ga.shortestPathDist(1,200));\\n }\",\n \"private double dijkstraSingleTarget(Map> graph, int vertices, int source, int target) {\\n Queue minHeap = new PriorityQueue<>(\\n Comparator.comparingDouble(a -> a.weight)\\n );\\n\\n double[] dist = new double[vertices + 1]; //shortest distance for each vertex\\n Arrays.fill(dist, 0.0);\\n\\n boolean visited[] = new boolean[vertices + 1];\\n\\n // Distance for starting node is 0\\n dist[source] = -1;\\n minHeap.add((new Node(-1,source)));\\n\\n while (!minHeap.isEmpty()) {\\n Node topPair = minHeap.remove();\\n int currNode = topPair.vertex;\\n double currDistance = topPair.weight;\\n\\n if (!graph.containsKey(currNode)) {\\n continue;\\n }\\n\\n if (visited[currNode]) continue;\\n visited[currNode] = true;\\n\\n\\n for (Node edge : graph.get(currNode)) {\\n double weight = edge.weight;\\n int neighborNode = edge.vertex;\\n double nextDist = currDistance * weight;\\n\\n if (!visited[neighborNode] && nextDist < dist[neighborNode]) {\\n dist[neighborNode] = nextDist;\\n minHeap.add((new Node(nextDist, neighborNode)));\\n\\n }\\n\\n }\\n\\n\\n }\\n\\n return -dist[target];\\n }\",\n \"public ShortestPathMatrix allPairsShortestPaths();\",\n \"@Nullable\\n private NodeWithCost findShortestPath(@Nonnull DirectedGraph graph,\\n V start, V goal, @Nonnull ToDoubleFunction costf) {\\n PriorityQueue< NodeWithCost> frontier = new PriorityQueue<>(61);\\n Map> frontierMap = new HashMap<>(61);\\n // Size of explored is the expected number of nextArrows that we need to explore.\\n Set explored = new HashSet<>(61);\\n return doFindShortestPath(start, frontier, frontierMap, goal, explored, graph, costf);\\n }\",\n \"public ArrayList path2Dest(int s, int t, int k, int method){\\n double INFINITY = Double.MAX_VALUE;\\n boolean[] SPT = new boolean[intersection];\\n double[] d = new double[intersection];\\n int[] parent = new int[intersection];\\n\\n for (int i = 0; i list = g.adjacencylist[extractedVertex];\\n for (int i = 0; i =newKey){\\n if(currentKey==newKey){ //if equal need to compare the value of key\\n if(extractedVertex path = new ArrayList<>();\\n if(parent[t]!=-1){\\n path.add(t);\\n while(parent[t]!= s) {\\n path.add(0,parent[t]);\\n t = parent[t];\\n }\\n path.add(0,s);\\n }\\n else\\n path = null;\\n return path;\\n }\",\n \"private double dijkstrasAlgo(String source, String dest) {\\r\\n\\r\\n\\t\\tclearAll(); // running time: |V|\\r\\n\\t\\tint count = 0; // running time: Constant\\r\\n\\t\\tfor (Vertex v : vertexMap.values()) // running time: |V|\\r\\n\\t\\t\\tif (v.isStatus())\\r\\n\\t\\t\\t\\tcount++;\\r\\n\\r\\n\\t\\tVertex[] queue = new Vertex[count]; // running time: Constant\\r\\n\\t\\tVertex start = vertexMap.get(source); // running time: Constant\\r\\n\\t\\tstart.dist = 0; // running time: Constant\\r\\n\\t\\tstart.prev = null; // running time: Constant\\r\\n\\r\\n\\t\\tint index = 0; // running time: Constant\\r\\n\\t\\tfor (Vertex v : vertexMap.values()) { // running time: |V|\\r\\n\\t\\t\\tif (v.isStatus()) {\\r\\n\\t\\t\\t\\tqueue[index] = v;\\r\\n\\t\\t\\t\\tv.setHandle(index);\\r\\n\\t\\t\\t\\tindex++;\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n\\r\\n\\t\\tbuildMinHeap(queue, count); // running time: |V|\\r\\n\\r\\n\\t\\twhile (count != 0) { // running time: |V|\\r\\n\\t\\t\\tVertex min = extractMin(queue, count); // running time: log |V|\\r\\n\\t\\t\\tcount--; // running time: Constant\\r\\n\\r\\n\\t\\t\\tfor (Iterator i = min.adjacent.iterator(); i.hasNext();) { // running time: |E|\\r\\n\\t\\t\\t\\tEdge edge = (Edge) i.next();\\r\\n\\t\\t\\t\\tif (edge.isStatus()) {\\r\\n\\t\\t\\t\\t\\tVertex adjVertex = vertexMap.get(edge.getDestination());\\r\\n\\t\\t\\t\\t\\tif (adjVertex.dist > (min.dist + edge.getCost()) && adjVertex.isStatus()) {\\r\\n\\t\\t\\t\\t\\t\\tadjVertex.dist = (min.dist + edge.getCost());\\r\\n\\t\\t\\t\\t\\t\\tadjVertex.prev = min;\\r\\n\\t\\t\\t\\t\\t\\tint pos = adjVertex.getHandle();\\r\\n\\t\\t\\t\\t\\t\\tHeapdecreaseKey(queue, pos, adjVertex); // running time: log |V|\\r\\n\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n\\t\\treturn vertexMap.get(dest).dist; // running time: Constant\\r\\n\\t}\",\n \"private int[] runDijkstra(int graph[][], int source) {\\r\\n\\r\\n // Stores the best estimate of the shortest distance from\\r\\n // the source to each node \\r\\n int d[] = new int[graph.length];\\r\\n \\r\\n // Initialized with infinite value.\\r\\n // Value of -1 means the node has been settled \\r\\n int dC[] = new int[graph.length];\\r\\n \\r\\n // Stores the predecessor of each node on the shortest path \\r\\n // from the source\\r\\n int p[] = new int[graph.length];\\r\\n\\r\\n // Initialize\\r\\n for (int i = 0; i < graph.length; i++ ) {\\r\\n d[i] = this.INFINITE;\\r\\n dC[i] = this.INFINITE;\\r\\n p[i] = -1;\\r\\n }\\r\\n \\r\\n // We start knowning the distance of the source from itself (zero)\\r\\n d[source] = 0;\\r\\n dC[source] = 0;\\r\\n\\r\\n int i = 0;\\r\\n int min = this.INFINITE;\\r\\n int pos = 0;\\r\\n\\r\\n while (i < graph.length) {\\r\\n //extract minimum distance\\r\\n for (int j = 0; j < dC.length; j++ ){\\r\\n if( min > d[j] && dC[j] != -1 ){\\r\\n min = d[j];\\r\\n pos = j;\\r\\n }\\r\\n }\\r\\n // This node is settled\\r\\n dC[pos] = -1;\\r\\n\\r\\n // relax its neighbours\\r\\n for (int j = 0; j < graph.length; j++ ) {\\r\\n if ( (graph[pos][j] != -1) && (d[j] > graph[pos][j] + d[pos]) ) {\\r\\n d[j] = graph[pos][j] + d[pos];\\r\\n p[j] = pos;\\r\\n }\\r\\n }\\r\\n i++;\\r\\n min = this.INFINITE;\\r\\n }\\r\\n\\r\\n return p;\\r\\n }\",\n \"public void shortestPathsNodes() {\\n for (int sourceNode = 0; sourceNode < wordGraph.V(); sourceNode++) {\\n BreadthFirstDirectedPaths bfs = new BreadthFirstDirectedPaths(wordGraph, sourceNode);\\n\\n for (int goalNode = 0; goalNode < wordGraph.V(); goalNode++) {\\n Iterable shortestPath = bfs.pathTo(goalNode);\\n int pathLength = -1;\\n if (shortestPath != null) {\\n for (int edge : shortestPath) {\\n pathLength++;\\n }\\n }\\n if (pathLength != -1) {\\n }\\n System.out.println(pathLength);\\n }\\n }\\n }\",\n \"public void findShortestPath() {\\r\\n\\t\\t\\r\\n\\t\\t//Create a circular array that will store the possible next tiles in the different paths.\\r\\n\\t\\tOrderedCircularArray path = new OrderedCircularArray();\\r\\n\\t\\t\\r\\n\\t\\t//Acquire the starting cell.\\r\\n\\t\\tMapCell starting = cityMap.getStart();\\r\\n\\t\\t\\r\\n\\t\\t//This variable is to be updated continuously with the cell with the shortest distance value in the circular array.\\r\\n\\t\\tMapCell current=null;\\r\\n\\t\\t\\r\\n\\t\\t//This variable is to check if the destination has been reached, which is initially false.\\r\\n\\t\\tboolean destination = false;\\r\\n\\t\\t\\r\\n\\t\\t//Add the starting cell into the circular array, and mark it in the list.\\r\\n\\t\\tpath.insert(starting, 0);\\r\\n\\t\\t\\r\\n\\t\\tstarting.markInList(); \\r\\n\\t\\t\\r\\n\\t\\ttry {\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t//As long as the circular array isn't empty, and the destination hasn't been reached, run this loop.\\r\\n\\t\\t\\twhile(!path.isEmpty()&&!destination) {\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t//Take the cell with the shortest distance out of the circular array, and mark it accordingly.\\r\\n\\t\\t\\t\\tcurrent = path.getSmallest();\\r\\n\\t\\t\\t\\tcurrent.markOutList();\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t\\tMapCell next;\\r\\n\\t\\t\\t\\tint distance;\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t\\tif(current.isDestination()) {\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\tdestination = true; //If the current cell is the destination, end the loop.\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t} else {\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\tnext = nextCell(current); //Acquire the next possible neighbour of the current cell.\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t//Don't run if next is null, meaning there is no other possible neighbour in the path for the current cell.\\r\\n\\t\\t\\t\\t\\twhile(next!=null) {\\r\\n\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\tdistance = current.getDistanceToStart() + 1;\\r\\n\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\t//If the distance of the selected neighbouring cell is currently more than 1 more than the current cell's \\r\\n\\t\\t\\t\\t\\t\\t//distance, update the distance of the neighbouring cell. Then, set the current cell as its predecessor.\\r\\n\\t\\t\\t\\t\\t\\tif(next.getDistanceToStart()>distance) {\\r\\n\\t\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\t\\tnext.setDistanceToStart(distance);\\r\\n\\t\\t\\t\\t\\t\\t\\tnext.setPredecessor(current);\\r\\n\\t\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\tdistance = next.getDistanceToStart(); \\r\\n\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\tif(next.isMarkedInList() && distance vs)\\n {\\n \\tfor (Vertex v : vs)\\n \\t{\\n \\t\\tv.minDistance = Double.POSITIVE_INFINITY;\\n \\t\\tv.previous = null;\\n \\t}\\n source.minDistance = 0.;\\t\\t// distance to self is zero\\n IndexMinPQ vertexQueue = new IndexMinPQ(vs.size());\\n \\n for (Vertex v : vs) vertexQueue.insert(Integer.parseInt(v.id), v);\\n\\n\\t\\twhile (!vertexQueue.isEmpty()) \\n\\t\\t{\\n\\t \\t// retrieve vertex with shortest distance to source\\n\\t \\tVertex u = vertexQueue.minKey();\\n\\t \\tvertexQueue.delMin();\\n\\t\\t\\tif (u == target)\\n\\t\\t\\t{\\n\\t\\t\\t\\t// trace back\\n\\t\\t\\t\\twhile (u.previous != null)\\n\\t\\t\\t\\t{;\\n\\t\\t\\t\\t\\tu = u.previous;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\treturn;\\n\\t\\t\\t}\\n \\t// Visit each edge exiting u\\n \\tfor (Edge e : u.adjacencies)\\n \\t\\t{\\n \\t\\tVertex v = e.target;\\n\\t\\t\\t\\tdouble weight = e.weight;\\n \\tdouble distanceThroughU = u.minDistance + weight;\\n\\t\\t\\t\\tif (distanceThroughU < v.minDistance) \\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tint vid = Integer.parseInt(v.id);\\n\\t\\t \\t\\tvertexQueue.delete(vid);\\n\\t\\t \\t\\tv.minDistance = distanceThroughU;\\n\\t\\t \\t\\tv.previous = u;\\n\\t\\t \\t\\tvertexQueue.insert(vid,v);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n }\\n }\",\n \"public void dijkstra(List > adj, int src){ \\n this.adj = adj; \\n \\n for (int i = 0; i < V; i++) \\n dist[i] = Integer.MAX_VALUE; \\n \\n // Add source node to the priority queue \\n pq.add(new Node(src, 0)); \\n \\n // Distance to the source is 0 \\n dist[src] = 0; \\n while (settled.size() != V) { \\n \\n // remove the minimum distance node from the priority queue \\n int u = pq.remove().node; \\n \\n // adding the node whose distance is finalized \\n settled.add(u); \\n \\n e_Neighbours(u); \\n } \\n }\",\n \"public void shortestPaths(int source) {\\n\\n\\t\\tlong start = 0;\\n\\t\\tlong stop;\\n\\t\\tfor (int v = 0; v < vertexList.length; v++) {\\n\\t\\t\\tedgeList[v] = new Edge(vertexList[v].id, rand, 5000);\\n\\t\\t}\\n\\t\\t// creating object of fibonacci\\n\\t\\tFHeap pq = new FHeap();\\n\\t\\t// creating a map for checking\\n\\t\\tMap check = new HashMap();\\n\\t\\t// storing the mst costs\\n\\n\\t\\tfor (int v = 0; v < vertexList.length; v++) {\\n\\t\\t\\tcheck.put(vertexList[v].id,\\n\\t\\t\\t\\t\\tpq.enqueue(vertexList[v].id, Double.POSITIVE_INFINITY));\\n\\t\\t}\\n\\t\\tstart = System.currentTimeMillis();\\n\\t\\t// allot cost 0 to initial node\\n\\t\\tpq.decreaseKey(check.get(vertexList[source].id), 0.0);\\n\\n\\t\\twhile (!pq.isEmpty()) {\\n\\t\\t\\t// take the current node and get its minimum cost\\n\\t\\t\\tFHeap.Node current = pq.dequeueMin();\\n\\n\\t\\t\\t// store the values in the table\\n\\t\\t\\tresult.put(current.getValue(), current.getCost());\\n\\n\\t\\t\\t// update the costs\\n\\t\\t\\tfor (Neighbor nbr = vertexList[current.getValue()].adjList; nbr != null; nbr = nbr.next) {\\n\\n\\t\\t\\t\\t// edge is not added if shortest cost is known\\n\\t\\t\\t\\tif (result.containsKey(vertexList[nbr.vertexNumber].id))\\n\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t// update cost to shortest\\n\\t\\t\\t\\tFHeap.Node finalCost = check\\n\\t\\t\\t\\t\\t\\t.get(vertexList[nbr.vertexNumber].id);\\n\\t\\t\\t\\tif (nbr.weight < finalCost.getCost())\\n\\t\\t\\t\\t\\tpq.decreaseKey(finalCost, nbr.weight);\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\tstop = System.currentTimeMillis();\\n\\t\\t// computing the time\\n\\t\\ttime = stop - start;\\n\\n\\t\\t// calculate the MST cost\\n\\t\\tfor (int i = 0; i < vertexList.length; i++) {\\n\\t\\t\\tsumHeapCost = (int) (sumHeapCost + result.get(i));\\n\\t\\t}\\n\\t\\t// for printing in case of input from file in fibonacci mode\\n\\t\\n\\t\\t// System.out.println(sumHeapCost);\\n\\t}\",\n \"public Queue approxShortestPath(Station start, Station end)\\n {\\n //Create a hash from station IDs to extra data needed for this algorithm.\\n HashMap station_extras =\\n new HashMap();\\n for (Station station : getStations())\\n station_extras.put(station.getId(), new ApproxSearchExtra());\\n\\n HashSet closed = new HashSet();\\n HashSet open = new HashSet();\\n open.add(start);\\n\\n while (open.size() > 0)\\n {\\n //Current is the item in the open set with the lowest estimated cost.\\n Station current = null;\\n ApproxSearchExtra current_extra = null;\\n for (Station element : open)\\n {\\n if (current == null && current_extra == null)\\n {\\n current = element;\\n current_extra = station_extras.get(element.getId());\\n }\\n else\\n {\\n ApproxSearchExtra extra = station_extras.get(element.getId());\\n if (extra.estimated_cost < current_extra.estimated_cost)\\n {\\n current = element;\\n current_extra = extra;\\n }\\n }\\n }\\n\\n //If the current station is the end station, then we're done.\\n if (current == end)\\n return buildApproxShortestPathResult(end, station_extras);\\n\\n //Station is no longer in the open set and is now in the closed set\\n //because it was traversed.\\n open.remove(current);\\n closed.add(current);\\n\\n for (Station neighbour : getAdjacentStations(current))\\n {\\n //Do nothing if neighbour is already in the closed set.\\n if (closed.contains(neighbour))\\n continue;\\n\\n ApproxSearchExtra neighbour_extra =\\n station_extras.get(neighbour.getId());\\n\\n //Cost of movement to this neighbour.\\n float attempt_cost = current_extra.cost + current.distance(neighbour);\\n\\n //If not in the open set, add the neighbour to the open set so that it\\n //will be traversed later.\\n if (!open.contains(neighbour))\\n open.add(neighbour);\\n //If this path is more costly than another path to this station, then\\n //this path cannot be optimal.\\n else if (attempt_cost >= neighbour_extra.cost)\\n continue;\\n\\n //This is now the best path to this neighbour. Store this information.\\n neighbour_extra.came_from = current;\\n neighbour_extra.cost = attempt_cost;\\n neighbour_extra.estimated_cost = attempt_cost +\\n neighbour.distance(end);\\n }\\n }\\n\\n return null;\\n }\",\n \"public static ArrayList> Dijkstra(String CHAR1, String CHAR2, graph g) {\\n\\t\\tPriorityQueue>> active = \\n\\t\\t\\tnew PriorityQueue>>(10,new Comparator>>() {\\n\\t\\t\\t\\tpublic int compare(ArrayList> path1, ArrayList> path2) {\\n\\t\\t\\t\\t\\tedges dest1 = path1.get(path1.size() - 1);\\n\\t\\t\\t\\t\\tedges dest2 = path2.get(path2.size() - 1);\\n\\t\\t\\t\\t\\tif (!(dest1.getLabel().equals(dest2.getLabel())))\\n\\t\\t\\t\\t\\t\\treturn dest1.getLabel().compareTo(dest2.getLabel());\\n\\t\\t\\t\\t\\treturn path1.size() - path2.size();\\n\\t\\t\\t\\t}\\n\\t\\t\\t});\\n\\t\\t\\tSet known = new HashSet();\\n\\t\\t\\tArrayList> begin = new ArrayList>();\\n\\t\\t\\tbegin.add(new edges(CHAR1, 0.0));\\n\\t\\t\\tactive.add(begin);\\t\\t\\n\\t\\t\\twhile (!active.isEmpty()) {\\n\\t\\t\\t\\tArrayList> minPath = active.poll();\\n\\t\\t\\t\\tedges endOfMinPath = minPath.get(minPath.size() - 1);\\n\\t\\t\\t\\tString minDest = endOfMinPath.getDest();\\n\\t\\t\\t\\tdouble minCost = endOfMinPath.getLabel();\\n\\t\\t\\t\\tif (minDest.equals(CHAR2)) {\\n\\t\\t\\t\\t\\treturn minPath;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tif (known.contains(minDest))\\n\\t\\t\\t\\t\\tcontinue;\\n\\t\\t\\t\\tSet> children = g.childrenOf(minDest);\\n\\t\\t\\t\\tfor (edges e : children) {\\n\\t\\t\\t\\t\\tif (!known.contains(e.getDest())) {\\n\\t\\t\\t\\t\\t\\tdouble newCost = minCost + e.getLabel();\\n\\t\\t\\t\\t\\t\\tArrayList> newPath = new ArrayList>(minPath); \\n\\t\\t\\t\\t\\t\\tnewPath.add(new edges(e.getDest(), newCost));\\n\\t\\t\\t\\t\\t\\tactive.add(newPath);\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tknown.add(minDest);\\n\\t\\t\\t}\\n\\t\\t\\treturn null;\\n\\t}\",\n \"private static void findShortestPath(ArrayList edges, int start, int dest, int nNodes) {\\n int costs[] = new int[nNodes];\\n int parents[] = new int[nNodes];\\n boolean doneWithNode[] = new boolean[nNodes];\\n\\n // cost[i] has the cost of getting to node number i or is UNKNOWN if no cost figure out yet.\\n // parent[i] contains the parent (or the way) we got to node i.\\n // done[i] is true if we've already worked on all the children of node i.\\n\\n // Initialize the arrays.\\n for (int i = 0; i path = new ArrayList<>();\\n\\t\\tPriorityQueue qv = new PriorityQueue<>();\\n\\t\\tverts[s].dist = 0;\\n\\t\\tqv.add(verts[s]);\\n\\t\\twhile (!qv.isEmpty()) {\\n\\t\\t\\tVert v = qv.poll();\\n\\t\\t\\tint vidx = v.idx;\\n\\t\\t\\tfor (Edge e : v.edges) {\\n\\t\\t\\t\\tif (e.w==0) {\\n\\t\\t\\t\\t\\tcontinue;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tVert vo = verts[e.other(vidx)];\\n\\t\\t\\t\\tif (vo.dist > v.dist + e.w) {\\n\\t\\t\\t\\t\\tvo.dist = v.dist + e.w;\\n\\t\\t\\t\\t\\tqv.add(vo);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\tif (verts[t].dist < L) {\\n\\t\\t\\tok = false;\\n\\t\\t\\treturn;\\n\\t\\t} else if (verts[t].dist == L) {\\n\\t\\t\\tok = true;\\n\\t\\t\\tfor (int i=0; i v.dist + e.w) {\\n\\t\\t\\t\\t\\tvo.dist = v.dist + e.w;\\n\\t\\t\\t\\t\\tqv.add(vo);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\tif (verts[t].dist > L) {\\n\\t\\t\\tok = false;\\n\\t\\t\\treturn;\\n\\t\\t}\\n\\t\\tVert v = verts[t];\\n\\t\\twhile (v.dist > 0) {\\n\\t\\t\\tlong minDist = MAX_DIST;\\n\\t\\t\\tVert vMin = null;\\n\\t\\t\\tEdge eMin = null;\\n\\t\\t\\tfor (Edge e : v.edges) {\\n\\t\\t\\t\\tVert vo = verts[e.other(v.idx)];\\n\\t\\t\\t\\tif (vo.dist+e.w < minDist) {\\n\\t\\t\\t\\t\\tvMin = vo;\\n\\t\\t\\t\\t\\teMin = e;\\n\\t\\t\\t\\t\\tminDist = vMin.dist+e.w;\\n\\t\\t\\t\\t}\\t\\t\\t\\t\\n\\t\\t\\t}\\n\\t\\t\\tv = vMin;\\t\\n\\t\\t\\tpath.add(eMin);\\n\\t\\t}\\n\\t\\tCollections.reverse(path);\\n\\t\\tfor (int i=0; i settledNodes = new HashSet<>();\\n Set unsettledNodes = new HashSet<>();\\n unsettledNodes.add(source);\\n \\n while (unsettledNodes.size() != 0) {\\n Node currentNode = Graph.getLowestDistanceNode(unsettledNodes);\\n unsettledNodes.remove(currentNode);\\n for (Map.Entry adjacencyPair: \\n currentNode.adjacentNodes.entrySet()) {\\n Node adjacentNode = adjacencyPair.getKey();\\n Integer edgeWeight = adjacencyPair.getValue();\\n if (!settledNodes.contains(adjacentNode)) {\\n Graph.calculateMinimumDistance(adjacentNode, edgeWeight, currentNode);\\n unsettledNodes.add(adjacentNode);\\n }\\n }\\n settledNodes.add(currentNode);\\n }\\n return graph;\\n }\",\n \"private String getShortestPath(final Pair src, final Pair dst,\\n final String passCode, final boolean first) {\\n final var queue = new LinkedList();\\n final var seen = new HashSet();\\n //start from source\\n final var srcNode = new Node( src, \\\"\\\" );\\n queue.add( srcNode );\\n seen.add( srcNode );\\n\\n int max = 0;\\n while ( !queue.isEmpty() ) {\\n final var curr = queue.remove();\\n if ( curr.pos.equals( dst ) ) {\\n if ( first ) {\\n //shortest path\\n return curr.path;\\n } else {\\n //store path length\\n max = curr.path.length();\\n //stop this path\\n }\\n } else {\\n for ( final var neighbour : getNeighbours( curr, passCode ) ) {\\n //unseen neighbour\\n if ( seen.add( neighbour ) ) {\\n //add to the queue\\n queue.add( neighbour );\\n }\\n }\\n }\\n }\\n\\n return itoa( max );\\n }\",\n \"private int[] shrtst_Path_Dijkstra_Algo(int[][] matrx, int sNode, int[] forward_tab_dist, int[] list_Prevoius_Nodes) \\n\\t{\\n\\t\\tArrayList visitedNodes_M = new ArrayList<>(); //3. set of visited vertices is initially empty\\n\\t\\tArrayList unvisitedNodes_Q = new ArrayList<>(); //4. the queue initially contains all vertices\\n\\t\\t\\n\\t\\t//1. Distance to source vertex = 0\\n\\t\\tforward_tab_dist[sNode] = 0;\\n\\n\\t\\t//2. Initialize: Set all other distances to infinity\\n\\t\\tint k=0;\\n\\t\\twhile(k < matrx.length)\\n\\t\\t{\\n\\t\\t\\tunvisitedNodes_Q.add(k);\\n\\t\\t\\tif(k != sNode)\\n\\t\\t\\t{\\n\\t\\t\\t\\tforward_tab_dist[k] = INFINITE_DIST;\\n\\t\\t\\t}\\n\\t\\t\\tk++;\\n\\t\\t}\\n\\t\\t\\n\\t\\t//list of previous nodes, to traverse back\\n\\t\\tlist_Prevoius_Nodes[sNode] = sNode;\\n\\t\\t\\n\\t\\t//5. While queue is not empty\\n\\t\\twhile(!unvisitedNodes_Q.isEmpty())\\n\\t\\t{\\n\\t\\t\\tint minDist = INFINITE_DIST;\\n\\t\\t\\tint u_minDistNode = -1;\\n\\t\\t\\t\\n\\t\\t\\t//6. select the element of Q with min distance\\n\\t\\t\\tint l = 0;\\n\\t\\t\\twhile(l < unvisitedNodes_Q.size())\\n\\t\\t\\t{\\n\\t\\t\\t\\tint n = unvisitedNodes_Q.get(l);\\n\\t\\t\\t\\tif(!(forward_tab_dist[n] <= minDist))\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tl++;\\n\\t\\t\\t\\t\\tcontinue;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\telse\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tu_minDistNode = n;\\n\\t\\t\\t\\t\\tminDist = forward_tab_dist[n];\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tl++;\\n\\t\\t\\t}\\n\\t\\t\\t//No minimum distance node found then return\\n\\t\\t\\tif(u_minDistNode == -1)\\n\\t\\t\\t{\\tbreak;\\t}\\n\\t\\t\\t\\n\\t\\t\\t//7. add u to list of visited vertices\\n\\t\\t\\tvisitedNodes_M.add(u_minDistNode);\\n\\t\\t\\t\\n\\t\\t\\tint index = unvisitedNodes_Q.indexOf(u_minDistNode);\\t//remove this node from unvisited nodes\\n\\t\\t\\tunvisitedNodes_Q.remove(index);\\n\\t\\t\\t\\n\\t\\t\\t//8.0 algo - consider neighbor as direct distance nodes except source\\n\\t\\t\\tfor(int v=0; v 0 ensures it is not source node\\n\\t\\t\\t\\t//unvisitedNodes_Q.contains(v) only check for unvisited nodes\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif(unvisitedNodes_Q.contains(v) && matrx[u_minDistNode][v] > 0)\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tint val = forward_tab_dist[u_minDistNode] + matrx[u_minDistNode][v];\\n\\t\\t\\t\\t\\tif(val < forward_tab_dist[v])\\n\\t\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\t\\t//stores shortest distance\\n\\t\\t\\t\\t\\t\\tforward_tab_dist[v] = val;\\n\\t\\t\\t\\t\\t\\t//stores last node for back traversal to find path\\n\\t\\t\\t\\t\\t\\tlist_Prevoius_Nodes[v] = u_minDistNode;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\treturn forward_tab_dist;\\n\\t}\",\n \"List getShortestPath(V vertex);\",\n \"@Override\\n public List findShortestPath(Node s, Node t)\\n {\\n nodeDists.clear(); //clear previously calculated distances\\n\\n recordNodeDistances(s, t); //record node distances to target\\n\\n LinkedList shortestPath = new LinkedList();\\n\\n shortestPath.addLast(s);\\n\\n boolean reachedEnd = false;\\n\\n if(s==t) reachedEnd = true; // \\\"That was easy\\\"\\n\\n while(!reachedEnd)\\n {\\n //get the neighbors from the most recent step on the path\\n Collection neighbors = shortestPath.getLast().getNeighbors();\\n\\n //minimum cost from neighbors\\n Node minNode = null;\\n\\n for(Node n: neighbors)\\n {\\n if(minNode == null || nodeDists.get(n) < nodeDists.get(minNode))\\n {\\n minNode = n;\\n\\n if(nodeDists.get(n) == 0)\\n {\\n reachedEnd = true;\\n break;\\n }\\n }\\n }\\n\\n if(nodeDists.get(minNode) == Integer.MAX_VALUE) return null; //no path\\n else shortestPath.addLast(minNode);\\n }\\n\\n return shortestPath;\\n }\",\n \"public ArrayQueue getShortestPath(T vertex1, T vertex2){\\n DijkstraShortestPath p = new DijkstraShortestPath(vertex1, vertex2);\\n return p.getMinPath();\\n }\",\n \"public Dijkstra(EdgeWeightedDigraph G, int s) {\\r\\n int V = G.V();\\r\\n distTo = new double[V];\\r\\n edgeTo = new DirectedEdge[V];\\r\\n distTo[0] = 0.0;\\r\\n for (int i = 1; i < V; i++) {\\r\\n distTo[i] = Double.POSITIVE_INFINITY;\\r\\n }\\r\\n pq.insert(s, 0.0);\\r\\n while (!pq.isEmpty()) {\\r\\n int v = pq.deleteMin();\\r\\n for (DirectedEdge e : G.adj(v)) {\\r\\n relax(e);\\r\\n }\\r\\n }\\r\\n }\",\n \"DijkstraSP(EdgeWeightedDigraph G, int s)\\n\\t{\\n\\t\\tdistTo=new double[G.V()];\\n\\t\\tedgeTo=new DirectedEdge[G.V()];\\n\\t\\tpq=new IndexMinPQ<>(G.V());\\n\\t\\tfor(int v=0;v q = new LinkedBlockingQueue();\\n\\t\\tq.add(start);\\n\\t\\twhile(!q.isEmpty()) {\\n\\t\\t\\tnode_data v = q.poll();\\n\\t\\t\\tCollection edgesV = dwg.getE(v.getKey());\\n\\t\\t\\tfor(edge_data edgeV : edgesV) {\\n\\t\\t\\t\\tdouble newSumPath = Double.parseDouble(v.getInfo()) +edgeV.getWeight();\\n\\t\\t\\t\\tint keyU = edgeV.getDest();\\n\\t\\t\\t\\tnode_data u = dwg.getNode(keyU);\\n\\t\\t\\t\\tif(newSumPath < Double.parseDouble(u.getInfo())) {\\n\\t\\t\\t\\t\\tu.setInfo(\\\"\\\"+newSumPath);\\n\\t\\t\\t\\t\\tq.remove(u);\\n\\t\\t\\t\\t\\tq.add(u);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t\\treturn Double.parseDouble(dwg.getNode(dest).getInfo());\\n\\t}\",\n \"public double shortestPathDist(int src, int dest);\",\n \"public List findShortestPathsToEveryNode(final String rootNode, final Graph graph) {\\n final List vertices = graph.getVertices();\\n final List visitedVertices = startingVisitedNodes(rootNode);\\n final Map table = createInitialTable(rootNode, vertices);\\n\\n for (int i = 0; i < visitedVertices.size(); i++) {\\n final String currentVertex = visitedVertices.get(i);\\n final List unvisitedAdjacentVertices = getUnvisitedAdjacentVertices(\\n currentVertex,\\n graph,\\n visitedVertices);\\n\\n unvisitedAdjacentVertices.forEach(vertex -> {\\n final DijkstraEntry previousNodeEntry = table.get(currentVertex);\\n\\n final Integer cost =\\n graph.getWeight(currentVertex, vertex) + previousNodeEntry\\n .getShortestDistance();\\n\\n final DijkstraEntry entry = table.get(vertex);\\n final Integer currentShortestDistance = entry.getShortestDistance();\\n\\n if (Objects.isNull(currentShortestDistance) || cost < currentShortestDistance) {\\n final DijkstraEntry updatedEntry = entry.withDistance(cost)\\n .withPreviousVertex(currentVertex);\\n table.put(vertex, updatedEntry);\\n }\\n });\\n\\n final String unvisitedWithSmallestDistance = unvisitedWithSmallestDistance(\\n unvisitedAdjacentVertices, table);\\n\\n if (unvisitedAdjacentVertices.isEmpty()) {\\n break;\\n }\\n visitedVertices.add(unvisitedWithSmallestDistance);\\n }\\n\\n return createPathResultsFromTable(rootNode, table, vertices);\\n }\",\n \"public void calcSP(Graph g, Vertex source){\\n // Algorithm:\\n // 1. Take the unvisited node with minimum weight.\\n // 2. Visit all its neighbours.\\n // 3. Update the distances for all the neighbours (In the Priority Queue).\\n // Repeat the process till all the connected nodes are visited.\\n\\n // clear existing info\\n// System.out.println(\\\"Calc SP from vertex:\\\" + source.name);\\n g.resetMinDistance();\\n source.minDistance = 0;\\n PriorityQueue queue = new PriorityQueue();\\n queue.add(source);\\n\\n while(!queue.isEmpty()){\\n Vertex u = queue.poll();\\n for(Edge neighbour:u.neighbours){\\n// System.out.println(\\\"Scanning vector: \\\"+neighbour.target.name);\\n Double newDist = u.minDistance+neighbour.weight;\\n\\n // get new shortest path, empty existing path info\\n if(neighbour.target.minDistance>newDist){\\n // Remove the node from the queue to update the distance value.\\n queue.remove(neighbour.target);\\n neighbour.target.minDistance = newDist;\\n\\n // Take the path visited till now and add the new node.s\\n neighbour.target.path = new ArrayList<>(u.path);\\n neighbour.target.path.add(u);\\n// System.out.println(\\\"Path\\\");\\n// for (Vertex vv: neighbour.target.path) {\\n// System.out.print(vv.name);\\n// }\\n// System.out.print(\\\"\\\\n\\\");\\n\\n// System.out.println(\\\"Paths\\\");\\n neighbour.target.pathCnt = 0;\\n neighbour.target.paths = new ArrayList>();\\n if (u.paths.size() == 0) {\\n ArrayList p = new ArrayList();\\n p.add(u);\\n neighbour.target.paths.add(p);\\n neighbour.target.pathCnt++;\\n } else {\\n for (ArrayList p : u.paths) {\\n ArrayList p1 = new ArrayList<>(p);\\n p1.add(u);\\n// for (Vertex vv : p1) {\\n// System.out.print(vv.name);\\n// }\\n// System.out.print(\\\"\\\\n\\\");\\n neighbour.target.paths.add(p1);\\n neighbour.target.pathCnt++;\\n }\\n }\\n\\n //Reenter the node with new distance.\\n queue.add(neighbour.target);\\n }\\n // get equal cost path, add into path list\\n else if (neighbour.target.minDistance == newDist) {\\n queue.remove(neighbour.target);\\n for(ArrayList p: u.paths) {\\n ArrayList p1 = new ArrayList<>(p);\\n p1.add(u);\\n neighbour.target.paths.add(p1);\\n neighbour.target.pathCnt++;\\n }\\n queue.add(neighbour.target);\\n }\\n }\\n }\\n }\",\n \"public int[] djekstra(Router root, Router destination){\\n //if router and destination same\\n if (root.getID() == destination.getID()){\\n int[] result = new int[2];\\n result[0] = root.getID();\\n result[1] = 0;\\n hops.add(0);\\n return result;\\n }\\n\\n //Storing shortest path currently known\\n int[] shortestPath = new int[size];\\n //Storing the weights of the current router's connection to neighbors\\n int[] currentNeighborConnectionWeight = new int[size];\\n\\n //First set all of the positions to 9999 (pseudo infinity)\\n for (int i = 0; i < shortestPath.length;i++){\\n shortestPath[i] = 9999;\\n }\\n\\n // Set the distance to itself as 0, mark as visited\\n shortestPath[root.getID()-1] = 0;\\n root.visit();\\n\\n //For each connection the root has, set the shortestPath available to the weight to the neighbor\\n for (Connection c : root.getConnections()){\\n shortestPath[c.getDestination().getID()-1] = c.getWeight();\\n }\\n\\n //Find the smallest router to start the algorithm\\n //ID of smallest router, start the value with the first available option\\n int smallestRouterID = 0;\\n int smallestRouterWeight = 9999;\\n //Router used for iterating\\n Router current = null;\\n //Storing path length\\n int totalPathLength = 0;\\n\\n\\n //Find the shortest available path link to start with\\n for (int k = 0; k < shortestPath.length; k++){\\n if ((shortestPath[k] < smallestRouterWeight) && (shortestPath[k] != 0)){\\n // Check to see if dead end\\n if (routers.get(k).getConnections().size() > 1){\\n // id is pos+1\\n smallestRouterID = k + 1;\\n smallestRouterWeight = shortestPath[k];\\n } else if (routers.get(k).getID() == destination.getID()){ //edge case\\n // id is pos+1\\n smallestRouterID = k + 1;\\n smallestRouterWeight = shortestPath[k];\\n }\\n }\\n }\\n // add its weight\\n totalPathLength += smallestRouterWeight;\\n\\n //This is where we start our first step\\n current = getRouter(smallestRouterID);\\n hops.add(current.getID());\\n current.visit();\\n //System.out.println(\\\"First step--> Router:\\\" + smallestRouterID + \\\" Weight to router from root:\\\" + smallestRouterWeight);\\n //Now we loop\\n Router firstRouter = current;\\n boolean done = false;\\n while (done == false){\\n //Break case 1, we found the router\\n if (current.getID() == destination.getID()){\\n // check if root has available connections\\n\\n // set current to root and store totalPathLength to new variable && store hops in new array ArrayList\\n // compare totals and store the one that's lower ++ hops list too\\n // could we recursively call djekstra?\\n done = true;\\n // System.out.println(\\\"Router found\\\");\\n break;\\n }\\n\\n //Break case 2, all of the connections have been visited already\\n boolean destinationAvailable = hasAvailableConnections(current);\\n if (destinationAvailable == false){\\n if(hasAvailableConnections(root)){\\n current = root;\\n hops.clear();\\n totalPathLength= 0;\\n } else {\\n done = true;\\n // System.out.println(\\\"v-- No more routers available\\\");\\n break;\\n }\\n }\\n\\n //set all to 9999 to assume we cant see\\n for (int a = 0; a < currentNeighborConnectionWeight.length; a++){\\n currentNeighborConnectionWeight[a] = 9999;\\n }\\n\\n //Recalculate for new path lengths\\n for (Connection c : current.getConnections()){\\n //Only calculate path for routers that havent been visited\\n if (c.getDestination().getVisit() == false){\\n currentNeighborConnectionWeight[c.getDestination().getID()-1] = c.getWeight();\\n }\\n }\\n\\n //Find the next step to take\\n //Find the shortest available path link to start with\\n smallestRouterID = 0;\\n smallestRouterWeight = 9999;\\n for (int b = 0; b < currentNeighborConnectionWeight.length; b++){\\n if ((currentNeighborConnectionWeight[b] < smallestRouterWeight)){\\n // id is pos+1\\n smallestRouterID = b + 1;\\n smallestRouterWeight = currentNeighborConnectionWeight[b];\\n }\\n }\\n\\n // add its weight\\n totalPathLength += smallestRouterWeight;\\n current = getRouter(smallestRouterID);\\n hops.add(current.getID());\\n current.visit();\\n // System.out.println(\\\"Next shortest path--> Router: \\\" + current.getID() + \\\" Length from root:\\\" + totalPathLength);\\n\\n\\n } // <--------------------------------------------------------------------------------End of while loop\\n\\n // returns \\n int[] result = new int[2];\\n //Check and see if the path length is smaller then the original\\n if (totalPathLength <= shortestPath[destination.getID()-1]){\\n //System.out.println(\\\"Case new \\\" + firstRouter.getID());\\n shortestPath[destination.getID()-1] = totalPathLength;\\n result[0] = firstRouter.getID();\\n result[1] = shortestPath[destination.getID()-1];\\n } else {\\n //root was shorter\\n //System.out.println(\\\"Case old \\\" + root.getID());\\n result[0] = root.getID();\\n result[1] = shortestPath[destination.getID()-1];\\n }\\n // System.out.println(\\\"Next hop:\\\" + current.getID() + \\\" Total Distance:\\\" + shortestPath[destination.getID()-1]);\\n\\n //reset the visited list\\n for (Router r: routers){\\n r.unvisit();\\n }\\n return result;\\n }\",\n \"public DijkstraSP(EdgeWeightedDigraph G, int s){\\n edgeTo = new DirectedEdge[G.V()];\\n distTo = new double[G.V()];\\n pq = new IndexMinPQ<>(G.V());\\n\\n for (int v=0; v dijkstra() {\\r\\n\\r\\n\\t\\tPriorityQueue aVisitar = new PriorityQueue();\\r\\n\\t\\tHashMap distancias = new HashMap();\\r\\n\\t\\tHashMap retorno = new HashMap();\\r\\n\\t\\tHashSet visitados = new HashSet();\\r\\n\\r\\n\\t\\tNodoDijkstra nodoOrigen = new NodoDijkstra(this, 0);\\r\\n\\t\\tnodoOrigen.setCamino(new Camino(this));\\r\\n\\t\\taVisitar.add(nodoOrigen);\\r\\n\\t\\tdistancias.put(this, new Integer(0));\\r\\n\\t\\tretorno.put(this, new Integer(0));\\r\\n\\r\\n\\t\\twhile (!aVisitar.isEmpty()) {\\r\\n\\t\\t\\tNodoDijkstra dNodo = aVisitar.poll();\\r\\n\\t\\t\\tNodo actual = dNodo.getNodo();\\r\\n\\t\\t\\tCamino camino = dNodo.getCamino();\\r\\n\\r\\n\\t\\t\\tif (visitados.contains(actual))\\r\\n\\t\\t\\t\\tcontinue;\\r\\n\\r\\n\\t\\t\\tvisitados.add(actual);\\r\\n\\r\\n\\t\\t\\tfor (CanalOptico canal : actual.canales) {\\r\\n\\t\\t\\t\\tNodo vecino = canal.getOtroExtremo(actual);\\r\\n\\t\\t\\t\\tint costo = canal.getCosto();\\r\\n\\r\\n\\t\\t\\t\\t/* Restriccion del Dijkstra */\\r\\n\\t\\t\\t\\tif (visitados.contains(vecino))\\r\\n\\t\\t\\t\\t\\tcontinue;\\r\\n\\r\\n\\t\\t\\t\\tif (canal.estaBloqueado())\\r\\n\\t\\t\\t\\t\\tcontinue;\\r\\n\\r\\n\\t\\t\\t\\tif (vecino.estaBloqueado())\\r\\n\\t\\t\\t\\t\\tcontinue;\\r\\n\\r\\n\\t\\t\\t\\tif (distancias.containsKey(vecino)) {\\r\\n\\t\\t\\t\\t\\tint dActual = distancias.get(vecino);\\r\\n\\r\\n\\t\\t\\t\\t\\tif (dActual <= dNodo.getDistancia() + costo)\\r\\n\\t\\t\\t\\t\\t\\tcontinue;\\r\\n\\t\\t\\t\\t\\telse {\\r\\n\\t\\t\\t\\t\\t\\taVisitar.remove(vecino);\\r\\n\\t\\t\\t\\t\\t\\tdistancias.remove(vecino);\\r\\n\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t}\\r\\n\\r\\n\\t\\t\\t\\tNodoDijkstra nuevoNodo = new NodoDijkstra(vecino,\\r\\n\\t\\t\\t\\t\\t\\tdNodo.getDistancia() + costo);\\r\\n\\t\\t\\t\\tCamino caminoNuevo = new Camino(camino);\\r\\n\\t\\t\\t\\tcaminoNuevo.addSalto(new Salto(camino.getSaltos().size() + 1,\\r\\n\\t\\t\\t\\t\\t\\tcanal));\\r\\n\\t\\t\\t\\tnuevoNodo.setCamino(caminoNuevo);\\r\\n\\t\\t\\t\\taVisitar.add(nuevoNodo);\\r\\n\\t\\t\\t\\tdistancias.put(nuevoNodo.getNodo(), nuevoNodo.getDistancia());\\r\\n\\t\\t\\t\\tretorno.put(nuevoNodo.getNodo(), nuevoNodo.getDistancia());\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n\\t\\treturn retorno;\\r\\n\\t}\",\n \"public DijkstraSP(EdgeWeightedDigraph G, int s)\\n {\\n edgeTo = new DirectedEdge[G.V()];\\n distTo = new double[G.V()];\\n pq = new IndexMinPQ(G.V());\\n for (int v = 0; v < G.V(); v++)\\n distTo[v] = Double.POSITIVE_INFINITY;\\n distTo[s] = 0.0;\\n pq.insert(s, 0.0);\\n while (!pq.isEmpty())\\n relax(G, pq.delMin());\\n }\",\n \"public static void dijkstra_function(graph G, int s) throws IOException\\n { \\t\\t\\t\\t\\t// s is the index of the starting vertex\\n \\t// declare variables\\n\\tint nVerts, u, v;\\n\\tint [] dist;\\n\\n nVerts = G.vertices(); \\t\\t\\t// get number of vertices in the graph class\\n\\n // initialize array\\n dist = new int[nVerts];\\n\\n for(v=0; v dist[u] + G.edgeLength(u,v)) {\\n \\t\\tdist[v] = dist[u] + G.edgeLength(u,v);\\n\\t\\t\\t\\tQ.Update(v, dist[v]);\\n }\\n\\n \\tv = G.nextneighbor(u); \\t// get the next neighbor of u\\n\\n }// end while\\n\\n }// end while\\n\\n System.out.println(\\\"\\\"); \\t\\t\\t// display the array dist\\n for(int row=0; rowqueue=new PriorityQueue();//queue storages the nodes that we will visit by the minimum tag\\n //WGraph_DS copy = (WGraph_DS) (copy());//create a copy graph that the algorithm will on it\\n initializeTag();\\n initializeInfo();\\n node_info first=this.ga.getNode(src);\\n first.setTag(0);//distance from itself=0\\n queue.add(new Entry(first,first.getTag()));\\n while(!queue.isEmpty()) {\\n Entry pair=queue.poll();\\n node_info current= pair.node;\\n if (current.getInfo() != null) continue;//if we visit we can skip to the next loop because we have already marked\\n current.setInfo(\\\"visited\\\");//remark the info\\n Collection listNeighbors = this.ga.getV(current.getKey());//create a collection for the neighbors list\\n LinkedList Neighbors = new LinkedList<>(listNeighbors);//create the neighbors list\\n if (Neighbors == null) continue;\\n for(node_info n:Neighbors) {\\n\\n if(n.getTag()>ga.getEdge(n.getKey(),current.getKey())+current.getTag())\\n {\\n n.setTag(current.getTag() + ga.getEdge(n.getKey(), current.getKey()));//compute the new tag\\n }\\n queue.add(new Entry(n,n.getTag()));\\n }\\n }\\n Iterator it=this.ga.getV().iterator();\\n while(it.hasNext()){\\n if(it.next().getInfo()==null) return false;\\n }\\n return true;\\n }\",\n \"public ArrayList dijkstraPath(int sourceIndex, int sinkIndex) {\\r\\n \\tArrayList locationcopy;\\r\\n \\tlocationcopy=new ArrayList(location);\\r\\n \\tArrayList dijpath;\\r\\n \\tdijpath= new ArrayList(0);\\r\\n \\t//dijpath.add(locationcopy.get(sourceIndex));\\r\\n \\tint i,j,maxdist=locationcopy.size()+1;\\r\\n \\tint[] DistArray=new int[locationcopy.size()], PreArray=new int[locationcopy.size()]; \\r\\n \\tint[][] AdjArray=new int[locationcopy.size()][locationcopy.size()];\\r\\n \\t\\r\\n \\r\\n \\t\\r\\n \\tfor(i=0;i(0);\\r\\n \\t else\\r\\n \\t { \\r\\n \\t \\t AdjArray[mdistindex][mdistindex]=1;\\r\\n \\t for(i=0;i s=new Stack();\\r\\n \\t i=sinkIndex;\\r\\n \\t s.push(i);\\r\\n \\t while(PreArray[i]!=-1)\\r\\n \\t {\\r\\n \\t\\t s.push(PreArray[i]);\\r\\n \\t\\t i=PreArray[i];\\r\\n \\t }\\r\\n \\t while(!s.isEmpty())\\r\\n \\t {\\r\\n \\t\\t dijpath.add(locationcopy.get(s.pop()));\\r\\n \\t }\\r\\n \\treturn dijpath;\\r\\n }\",\n \"public InTree weightedShortestPaths(V source)\\n\\t\\tthrows NegativeWeightEdgeException, DisconnectedGraphException;\",\n \"public ShortestPath(IWeightedGraph graph, int startNode) {\\n\\t\\tthis.graph = graph;\\n\\t\\tthis.startNode = startNode;\\n\\t\\tthis.shortestPaths = new double[graph.numberOfNodes()];\\n\\t\\tthis.previousNode = new int[graph.numberOfNodes()];\\n\\t\\tbellmanFord(this.graph, this.startNode);\\n\\t}\",\n \"private HashMap getShortestPathBetweenDifferentNodes(Node start, Node end) {\\n HashMap parentChildMap = new HashMap<>();\\n parentChildMap.put(start, null);\\n\\n // Shortest path between nodes\\n HashMap shortestPathMap = new HashMap<>();\\n\\n for (Node node : getNodes()) {\\n if (node == start)\\n shortestPathMap.put(start, 0);\\n else shortestPathMap.put(node, Integer.MAX_VALUE);\\n }\\n\\n for (Edge edge : start.getEdges()) {\\n shortestPathMap.put(edge.getDestination(), edge.getWeight());\\n parentChildMap.put(edge.getDestination(), start);\\n }\\n\\n while (true) {\\n Node currentNode = closestUnvisitedNeighbour(shortestPathMap);\\n\\n if (currentNode == null) {\\n return null;\\n }\\n\\n // Save path to nearest unvisited node\\n if (currentNode == end) {\\n Node child = end;\\n String path = end.getName();\\n while (true) {\\n Node parent = parentChildMap.get(child);\\n if (parent == null) {\\n break;\\n }\\n\\n // Create path using previous(parent) and current(child) node\\n path = parent.getName() + \\\"\\\" + path;\\n child = parent;\\n }\\n HashMap hm= new HashMap<>();\\n hm.put(path, shortestPathMap.get(end));\\n return hm;\\n }\\n currentNode.visit();\\n\\n // Go trough edges and find nearest\\n for (Edge edge : currentNode.getEdges()) {\\n if (edge.getDestination().isVisited())\\n continue;\\n\\n if (shortestPathMap.get(currentNode) + edge.getWeight() < shortestPathMap.get(edge.getDestination())) {\\n shortestPathMap.put(edge.getDestination(), shortestPathMap.get(currentNode) + edge.getWeight());\\n parentChildMap.put(edge.getDestination(), currentNode);\\n }\\n }\\n }\\n }\",\n \"private static void shortestPath(Graph graph, Character startNode, int algorithm) {\\n Node currentNode = graph.getNode(startNode);\\n\\n // keep track of the nodes visited\\n List nodesVisited = new ArrayList<>();\\n\\n // add the current node\\n nodesVisited.add(currentNode.getName());\\n\\n // breadth first search to help keep track of the nodes we have already visited\\n // helps with backtracking\\n Stack visitingNodes = new Stack<>();\\n\\n // loop through the graph\\n while (currentNode != graph.getNode('Z')) {\\n // we have visited a node\\n // add it to the stack\\n // set true to since its been visited and it will be in the shortest path\\n visitingNodes.add(currentNode);\\n currentNode.setNodeVisited(true);\\n currentNode.setInShortestPath(true);\\n\\n // get all the edges that are connected to the current node we are on\\n List adjacentNodes = currentNode.getNeighbors();\\n\\n // temp for next node\\n Node nextNode = null;\\n int weightDistanceTotal = Integer.MAX_VALUE;\\n\\n for (Edge i: adjacentNodes) {\\n // testing\\n // System.out.println(i.destination.getName());\\n // System.out.println(i.destination.getDistanceToZ());\\n\\n // 1. always check to see if we have visited the node\\n if (i.destination.isNodeVisited()) {\\n // System.out.println(i.destination.getName() + \\\" is already in the path\\\");\\n continue;\\n }\\n\\n // 2. assign the next node to the destination\\n if (nextNode == null) {\\n nextNode = i.destination;\\n }\\n\\n // compare distances\\n if (algorithm == 1) {\\n nextNode = updateNextNodeAlgo1(nextNode, i.destination);\\n } else {\\n NodeWithWeightDistanceTotal nodeWithWeightDistanceTotal = updateNextNodeAlgo2(nextNode, i, weightDistanceTotal);\\n nextNode = nodeWithWeightDistanceTotal.node;\\n weightDistanceTotal = nodeWithWeightDistanceTotal.weightDistanceTotal;\\n }\\n //if (nextNode.getDistanceToZ() > i.destination.getDistanceToZ()) {\\n // nextNode = i.destination;\\n //}\\n }\\n\\n // next has no other edges\\n if (nextNode == null) {\\n // System.out.println(\\\"There no place to go from \\\" + currentNode.getName());\\n // pop off the node we just visited\\n nextNode = visitingNodes.pop();\\n // its not in the shortest path to Z\\n nextNode.setInShortestPath(false);\\n // set the next node to the previous node\\n nextNode = visitingNodes.pop();\\n }\\n\\n // add the nodes we visit to keep track of the path\\n nodesVisited.add(nextNode.getName());\\n\\n // System.out.println(Arrays.toString(nodesVisited.toArray()));\\n // testing purposes to see if the node is on the shortest path\\n\\n// for (Character node: nodesVisited) {\\n// Node boolVisit = graph.getNode(node);\\n// System.out.println(boolVisit.isInShortestPath());\\n// }\\n\\n // progress to the next node\\n currentNode = nextNode;\\n // when visiting the last node mark z in the shortest path\\n if (currentNode.getName() == 'Z') {\\n currentNode.setInShortestPath(true);\\n }\\n // testing\\n // System.out.println(\\\"next node = \\\" + currentNode.getName());\\n }\\n\\n // keep track of the path visited and the total addition of weights\\n int pathCounter = 0;\\n\\n // construct the shortest path\\n List shortestPath = new ArrayList<>();\\n\\n for (Character nodeVisitor: nodesVisited) {\\n // get the node\\n Node node = graph.getNode(nodeVisitor);\\n\\n // add to the shortest path\\n if (node.isInShortestPath() && !shortestPath.contains(node)) {\\n shortestPath.add(node);\\n }\\n }\\n\\n // print the shortest path\\n for (int i = 0; i < shortestPath.size() - 1; i++) {\\n currentNode = shortestPath.get(i);\\n Node nextNode = shortestPath.get(i + 1);\\n\\n // find the weight of that node\\n int weight = currentNode.findWeight(nextNode);\\n pathCounter += weight;\\n\\n // System.out.println(\\\"weight \\\" + weight);\\n // System.out.println(\\\"path total \\\" + pathCounter);\\n }\\n\\n // final output\\n String fullPathSequence = \\\"\\\";\\n String shortestPathSequence = \\\"\\\";\\n\\n for (int i = 0; i < nodesVisited.size(); i++) {\\n if (i != nodesVisited.size() - 1) {\\n fullPathSequence += nodesVisited.get(i) + \\\" -> \\\";\\n }\\n }\\n\\n fullPathSequence += nodesVisited.get(nodesVisited.size() - 1);\\n\\n for (int i = 0; i < shortestPath.size(); i++) {\\n if (i != shortestPath.size() - 1) {\\n shortestPathSequence += shortestPath.get(i).getName() + \\\" -> \\\";\\n }\\n }\\n\\n if (currentNode.getName() == 'Z') {\\n shortestPathSequence += \\\"Z\\\";\\n } else {\\n shortestPathSequence += shortestPath.get(shortestPath.size() - 1).getName();\\n }\\n\\n System.out.println(\\\"Algorithm \\\" + algorithm + \\\" : \\\");\\n System.out.println(\\\"Sequence of all nodes \\\" + fullPathSequence);\\n System.out.println(\\\"Shortest path: \\\" + shortestPathSequence);\\n System.out.println(\\\"Shortest path length: \\\" + pathCounter);\\n System.out.println(\\\"\\\\n\\\");\\n\\n // reset the graph\\n graph.graphReset();\\n\\n }\",\n \"@Test\\n public void testShortestDistance() {\\n Vertex v1 = new Vertex(1, \\\"A\\\");\\n Vertex v2 = new Vertex(2, \\\"B\\\");\\n Vertex v3 = new Vertex(3, \\\"C\\\");\\n\\n Edge e1 = new Edge<>(v1, v2, 1);\\n Edge e2 = new Edge<>(v2, v3, 3);\\n Edge e3 = new Edge<>(v1, v3, 2);\\n\\n Graph> g = new Graph<>();\\n g.addVertex(v1);\\n g.addVertex(v2);\\n g.addVertex(v3);\\n g.addEdge(e1);\\n g.addEdge(e2);\\n g.addEdge(e3);\\n\\n List expectedPath = new ArrayList<>();\\n expectedPath.add(v1);\\n expectedPath.add(v3);\\n assertEquals(expectedPath, g.shortestPath(v1, v3));\\n\\n assertEquals(6, g.edgeLengthSum());\\n }\",\n \"public List getPath(Long start, Long finish){\\n \\n \\n List res = new ArrayList<>();\\n // auxiliary list\\n List serving = new ArrayList<>();\\n// nearest vertexes map \\n Map optimMap = new HashMap<>();\\n// thread save reading \\n synchronized (vertexes){ \\n // preparation\\n for (Map.Entry entry : vertexes.entrySet()) {\\n Vertex userVertex = entry.getValue();\\n // If it`s start vertex weight = 0 and the nereast vertex is itself \\n if(userVertex.getID().equals(start)){\\n serving.add(new DeixtraObj(start, 0.0, start));\\n }else{\\n // For other vertex weight = infinity and the nereast vertex is unknown \\n serving.add(new DeixtraObj(userVertex.getID(), Double.MAX_VALUE, null));\\n }\\n\\n } \\n // why auxiliary is not empty \\n while(serving.size()>0 ){\\n // sort auxiliary by weight \\n Collections.sort(serving);\\n\\n \\n // remove shortes fom auxiliary and put in to answer \\n DeixtraObj minObj = serving.remove(0);\\n optimMap.put(minObj.getID(), minObj);\\n\\n Vertex minVertex = vertexes.get(minObj.getID());\\n\\n // get all edges from nearest \\n for (Map.Entry entry : minVertex.allEdges().entrySet()) {\\n Long dest = entry.getKey();\\n Double wieght = entry.getValue().getWeight();\\n // by all remain vertexes \\n for(DeixtraObj dx : serving){\\n if(dx.getID().equals(dest)){\\n // if in checking vertex weight more then nearest vertex weight plus path to cheking \\n // then change in checking weight and nearest\\n if( (minObj.getWeight()+wieght) < dx.getWeight()){\\n dx.setNearest(minVertex.getID());\\n dx.setWeight((minObj.getWeight()+wieght));\\n }\\n }\\n }\\n }\\n\\n }\\n }\\n \\n // create output list\\n res.add(finish);\\n Long point = finish;\\n while(!point.equals(start)){\\n \\n point = ((DeixtraObj)optimMap.get(point)).getNearest();\\n res.add(point);\\n }\\n \\n Collections.reverse(res);\\n \\n \\n return res;\\n \\n }\",\n \"public Pair> ShortestDistance(Vertex source, Vertex zink) {\\n Map PredecessorMap = new HashMap<>();\\n Map DistanceMap = new HashMap<>();\\n Vertex a;\\n // initialize arrays\\n for (Vertex v : Vertices) {\\n DistanceMap.put(v, 1000); //We initialize the array in infinite\\n PredecessorMap.put(v, null);\\n }\\n DistanceMap.put(source, 0); //We put the source in 0\\n for (Vertex v : Vertices) {\\n while (!DistanceMap.isEmpty()) { //And we iterate until the distance map is empty\\n a = getmin(DistanceMap); //we get the minimum vertex\\n if(a==null) {\\n return (new Pair>(DistanceMap.get(zink), PredecessorMap));\\n }\\n\\n ArrayList edges = a.getOutEdges(); //we get de edges connected to this vertex\\n for (Edge e : edges) { //we iterate getting the vertex of each edge\\n if (DistanceMap.containsKey(e.tovertex)) { //if the vertex is in the distance map:\\n Integer alt = DistanceMap.get(a) + e.distance; //we get it value and plus the distance of the edge\\n\\n System.out.println(\\\"This is the distance going out from that Vertex: \\\" + alt + \\\", with previous distance: \\\" + DistanceMap.get(e.tovertex));\\n if (alt < DistanceMap.get(e.tovertex)) { //if it is less, we put it in the arrays\\n DistanceMap.put(e.tovertex, alt);\\n PredecessorMap.put(e.tovertex, a);\\n\\n }\\n }\\n }\\n DistanceMap.remove(a); //and we remove it of the array\\n }\\n }\\n return (new Pair>(DistanceMap.get(zink), PredecessorMap));\\n }\",\n \"public Dijkstra(Graph graph, int firstVertexPortNum)\\n {\\n this.graph = graph;\\n Set vertexKeys = this.graph.vertexKeys();\\n \\n this.initialVertexPortNum = firstVertexPortNum;\\n this.predecessors = new HashMap();\\n this.distances = new HashMap();\\n this.availableVertices = new PriorityQueue(vertexKeys.size(), new Comparator()\\n {\\n // compare weights of these two vertices.\\n public int compare(Vertex v1, Vertex v2)\\n {\\n \\t// errors are here.\\n int weightOne = Dijkstra.this.distances.get(v1.convertToString(v1.getVertexPortNum())); // distances stored by portnum in string form.\\n int weightTwo = Dijkstra.this.distances.get(v2.convertToString(v2.getVertexPortNum())); // distances stored by portnum in string form.\\n return weightOne - weightTwo; // return the modified weight of the two vertices.\\n }\\n });\\n \\n this.visitedVertices = new HashSet();\\n \\n // for each Vertex in the graph\\n for(String key: vertexKeys)\\n {\\n this.predecessors.put(key, null);\\n this.distances.put(key, Integer.MAX_VALUE); // assuming that the distance of this is infinity.\\n }\\n \\n \\n //the distance from the initial vertex to itself is 0\\n this.distances.put(convertToString(initialVertexPortNum), 0); \\n \\n //and seed initialVertex's neighbors\\n Vertex initialVertex = this.graph.getVertex(convertToString(initialVertexPortNum)); // converted portnum to String to make this work.\\n ArrayList initialVertexNeighbors = initialVertex.getSquad();\\n for(Edge e : initialVertexNeighbors)\\n {\\n Vertex other = e.getNeighbor(initialVertex);\\n this.predecessors.put(convertToString(other.getVertexPortNum()), convertToString(initialVertexPortNum));\\n this.distances.put(convertToString(other.getVertexPortNum()), e.getWeight()); // converted portnum to String to make this work.\\n this.availableVertices.add(other); // add to available vertices.\\n }\\n \\n this.visitedVertices.add(initialVertex); // add to list of visited vertices.\\n \\n // apply Dijkstra's algorithm to the overlay.\\n processOverlay();\\n \\n }\",\n \"public static ,V,E extends WeightedEdge, W extends Number & Comparable> List findShortestPathInt(G graph, V source, V sink){\\r\\n\\t\\t// check graph contains source and sink\\r\\n\\t\\tSet vertecies = graph.getVertices();\\r\\n\\t\\tif( !(vertecies.contains(source) && vertecies.contains(sink)) ){\\r\\n\\t\\t\\tthrow new IllegalArgumentException(\\\"BaseGraph must contain both source and sink\\\");\\r\\n\\t\\t}\\r\\n\\t\\t\\r\\n\\t\\tPriorityQueue> pq = new PriorityQueue>(); \\r\\n\\t\\tHashSet checked = new HashSet();\\r\\n\\t\\tHashMap> map = new HashMap>();\\r\\n\\t\\taddOrUpdate(map,pq,source,Integer.valueOf(0));\\r\\n\\t\\twhile(!pq.isEmpty()&&!sink.equals(pq.peek().vertex)){\\r\\n\\t\\t\\tWeightedPathChain current = pq.poll(); // poll lowest level vertex\\r\\n\\t\\t\\tchecked.add(current.vertex); // add vertex to checked set\\r\\n\\t\\t\\tfor (E edge :graph.getOutgoingEdges(current.vertex)){\\t// for each outgoing edge \\r\\n\\t\\t\\t\\tif(!checked.contains(edge.getOpposingVertex(current.vertex))){\\t\\t// if opposing vertex has not been checked \\r\\n\\t\\t\\t\\t\\taddOrUpdate(map,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tpq,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tedge.getOpposingVertex(current.vertex),\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tInteger.valueOf(map.get(current.vertex).val+edge.getWeight().intValue() ) ,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tedge);\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n\\t\\tArrayList path = new ArrayList(); // vertex path \\r\\n\\t\\tArrayList edgePath = new ArrayList(); // edge path\\r\\n\\t\\tboolean run = true; \\r\\n\\t\\tif(!pq.isEmpty()&&pq.peek().vertex.equals(sink)) { // \\r\\n\\t\\t\\tWeightedPathChain vv = pq.poll();\\r\\n\\t\\t\\tpath.add(vv.vertex);\\r\\n\\t\\t\\tedgePath.add(vv.edge);\\r\\n\\t\\t\\twhile(run) {\\r\\n\\t\\t\\t\\tvv = map.get(vv.edge.getOpposingVertex(vv.vertex));\\r\\n\\t\\t\\t\\tif(vv.vertex.equals(source)) {\\r\\n\\t\\t\\t\\t\\trun=false;\\r\\n\\t\\t\\t\\t\\tpath.add(vv.vertex);\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\telse {\\t\\r\\n\\t\\t\\t\\t\\tedgePath.add(vv.edge);\\r\\n\\t\\t\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n\\t\\t//return path;\\r\\n\\t\\t\\r\\n\\t\\tCollections.reverse(edgePath);\\r\\n\\t\\treturn edgePath;\\r\\n\\t}\",\n \"public void shortestRouteDijkstra(){\\n int landmark1 = l1.getSelectionModel().getSelectedIndex();\\n int landmark2 = l2.getSelectionModel().getSelectedIndex();\\n GraphNodeAL lm1 = landmarkList.get(landmark1);\\n GraphNodeAL lm2 = landmarkList.get(landmark2);\\n\\n shortestRouteDij(lm1, lm2);\\n }\",\n \"@Test public void testPublic14() {\\n Graph graph= TestGraphs.testGraph2();\\n List shortestPath= new ArrayList();\\n\\n assertEquals(1, graph.Dijkstra(\\\"apple\\\", \\\"banana\\\", shortestPath));\\n assertEquals(\\\"apple banana\\\", TestGraphs.listToString(shortestPath));\\n\\n assertEquals(2, graph.Dijkstra(\\\"apple\\\", \\\"cherry\\\", shortestPath));\\n assertEquals(\\\"apple banana cherry\\\",\\n TestGraphs.listToString(shortestPath));\\n\\n assertEquals(3, graph.Dijkstra(\\\"apple\\\", \\\"date\\\", shortestPath));\\n assertEquals(\\\"apple banana cherry date\\\",\\n TestGraphs.listToString(shortestPath));\\n\\n assertEquals(4, graph.Dijkstra(\\\"apple\\\", \\\"elderberry\\\", shortestPath));\\n assertEquals(\\\"apple banana cherry date elderberry\\\",\\n TestGraphs.listToString(shortestPath));\\n\\n assertEquals(5, graph.Dijkstra(\\\"apple\\\", \\\"fig\\\", shortestPath));\\n assertEquals(\\\"apple banana cherry date elderberry fig\\\",\\n TestGraphs.listToString(shortestPath));\\n\\n assertEquals(6, graph.Dijkstra(\\\"apple\\\", \\\"guava\\\", shortestPath));\\n assertEquals(\\\"apple banana cherry date elderberry fig guava\\\",\\n TestGraphs.listToString(shortestPath));\\n }\",\n \"private void expandNode() {\\r\\n\\t\\t\\t// Dijkstra's algorithm to handle separately\\r\\n\\t\\t\\tif (dijkstra.isSelected()) {\\r\\n\\t\\t\\t\\tCell u;\\r\\n\\t\\t\\t\\t// 11: while Q is not empty:\\r\\n\\t\\t\\t\\tif (graph.isEmpty()) {\\r\\n\\t\\t\\t\\t\\treturn;\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t// 12: u := vertex in Q (graph) with smallest distance in dist[]\\r\\n\\t\\t\\t\\t// ;\\r\\n\\t\\t\\t\\t// 13: remove u from Q (graph);\\r\\n\\t\\t\\t\\tu = graph.remove(0);\\r\\n\\t\\t\\t\\t// Add vertex u in closed set\\r\\n\\t\\t\\t\\tclosedSet.add(u);\\r\\n\\t\\t\\t\\t// If target has been found ...\\r\\n\\t\\t\\t\\tif (u.row == targetPos.row && u.col == targetPos.col) {\\r\\n\\t\\t\\t\\t\\tfound = true;\\r\\n\\t\\t\\t\\t\\treturn;\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t// Counts nodes that have expanded.\\r\\n\\t\\t\\t\\texpanded++;\\r\\n\\t\\t\\t\\t// Update the color of the cell\\r\\n\\t\\t\\t\\tgrid[u.row][u.col] = CLOSED;\\r\\n\\t\\t\\t\\t// 14: if dist[u] = infinity:\\r\\n\\t\\t\\t\\tif (u.dist == INFINITY) {\\r\\n\\t\\t\\t\\t\\t// ... then there is no solution.\\r\\n\\t\\t\\t\\t\\t// 15: break;\\r\\n\\t\\t\\t\\t\\treturn;\\r\\n\\t\\t\\t\\t\\t// 16: end if\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t// Create the neighbors of u\\r\\n\\t\\t\\t\\tArrayList neighbors = createSuccesors(u, false);\\r\\n\\t\\t\\t\\t// 18: for each neighbor v of u:\\r\\n\\t\\t\\t\\tfor (Cell v : neighbors) {\\r\\n\\t\\t\\t\\t\\t// 20: alt := dist[u] + dist_between(u, v) ;\\r\\n\\t\\t\\t\\t\\tint alt = u.dist + distBetween(u, v);\\r\\n\\t\\t\\t\\t\\t// 21: if alt < dist[v]:\\r\\n\\t\\t\\t\\t\\tif (alt < v.dist) {\\r\\n\\t\\t\\t\\t\\t\\t// 22: dist[v] := alt ;\\r\\n\\t\\t\\t\\t\\t\\tv.dist = alt;\\r\\n\\t\\t\\t\\t\\t\\t// 23: previous[v] := u ;\\r\\n\\t\\t\\t\\t\\t\\tv.prev = u;\\r\\n\\t\\t\\t\\t\\t\\t// Update the color of the cell\\r\\n\\t\\t\\t\\t\\t\\tgrid[v.row][v.col] = FRONTIER;\\r\\n\\t\\t\\t\\t\\t\\t// 24: decrease-key v in Q;\\r\\n\\t\\t\\t\\t\\t\\t// (sort list of nodes with respect to dist)\\r\\n\\t\\t\\t\\t\\t\\tCollections.sort(graph, new CellComparatorByDist());\\r\\n\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t// The handling of the other four algorithms\\r\\n\\t\\t\\t} else {\\r\\n\\t\\t\\t\\tCell current;\\r\\n\\t\\t\\t\\tif (dfs.isSelected() || bfs.isSelected()) {\\r\\n\\t\\t\\t\\t\\t// Here is the 3rd step of the algorithms DFS and BFS\\r\\n\\t\\t\\t\\t\\t// 3. Remove the first state, Si, from OPEN SET ...\\r\\n\\t\\t\\t\\t\\tcurrent = openSet.remove(0);\\r\\n\\t\\t\\t\\t} else {\\r\\n\\t\\t\\t\\t\\t// Here is the 3rd step of the algorithms A* and Greedy\\r\\n\\t\\t\\t\\t\\t// 3. Remove the first state, Si, from OPEN SET,\\r\\n\\t\\t\\t\\t\\t// for which f(Si) ≤ f(Sj) for all other\\r\\n\\t\\t\\t\\t\\t// open states Sj ...\\r\\n\\t\\t\\t\\t\\t// (sort first OPEN SET list with respect to 'f')\\r\\n\\t\\t\\t\\t\\tCollections.sort(openSet, new CellComparatorByF());\\r\\n\\t\\t\\t\\t\\tcurrent = openSet.remove(0);\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t// ... and add it to CLOSED SET.\\r\\n\\t\\t\\t\\tclosedSet.add(0, current);\\r\\n\\t\\t\\t\\t// Update the color of the cell\\r\\n\\t\\t\\t\\tgrid[current.row][current.col] = CLOSED;\\r\\n\\t\\t\\t\\t// If the selected node is the target ...\\r\\n\\t\\t\\t\\tif (current.row == targetPos.row && current.col == targetPos.col) {\\r\\n\\t\\t\\t\\t\\t// ... then terminate etc\\r\\n\\t\\t\\t\\t\\tCell last = targetPos;\\r\\n\\t\\t\\t\\t\\tlast.prev = current.prev;\\r\\n\\t\\t\\t\\t\\tclosedSet.add(last);\\r\\n\\t\\t\\t\\t\\tfound = true;\\r\\n\\t\\t\\t\\t\\treturn;\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t// Count nodes that have been expanded.\\r\\n\\t\\t\\t\\texpanded++;\\r\\n\\t\\t\\t\\t// Here is the 4rd step of the algorithms\\r\\n\\t\\t\\t\\t// 4. Create the successors of Si, based on actions\\r\\n\\t\\t\\t\\t// that can be implemented on Si.\\r\\n\\t\\t\\t\\t// Each successor has a pointer to the Si, as its predecessor.\\r\\n\\t\\t\\t\\t// In the case of DFS and BFS algorithms, successors should not\\r\\n\\t\\t\\t\\t// belong neither to the OPEN SET nor the CLOSED SET.\\r\\n\\t\\t\\t\\tArrayList succesors;\\r\\n\\t\\t\\t\\tsuccesors = createSuccesors(current, false);\\r\\n\\t\\t\\t\\t// Here is the 5th step of the algorithms\\r\\n\\t\\t\\t\\t// 5. For each successor of Si, ...\\r\\n\\t\\t\\t\\tfor (Cell cell : succesors) {\\r\\n\\t\\t\\t\\t\\t// ... if we are running DFS ...\\r\\n\\t\\t\\t\\t\\tif (dfs.isSelected()) {\\r\\n\\t\\t\\t\\t\\t\\t// ... add the successor at the beginning of the list\\r\\n\\t\\t\\t\\t\\t\\t// OPEN SET\\r\\n\\t\\t\\t\\t\\t\\topenSet.add(0, cell);\\r\\n\\t\\t\\t\\t\\t\\t// Update the color of the cell\\r\\n\\t\\t\\t\\t\\t\\tgrid[cell.row][cell.col] = FRONTIER;\\r\\n\\t\\t\\t\\t\\t\\t// ... if we are runnig BFS ...\\r\\n\\t\\t\\t\\t\\t} else if (bfs.isSelected()) {\\r\\n\\t\\t\\t\\t\\t\\t// ... add the successor at the end of the list OPEN SET\\r\\n\\t\\t\\t\\t\\t\\topenSet.add(cell);\\r\\n\\t\\t\\t\\t\\t\\t// Update the color of the cell\\r\\n\\t\\t\\t\\t\\t\\tgrid[cell.row][cell.col] = FRONTIER;\\r\\n\\t\\t\\t\\t\\t\\t// ... if we are running A* or Greedy algorithms (step 5\\r\\n\\t\\t\\t\\t\\t\\t// of A* algorithm) ...\\r\\n\\t\\t\\t\\t\\t} else if (aStar.isSelected() || guloso.isSelected()) {\\r\\n\\t\\t\\t\\t\\t\\t// ... calculate the value f(Sj) ...\\r\\n\\t\\t\\t\\t\\t\\tint dxg = current.col - cell.col;\\r\\n\\t\\t\\t\\t\\t\\tint dyg = current.row - cell.row;\\r\\n\\t\\t\\t\\t\\t\\tint dxh = targetPos.col - cell.col;\\r\\n\\t\\t\\t\\t\\t\\tint dyh = targetPos.row - cell.row;\\r\\n\\t\\t\\t\\t\\t\\tif (diagonal.isSelected()) {\\r\\n\\t\\t\\t\\t\\t\\t\\t// with diagonal movements\\r\\n\\t\\t\\t\\t\\t\\t\\t// calculate 1000 times the Euclidean distance\\r\\n\\t\\t\\t\\t\\t\\t\\tif (guloso.isSelected()) {\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t// especially for the Greedy ...\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tcell.g = 0;\\r\\n\\t\\t\\t\\t\\t\\t\\t} else {\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tcell.g = current.g + (int) ((double) 1000 * Math.sqrt(dxg * dxg + dyg * dyg));\\r\\n\\t\\t\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t\\t\\t\\tcell.h = (int) ((double) 1000 * Math.sqrt(dxh * dxh + dyh * dyh));\\r\\n\\t\\t\\t\\t\\t\\t} else {\\r\\n\\t\\t\\t\\t\\t\\t\\t// without diagonal movements\\r\\n\\t\\t\\t\\t\\t\\t\\t// calculate Manhattan distances\\r\\n\\t\\t\\t\\t\\t\\t\\tif (guloso.isSelected()) {\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t// especially for the Greedy ...\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tcell.g = 0;\\r\\n\\t\\t\\t\\t\\t\\t\\t} else {\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tcell.g = current.g + Math.abs(dxg) + Math.abs(dyg);\\r\\n\\t\\t\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t\\t\\t\\tcell.h = Math.abs(dxh) + Math.abs(dyh);\\r\\n\\t\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t\\t\\tcell.f = cell.g + cell.h;\\r\\n\\t\\t\\t\\t\\t\\t// ... If Sj is neither in the OPEN SET nor in the\\r\\n\\t\\t\\t\\t\\t\\t// CLOSED SET states ...\\r\\n\\t\\t\\t\\t\\t\\tint openIndex = isInList(openSet, cell);\\r\\n\\t\\t\\t\\t\\t\\tint closedIndex = isInList(closedSet, cell);\\r\\n\\t\\t\\t\\t\\t\\tif (openIndex == -1 && closedIndex == -1) {\\r\\n\\t\\t\\t\\t\\t\\t\\t// ... then add Sj in the OPEN SET ...\\r\\n\\t\\t\\t\\t\\t\\t\\t// ... evaluated as f(Sj)\\r\\n\\t\\t\\t\\t\\t\\t\\topenSet.add(cell);\\r\\n\\t\\t\\t\\t\\t\\t\\t// Update the color of the cell\\r\\n\\t\\t\\t\\t\\t\\t\\tgrid[cell.row][cell.col] = FRONTIER;\\r\\n\\t\\t\\t\\t\\t\\t\\t// Else ...\\r\\n\\t\\t\\t\\t\\t\\t} else {\\r\\n\\t\\t\\t\\t\\t\\t\\t// ... if already belongs to the OPEN SET, then ...\\r\\n\\t\\t\\t\\t\\t\\t\\tif (openIndex > -1) {\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t// ... compare the new value assessment with the\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t// old one.\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t// If old <= new ...\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tif (openSet.get(openIndex).f <= cell.f) {\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// ... then eject the new node with state\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// Sj.\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// (ie do nothing for this node).\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// Else, ...\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t} else {\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// ... remove the element (Sj, old) from the\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// list\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// to which it belongs ...\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\topenSet.remove(openIndex);\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// ... and add the item (Sj, new) to the\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// OPEN SET.\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\topenSet.add(cell);\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// Update the color of the cell\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgrid[cell.row][cell.col] = FRONTIER;\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t// ... if already belongs to the CLOSED SET,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t// then ...\\r\\n\\t\\t\\t\\t\\t\\t\\t} else {\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t// ... compare the new value assessment with the\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t// old one.\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t// If old <= new ...\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tif (closedSet.get(closedIndex).f <= cell.f) {\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// ... then eject the new node with state\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// Sj.\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// (ie do nothing for this node).\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// Else, ...\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t} else {\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// ... remove the element (Sj, old) from the\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// list\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// to which it belongs ...\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tclosedSet.remove(closedIndex);\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// ... and add the item (Sj, new) to the\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// OPEN SET.\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\topenSet.add(cell);\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// Update the color of the cell\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgrid[cell.row][cell.col] = FRONTIER;\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\",\n \"public Path shortestPath(Vertex a, Vertex b) {\\n // If a or b aren't present in the set of vertices throw an exception\\n if (!myGraph.containsKey(b) || !myGraph.containsKey(a)) {\\n throw new IllegalArgumentException(\\\"One of the vertices isn't valid\\\");\\n }\\n /* Create a map of Vertices to VertexInfos. Fill it with VertexInfos for all\\n vertices that each have no previous vertex and and a cost of INFINITY */\\n Map vertInfos = new HashMap();\\n for (Vertex v : vertices()) {\\n vertInfos.put(v, new VertexInfo(v, null, INFINITY));\\n }\\n /* Create a PriorityQueue for VertexInfos */\\n PriorityQueue viQueue = new PriorityQueue();\\n /* Create a VertexInfo for the start Vertex 'a' with a cost of 0. This uses a copy of Vertex a&b for immutability */\\n Vertex copyA = new Vertex(a.getLabel());\\n Vertex copyB = new Vertex(b.getLabel());\\n\\n VertexInfo vi_a = new VertexInfo(copyA, null, 0);\\n /* Add VerxtexInfo for a to PQ and map it to it's VertexInfo */\\n viQueue.add(vi_a);\\n vertInfos.put(a, vi_a);\\n while(!viQueue.isEmpty()) {\\n /* Remove the VertexInfo with lowest cost */\\n Vertex curr = viQueue.poll().getVertex();\\n /* Check all adjacent Vertices of curr Vertex */\\n for (Vertex v : adjacentVertices(curr)) {\\n /* Calculate cost to get to v through curr */\\n int cost = vertInfos.get(curr).getCost() + edgeCost(curr, v);\\n /* If cost through curr is lower than previous */\\n if (cost < vertInfos.get(v).getCost()) {\\n /* Remove v's VertexInfo from PQ */\\n viQueue.remove(vertInfos.get(v));\\n /* Overwrite previous value of v in map\\n Add updated VerexInfo to PQ */\\n VertexInfo vi = new VertexInfo(v, curr, cost);\\n vertInfos.put(v,vi);\\n viQueue.add(vi);\\n }\\n }\\n }\\n /* Create ArrayList for path */\\n List path = new ArrayList();\\n \\n /* Add each vertex and it's previous vertex to path until a null vertex is reached */\\n for (Vertex vert = copyB; vert != null; vert = vertInfos.get(vert).getPrev()) {\\n path.add(vert);\\n }\\n\\n /* Reverse order of path */ \\n Collections.reverse(path);\\n /* Create new Path object with corresponding parameters */\\n if(path.contains(copyA)){\\n Path pathToB = new Path(path, vertInfos.get(copyB).getCost());\\n return pathToB;\\n } else {\\n return null;\\n }\\n }\",\n \"public List findShortestPath(Node s, Node t);\",\n \"private void buildPath( PriorityQueue> nodes ) {\\n\\t\\tNode v;\\n\\t\\tSearchNode su, sv;\\n\\t\\tWeightedEdge we;\\n\\n\\t\\twhile ( ! nodes.isEmpty() ) { // while Q is not empty:\\n\\t\\t\\tsu = nodes.poll(); // u = Q.min()\\n\\t\\t\\tif ( su.isUnreachable() ) { break; } //\\n\\n\\t\\t\\tfor ( Edge edge : su.getEdges() ) { // for each\\n\\t\\t\\t\\twe = (WeightedEdge)edge; //\\n\\t\\t\\t\\tv = we.getOtherNode( su.getNode() ); // neighbor v of u\\n\\t\\t\\t\\tsv = getSearchNode( v ); //\\n\\t\\t\\t\\tint uToV = su.getDistance() + we.getWeight();// alt = dist[u] + length(u, v)\\n\\t\\t\\t\\tif (uToV < sv.getDistance() ) { // if alt < dist[v]\\n\\t\\t\\t\\t\\tnodes.remove( sv ); // ( force recalc )\\n\\t\\t\\t\\t\\tsv.setDistance( uToV ); // dist[v] <- alt\\n\\t\\t\\t\\t\\tsv.setPrevious( su.getNode() ); // prev[v] <- u\\n\\t\\t\\t\\t\\tnodes.add( sv ); // Q.decrease_priority(v, alt) (dist recalc)\\n\\t\\t\\t\\t} // end if\\n\\t\\t\\t} // end for\\n\\t\\t} // end while\\n\\t}\",\n \"public Stack shortestPath() {\\n\\t\\tresetVisited();\\n\\t\\tStack shortestPath = new Stack();\\n\\t\\tprev = new HashMap();\\n\\t\\tCompass[] direction = Compass.values();\\n\\t\\tQueue path = new LinkedList();\\n\\t\\tpath.add(playerStart);\\n\\t\\twhile(!path.isEmpty()) {\\n\\t\\t\\tPoint current = path.poll();\\n\\t\\t\\tfor (Compass pointing: direction) {\\n\\t\\t\\t\\tif (current.equals(goal)) {\\n\\t\\t\\t\\t\\tshortestPath.push(current);\\n\\t\\t\\t\\t\\twhile (prev.containsKey(shortestPath.peek()) && !shortestPath.peek().equals(playerStart)){\\n\\t\\t\\t\\t\\t\\tshortestPath.push(prev.get(shortestPath.peek()));\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\treturn shortestPath;\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tint nextW = (int)current.getX() + pointing.mapX;\\n\\t\\t\\t\\tint nextH = (int)current.getY() + pointing.mapY;\\n\\t\\t\\t\\tPoint nextPoint = new Point(nextW, nextH);\\n\\t\\t\\t\\tif (arrayBounds(nextW, width) && arrayBounds (nextH, height) && maze[nextW][nextH] == 0 && !visited.contains(nextPoint)) {\\n\\t\\t\\t\\t\\tpath.add(nextPoint);\\n\\t\\t\\t\\t\\tvisited.add(nextPoint);\\n\\t\\t\\t\\t\\tprev.put(nextPoint, current);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\treturn shortestPath;\\t\\t\\n\\t}\",\n \"public int shortestPath(Village startVillage, Village targetVillage) {\\n// setting the initial point 's minimum distance to zera\\n startVillage.setMinDistance(0);\\n// accourting to bellman ford if there are n number of dots then n-1 iterations to be done to find the minimum distances of every dot from one initial dot\\n int length = this.villageList.size();\\n// looping n-1 times\\n for (int i = 0; i < length - 1; i++) {\\n// looping through all the roads and mark the minimum distances of all the possible points\\n for (Road road : roadList) {\\n\\n\\n// if the road is a main road then skip the path\\n if (road.getWeight() == 900)\\n continue; //why 900 ? : just a random hightest number as a minimum distance and same 900 is used as a mix number\\n Village v = road.getStartVertex();\\n Village u = road.getTargetVertex();\\n// if the newly went path is less than the path it used to be the update the min distance of the reached vertex\\n int newLengtha = v.getMinDistance() + road.getWeight();\\n if (newLengtha < u.getMinDistance()) {\\n u.setMinDistance(newLengtha);\\n u.setPreviousVertex(v);\\n }\\n int newLengthb = u.getMinDistance() + road.getWeight();\\n if (newLengthb < v.getMinDistance()) {\\n v.setMinDistance(newLengthb);\\n v.setPreviousVertex(v);\\n }\\n }\\n }\\n// finally return the minimum distance\\n return targetVillage.getMinDistance();\\n }\",\n \"private int BFS() {\\n adjList.cleanNodeFields();\\n\\n //Queue for storing current shortest path\\n Queue> q = new LinkedList<>();\\n\\n //Set source node value to 0\\n q.add(adjList.getNode(startNode));\\n q.peek().key = 0;\\n q.peek().d = 0;\\n q.peek().visited = true;\\n\\n //Helper variables\\n LinkedList, Integer>> neighbors;//Array of pairs \\n Node neighbor, u;\\n long speed = (long) (cellSideLength * 1.20);\\n\\n while (!isCancelled() && q.size() != 0) {\\n u = q.poll();\\n\\n //Marks node as checked\\n checkedNodesGC.fillRect((u.value >> 16) * cellSideLength + 0.5f,\\n (u.value & 0x0000FFFF) * cellSideLength + 0.5f,\\n (int) cellSideLength - 1, (int) cellSideLength - 1);\\n\\n //endNode found\\n if (u.value == endNode) {\\n //Draws shortest path\\n Node current = u, prev = u;\\n\\n while ((current = current.prev) != null) {\\n shortestPathGC.strokeLine((prev.value >> 16) * cellSideLength + cellSideLength / 2,\\n (prev.value & 0x0000FFFF) * cellSideLength + cellSideLength / 2,\\n (current.value >> 16) * cellSideLength + cellSideLength / 2,\\n (current.value & 0x0000FFFF) * cellSideLength + cellSideLength / 2);\\n prev = current;\\n }\\n return u.d;\\n }\\n\\n //Wait after checking node\\n try {\\n Thread.sleep(speed);\\n } catch (InterruptedException interrupted) {\\n if (isCancelled())\\n break;\\n }\\n\\n //Checking Neighbors\\n neighbors = adjList.getNeighbors(u.value);\\n for (Pair, Integer> neighborKeyValuePair : neighbors) {\\n neighbor = neighborKeyValuePair.getKey();\\n //Relaxation step\\n //Checks if neighbor hasn't been checked, if so the assign the shortest path\\n if (!neighbor.visited) {\\n //Adds checked neighbor to queue\\n neighbor.key = u.d + 1;\\n neighbor.d = u.d + 1; //Assign shorter path found to neighbor\\n neighbor.prev = u;\\n neighbor.visited = true;\\n q.add(neighbor);\\n }\\n }\\n }\\n return Integer.MAX_VALUE;\\n }\",\n \"@Override\\r\\n public List shortestPath(int src, int dest) {\\r\\n double i = shortestPathDist(src, dest);\\r\\n double j, k, s, mark = 1;\\r\\n ArrayList Rlist = new ArrayList<>();\\r\\n ArrayList Llist = new ArrayList<>();\\r\\n Rlist.clear();\\r\\n Llist.clear();\\r\\n j = i;\\r\\n for (node_info curr : this.Graph.getV()) {\\r\\n curr.setInfo(\\\"clear\\\");\\r\\n }\\r\\n this.Graph.getNode(src).setInfo(\\\"tmp\\\");\\r\\n Rlist.add(this.Graph.getNode(dest));\\r\\n node_info nd = this.Graph.getNode(dest);\\r\\n node_info temp = this.Graph.getNode(dest);\\r\\n while (j != 0 && j > 0) {\\r\\n for (node_info curr0 : this.Graph.getV(nd.getKey())) {\\r\\n if (curr0.getInfo() != null) {\\r\\n temp = curr0;\\r\\n k = this.Graph.getEdge(nd.getKey(), curr0.getKey());\\r\\n s = j - k;\\r\\n if ((s - curr0.getTag() < 0.001 && s - curr0.getTag() > -0.001) && nd.getInfo() != null) {\\r\\n Rlist.add(curr0);\\r\\n j = curr0.getTag();\\r\\n curr0.setInfo(\\\"tmp\\\");\\r\\n mark = 1;\\r\\n nd = curr0;\\r\\n }\\r\\n }\\r\\n }\\r\\n if (mark == 0) {\\r\\n i = j;\\r\\n temp.setInfo(null);\\r\\n Rlist.clear();\\r\\n Rlist.add(this.Graph.getNode(dest));\\r\\n mark = 1;\\r\\n }\\r\\n mark = 0;\\r\\n }\\r\\n for (int t = (Rlist.size() - 1); t >= 0; t--) {\\r\\n Llist.add(Rlist.get(t));\\r\\n }\\r\\n return Llist;\\r\\n }\",\n \"private static void compareDistanceAndReplace(final DirectedGraph directedGraph,\\n final Map currentShortestPaths,\\n final String start) {\\n final Map possibleDestinations = directedGraph.get(start);\\n if (possibleDestinations != null) {\\n // For each possible edge to this node, check if the distance of this edge plus the value of how\\n // we arrived at the start node is smaller than the current value in the table, if so then replace it\\n possibleDestinations.forEach((toNode, distance) -> {\\n final int valueToCompare = currentShortestPaths.get(start) + distance;\\n final Integer currentShortest = currentShortestPaths.get(toNode);\\n final boolean currentInfinity = currentShortestPaths.containsKey(toNode) && (currentShortest == null || currentShortest == 0);\\n // If the to node we are currently looking at is infinity in our table, then always replace\\n // or if there is a real value then compare it\\n // and if the new route is shorter then replace it\\n if (currentInfinity\\n || (containsAndNotNull(currentShortestPaths, toNode) && (currentShortest > valueToCompare))) {\\n currentShortestPaths.put(toNode, valueToCompare);\\n }\\n });\\n }\\n }\",\n \"public double dijkstra(NodoArista[][] adjacencyMatrix, int startVertex, int nodoBuscado, ListaEnlazada lista) {\\n int nVertices = adjacencyMatrix[0].length;\\n // shortestDistances[i] will hold the shortest distance from src to i\\n double[] shortestDistances = new double[nVertices];\\n double[] precios = new double[nVertices];\\n // added[i] will true if vertex i is included / in shortest path tree or shortest distance from src to i is finalized \\n boolean[] added = new boolean[nVertices];\\n\\n // Initialize all distances as INFINITE and added[] as false \\n for (int vertexIndex = 0; vertexIndex < nVertices; vertexIndex++) {\\n shortestDistances[vertexIndex] = Integer.MAX_VALUE;\\n precios[vertexIndex] = Integer.MAX_VALUE;\\n added[vertexIndex] = false;\\n }\\n // Distance of source vertex from itself is always 0 \\n shortestDistances[startVertex] = 0;\\n precios[startVertex] = 0;\\n // Parent array to store shortest path tree \\n int[] parents = new int[nVertices];\\n // The starting vertex does not have a parent \\n parents[startVertex] = NO_PARENT;\\n\\n // Find shortest path for all vertices \\n for (int i = 1; i < nVertices; i++) {\\n // Pick the minimum distance vertex from the set of vertices not yet processed. nearestVertex is always equal to startNode in first iteration. \\n int nearestVertex = -1;\\n double shortestDistance = Integer.MAX_VALUE;\\n double precio = Integer.MAX_VALUE;\\n for (int vertexIndex = 0; vertexIndex < nVertices; vertexIndex++) {\\n if (!added[vertexIndex] && shortestDistances[vertexIndex] < shortestDistance) {\\n nearestVertex = vertexIndex;\\n shortestDistance = shortestDistances[vertexIndex];\\n precio = precios[vertexIndex];\\n }\\n }\\n\\n // Mark the picked vertex as processed \\n added[nearestVertex] = true;\\n\\n // Update dist value of the adjacent vertices of the picked vertex. \\n for (int vertexIndex = 0; vertexIndex < nVertices; vertexIndex++) {\\n double edgeDistance = adjacencyMatrix[nearestVertex][vertexIndex].getPeso();\\n double precioActual = adjacencyMatrix[nearestVertex][vertexIndex].getPrecio();\\n double edgePrice = adjacencyMatrix[nearestVertex][vertexIndex].getPrecio();\\n if (edgeDistance > 0 && ((shortestDistance + edgeDistance) < shortestDistances[vertexIndex])) {\\n parents[vertexIndex] = nearestVertex;\\n shortestDistances[vertexIndex] = shortestDistance + edgeDistance;\\n precios[vertexIndex] = precio + precioActual;\\n }\\n if (edgePrice > 0 && ((shortestDistance + edgeDistance) < shortestDistances[vertexIndex])) {\\n parents[vertexIndex] = nearestVertex;\\n shortestDistances[vertexIndex] = shortestDistance + edgeDistance;\\n precios[vertexIndex] = precio + precioActual;\\n }\\n }\\n }\\n printSolution(startVertex, shortestDistances, parents);\\n printSolutionPara(startVertex, shortestDistances, parents, nodoBuscado, lista);\\n\\n return precios[nodoBuscado];\\n }\",\n \"public void computeShortestPath() throws IllegalStateException;\",\n \"private List> getBestPath(Pair curLocation, Pair | |