def singleSourceShortestPath(self, srcID): assert (srcID >= 0 and srcID < self.n) # Implement Dijkstra's algorithm # Input: # self --> a reference to a MyGraph instance # srcID: the id of the source vertex. # Expected Output: (d,pi) # d --> Map each vertex id v to the distance from srcID # pi --> Map each reachable vertex id v (except for srcID) to a parent. # Initialize the priority queue pq = PriorityQueue(self.n) #create the priority queue cur = self for i in range(0, self.n): # Iterate through all vertex ID if (i == srcID): # If ID is srcID pq.set(i, 0.0) # Distance of srcID should be zero else: # ID is not srcID pq.set(i, pq.Inf) # Distance should be infinity d = {} # Initialize the map with distances to nodes pi = {} # Initialize the map with parents of vertices minKey, minDist = pq.extractMin() d[minKey] = minDist #set orignal source distance to 0 pi[minKey] = minKey #set sources to orginal source while (pq.isEmpty() == False): # COMPLETE the Dijkstra code here lst = self.adjList[ minKey] #grap array of lists of format (vertices,weight) for node minKey for n in lst: #loop through said list ##grap the next node attached to this node somehow dist = n[1] + minDist #grab distance from list node = n[0] #grab node from list if (pq.hasKey(node) ): #check if that nodes min dist has been found if ( pq.get(node) > dist ): #check if path to the node from minKey is less then current path pq.set(node, dist) #set the nodes distance in the queue d[node] = dist #set the nodes distance in the return array pi[node] = minKey #sets the nodes parents minKey, minDist = pq.extractMin( ) #extract next node dont need to extract last node as all the paths will be filled would probably work better in a do while loop return (d, pi)
def singleSourceShortestPath(self, srcID): assert (srcID >= 0 and srcID < self.n) # Implement Dijkstra's algorithm # Input: # self --> a reference to a MyGraph instance # srcID: the id of the source vertex. # Expected Output: (d,pi) # d --> Map each vertex id v to the distance from srcID # pi --> Map each reachable vertex id v (except for srcID) to a parent. # Initialize the priority queue pq = PriorityQueue(self.n) #create the priority queue cur=self for i in range(0,self.n): # Iterate through all vertex ID if ( i == srcID): # If ID is srcID pq.set(i,0.0) # Distance of srcID should be zero else: # ID is not srcID pq.set(i, pq.Inf) # Distance should be infinity d = {} # Initialize the map with distances to nodes pi = {} # Initialize the map with parents of vertices minKey, minDist=pq.extractMin() d[minKey]=minDist #set orignal source distance to 0 pi[minKey]=minKey #set sources to orginal source while(pq.isEmpty()==False):# COMPLETE the Dijkstra code here lst=self.adjList[minKey]#grap array of lists of format (vertices,weight) for node minKey for n in lst:#loop through said list ##grap the next node attached to this node somehow dist=n[1]+minDist#grab distance from list node=n[0] #grab node from list if(pq.hasKey(node)):#check if that nodes min dist has been found if(pq.get(node)>dist):#check if path to the node from minKey is less then current path pq.set(node,dist)#set the nodes distance in the queue d[node]=dist#set the nodes distance in the return array pi[node]=minKey#sets the nodes parents minKey, minDist=pq.extractMin()#extract next node dont need to extract last node as all the paths will be filled would probably work better in a do while loop return (d,pi)
def singleSourceShortestPath(self, srcID): assert (srcID >= 0 and srcID < self.n) # ensure that srcID is between 0 and size of graph. # Implement Dijkstra's algorithm # Input: # self --> a reference to a MyGraph instance # srcID: the id of the source vertex. # Expected Output: (d,pi) # d --> Map each vertex id v to the distance from srcID # pi --> Map each reachable vertex id v (except for srcID) to a parent. # Initialize the priority queue pq = PriorityQueue(self.n) #create the priority queue for i in range(0,self.n): # Iterate through all vertex ID if i == srcID: # If ID is srcID pq.set(i, 0.0) # Distance of srcID should be zero else: # ID is not srcID pq.set(i, pq.Inf) # Distance should be infinity d = {} # Initialize the map with distances to nodes pi = {} # Initialize the map with parents of vertices while not pq.isEmpty(): # loop until priority queue is empty. (node, dist) = pq.extractMin() # extract smallest dist node. d[node] = dist # update dictionary with shortest distance. for (vertex, weight) in self.adjList[node]: # check the adjacency list of popped node. newDist = dist + weight # calculate new distance. if pq.hasKey(vertex): # if we haven't already popped the node in the adjacency list yet. if newDist < pq.get(vertex): # check distance vs new calculated dist. pq.set(vertex, newDist) # update priority queue. pi[vertex] = node # update parent list. return (d, pi)
def dijkstra(graphObj, startVertex): pq = PriorityQueue() for vertex in graphObj.getVertices(): if vertex == startVertex: pq.insert([0, vertex]) graphObj.verticesList[startVertex].distance = 0 else: pq.insert([INFINITY, vertex]) while(len(pq.pqueue)): currentVertex = pq.extractMin() if len(pq.pqueue) == 1: break # print(pq.pqueue, pq.lookup) for adjNode in graphObj.verticesList[currentVertex[1]].getConnections(): newDistance = graphObj.verticesList[currentVertex[1]].distance + graphObj.verticesList[currentVertex[1]].adjList[adjNode] if newDistance < graphObj.verticesList[adjNode].distance: graphObj.verticesList[adjNode].distance = newDistance graphObj.verticesList[adjNode].predecessor = currentVertex[1] index = pq.lookup[adjNode] pq.decreaseKey(index, newDistance) return graphObj
def singleSourceShortestPath(self, srcID): assert (srcID >= 0 and srcID < self.n) # Implement Dijkstra's algorithm # Input: # self --> a reference to a MyGraph instance # srcID: the id of the source vertex. # Expected Output: (d,pi) # d --> Map each vertex id v to the distance from srcID # pi --> Map each reachable vertex id v (except for srcID) to a parent. # Initialize the priority queue pq = PriorityQueue(self.n) #create the priority queue for i in range(0,self.n): # Iterate through all vertex ID if ( i == srcID): # If ID is srcID pq.set(i,0.0) # Distance of srcID should be zero else: # ID is not srcID pq.set(i, pq.Inf) # Distance should be infinity d = {} # Initialize the map with distances to nodes pi = {} # Initialize the map with parents of vertices d[srcID] = 0 # first node to dist map since while won't catch it. while not pq.isEmpty(): min = pq.extractMin() # Look at neighbors for neighbor in self.adjList[min[0]]: # where neighbor has not yet been removed from pq? alt = min[1] + neighbor[1] if pq.hasKey(neighbor[0]) and alt < pq.get(neighbor[0]): # previously stored needs to be replayed # Update distances and parents everywhere pq.set(neighbor[0], alt) d[neighbor[0]] = alt pi[neighbor[0]] = min[0] return (d,pi)
def prims(graphObj, start): pq = PriorityQueue() for vertex in graphObj.verticesList: if vertex == start: g.verticesList[vertex].distance = 0 pq.insert([0, vertex]) continue g.verticesList[vertex].distance = INFINITY pq.insert([INFINITY, vertex]) while(len(pq.pqueue)): currentVertex = pq.extractMin() if len(pq.pqueue) == 1: return for adjNode in graphObj.verticesList[currentVertex[1]].getConnections(): if adjNode in pq.lookup(adjNode): newDistance = graphObj.verticesList[currentVertex[1]].getCost(adjNode) if newDistance < graphObj.verticesList[adjNode].distance: graphObj.verticesList[adjNode].distance = newDistance graphObj.verticesList[adjNode].predecessor = currentVertex[1] return graphObj
def singleSourceShortestPath(self, srcID): assert (srcID >= 0 and srcID < self.n) # Implement Dijkstra's algorithm # Input: # self --> a reference to a MyGraph instance # srcID: the id of the source vertex. # Expected Output: (d,pi) # d --> Map each vertex id v to the distance from srcID # pi --> Map each reachable vertex id v (except for srcID) to a parent. # Initialize the priority queue pq = PriorityQueue(self.n) #create the priority queue for i in range(0, self.n): # Iterate through all vertex ID if (i == srcID): # If ID is srcID pq.set(i, 0.0) # Distance of srcID should be zero else: # ID is not srcID pq.set(i, pq.Inf) # Distance should be infinity d = {} # Initialize the map with distances to nodes pi = {} # Initialize the map with parents of vertices # COMPLETE the Dijkstra code here if srcID == None or self.adjList[ srcID] == None: #make sure srcId is not None return Dist = 0.0 for i in range(0, self.n): #iniatialize dictionaries to default values d[i] = pq.Inf pi[i] = i d[srcID] = 0.0 #set source to zero while (not pq.isEmpty()): #check if the queue is empty j = pq.extractMin( ) #tuple of min distance and vertex. j = (vertex,minDist) for i in self.adjList[j[0]]: if pq.hasKey( i[0] ): #assertion of pq.get(i) is that i must be in the priority queue if i[1] + j[1] < pq.get( i[0] ): #if distance of prior two nodes is less than current distance Dist = j[1] + i[1] pq.set(i[0], Dist) #update distance at vertex to Dist pi[i[0]] = j[0] #map vertex to its parent d[i[0]] = Dist #map vertex to its new distance return (d, pi)
def singleSourceShortestPath(self, srcID): assert (srcID >= 0 and srcID < self.n) # Implement Dijkstra's algorithm # Input: # self --> a reference to a MyGraph instance # srcID: the id of the source vertex. # Expected Output: (d,pi) # d --> Map each vertex id v to the distance from srcID # pi --> Map each reachable vertex id v (except for srcID) to a parent. # Initialize the priority queue pq = PriorityQueue(self.n) #create the priority queue for i in range(0, self.n): # Iterate through all vertex ID if (i == srcID): # If ID is srcID pq.set(i, 0.0) # Distance of srcID should be zero else: # ID is not srcID pq.set(i, pq.Inf) # Distance should be infinity d = {} # Initialize the map with distances to nodes pi = {} # Initialize the map with parents of vertices parent = None while not pq.isEmpty(): minNode = pq.extractMin() if parent is None: d[minNode[0]] = minNode[1] pi[minNode[0]] = minNode[0] elif minNode[1] != pq.Inf: d[minNode[0]] = float(round(decimal.Decimal(minNode[1]), 2)) else: d[minNode[0]] = pq.Inf lst = self.adjList[minNode[0]] for i in range(len(lst)): if pq.hasKey(lst[i][0]) and pq.get( lst[i][0]) > lst[i][1] + d[minNode[0]]: pi[lst[i][0]] = minNode[0] pq.set(lst[i][0], lst[i][1] + d[minNode[0]]) parent = minNode[0] return (d, pi)
def singleSourceShortestPath(self, srcID): assert (srcID >= 0 and srcID < self.n) # Implement Dijkstra's algorithm # Input: # self --> a reference to a MyGraph instance # srcID: the id of the source vertex. # Expected Output: (d,pi) # d --> Map each vertex id v to the distance from srcID # pi --> Map each reachable vertex id v (except for srcID) to a parent. # Initialize the priority queue pq = PriorityQueue(self.n) #create the priority queue for i in range(0,self.n): # Iterate through all vertex ID if ( i == srcID): # If ID is srcID pq.set(i,0.0) # Distance of srcID should be zero else: # ID is not srcID pq.set(i, pq.Inf) # Distance should be infinity d = {} # Initialize the map with distances to nodes pi = {} # Initialize the map with parents of vertices parent = None while not pq.isEmpty(): minNode = pq.extractMin() if parent is None: d[minNode[0]] = minNode[1] pi[minNode[0]] = minNode[0] elif minNode[1] != pq.Inf: d[minNode[0]] = float(round(decimal.Decimal(minNode[1]), 2)) else: d[minNode[0]] = pq.Inf lst = self.adjList[minNode[0]] for i in range(len(lst)): if pq.hasKey(lst[i][0]) and pq.get(lst[i][0]) > lst[i][1] + d[minNode[0]]: pi[lst[i][0]] = minNode[0] pq.set(lst[i][0], lst[i][1] + d[minNode[0]]) parent = minNode[0] return (d,pi)
def singleSourceShortestPath(self, srcID): assert (srcID >= 0 and srcID < self.n) # Implement Dijkstra's algorithm # Input: # self --> a reference to a MyGraph instance # srcID: the id of the source vertex. # Expected Output: (d,pi) # d --> Map each vertex id v to the distance from srcID # pi --> Map each reachable vertex id v (except for srcID) to a parent. # Initialize the priority queue pq = PriorityQueue(self.n) #create the priority queue for i in range(0,self.n): # Iterate through all vertex ID if ( i == srcID): # If ID is srcID pq.set(i,0.0) # Distance of srcID should be zero else: # ID is not srcID pq.set(i, pq.Inf) # Distance should be infinity d = {} # Initialize the map with distances to nodes pi = {} # Initialize the map with parents of vertices # COMPLETE the Dijkstra code here # self.n : number of vertices in the graph # self.adjList: Adjacency list stored as a list of lists. # self.adjList[i] stores all adjacent nodes to vertex ID i along with edge weights. # Eg., if vertex 2 has three edges (2,3) with weight 4.5, (2,4) with weight 3.2, and (2,5) with 2.1 # self.adjList[2] is the list [ (3,4.5), (4,3.2), (5,2.12) ] # your goal is to implement the singleSourceShortestPath function. while not pq.isEmpty(): (n, dist) = pq.extractMin() d[n] = dist neighbors = self.adjList[n] for i in range (0, len(neighbors)): (v, e) = neighbors[i] if pq.hasKey(v): oldDist = pq.get(v) #is it more efficient if these constants are declared outside the loop? newDist = dist + e if newDist < oldDist: pq.set(v, newDist) pi[v] = n return (d,pi)
def singleSourceShortestPath(self, srcID): assert (srcID >= 0 and srcID < self.n ) # ensure that srcID is between 0 and size of graph. # Implement Dijkstra's algorithm # Input: # self --> a reference to a MyGraph instance # srcID: the id of the source vertex. # Expected Output: (d,pi) # d --> Map each vertex id v to the distance from srcID # pi --> Map each reachable vertex id v (except for srcID) to a parent. # Initialize the priority queue pq = PriorityQueue(self.n) #create the priority queue for i in range(0, self.n): # Iterate through all vertex ID if i == srcID: # If ID is srcID pq.set(i, 0.0) # Distance of srcID should be zero else: # ID is not srcID pq.set(i, pq.Inf) # Distance should be infinity d = {} # Initialize the map with distances to nodes pi = {} # Initialize the map with parents of vertices while not pq.isEmpty(): # loop until priority queue is empty. (node, dist) = pq.extractMin() # extract smallest dist node. d[node] = dist # update dictionary with shortest distance. for (vertex, weight) in self.adjList[ node]: # check the adjacency list of popped node. newDist = dist + weight # calculate new distance. if pq.hasKey( vertex ): # if we haven't already popped the node in the adjacency list yet. if newDist < pq.get( vertex): # check distance vs new calculated dist. pq.set(vertex, newDist) # update priority queue. pi[vertex] = node # update parent list. return (d, pi)
def singleSourceShortestPath(self, srcID): assert (srcID >= 0 and srcID < self.n) # Implement Dijkstra's algorithm # Input: # self --> a reference to a MyGraph instance # srcID: the id of the source vertex. # Expected Output: (d,pi) # d --> Map each vertex id v to the distance from srcID # pi --> Map each reachable vertex id v (except for srcID) to a parent. # Initialize the priority queue pq = PriorityQueue(self.n) #create the priority queue for i in range(0, self.n): # Iterate through all vertex ID if (i == srcID): # If ID is srcID pq.set(i, 0.0) # Distance of srcID should be zero else: # ID is not srcID pq.set(i, pq.Inf) # Distance should be infinity d = {} # Initialize the map with distances to nodes pi = {} # Initialize the map with parents of vertices d[srcID] = 0 # first node to dist map since while won't catch it. while not pq.isEmpty(): min = pq.extractMin() # Look at neighbors for neighbor in self.adjList[min[ 0]]: # where neighbor has not yet been removed from pq? alt = min[1] + neighbor[1] if pq.hasKey(neighbor[0]) and alt < pq.get( neighbor[0]): # previously stored needs to be replayed # Update distances and parents everywhere pq.set(neighbor[0], alt) d[neighbor[0]] = alt pi[neighbor[0]] = min[0] return (d, pi)
def singleSourceShortestPath(self, srcID): assert (srcID >= 0 and srcID < self.n) # Implement Dijkstra's algorithm # Input: # self --> a reference to a MyGraph instance # srcID: the id of the source vertex. # Expected Output: (d,pi) # d --> Map each vertex id v to the distance from srcID # pi --> Map each reachable vertex id v (except for srcID) to a parent. # Initialize the priority queue pq = PriorityQueue(self.n) #create the priority queue for i in range(0,self.n): # Iterate through all vertex ID if ( i == srcID): # If ID is srcID pq.set(i,0.0) # Distance of srcID should be zero else: # ID is not srcID pq.set(i, pq.Inf) # Distance should be infinity d = {} # Initialize the map with distances to nodes pi = {} # Initialize the map with parents of vertices #Code Starts HERE d[srcID] = 0 #Set distances from source equal to 0 pi[srcID] = None #Set parents to None while not pq.isEmpty(): #While the priority queue is not empty (currentVertex,currentDistance) = pq.extractMin() #Extract the Min for (nextVertex, weight) in self.adjList[currentVertex]: newDist = weight + currentDistance if pq.hasKey(nextVertex): #Check if nextVertex exists in priority queue if newDist < pq.get(nextVertex): #If the new distance is less d[nextVertex] = newDist #Set new distnace pi[nextVertex] = currentVertex #Set the parents pq.set(nextVertex,newDist) #Set the new distance for the vertex return (d,pi)