Python PriorityQueue.get方法代码示例

# 需要导入模块: from priorityQueue import PriorityQueue [as 别名]
# 或者: from priorityQueue.PriorityQueue import get [as 别名]
    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)

# 需要导入模块: from priorityQueue import PriorityQueue [as 别名]
# 或者: from priorityQueue.PriorityQueue import get [as 别名]
    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)

# 需要导入模块: from priorityQueue import PriorityQueue [as 别名]
# 或者: from priorityQueue.PriorityQueue import get [as 别名]
    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)

# 需要导入模块: from priorityQueue import PriorityQueue [as 别名]
# 或者: from priorityQueue.PriorityQueue import get [as 别名]
    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)

# 需要导入模块: from priorityQueue import PriorityQueue [as 别名]
# 或者: from priorityQueue.PriorityQueue import get [as 别名]
class Sim:
    def __init__(self):
        self.q = PriorityQueue()
        self.time = 100
        self.nodes = {}
        self.actors = []
        self.done = False

    def add_actor(self, actor):
        actor.sim = self
        self.actors.append(actor)

    def at(self, event):
        if event.time < self.time:
            print "ERROR, time warp"
        else:
            self.q.put(event, event.time)

    def process(self):
        while not self.q.empty():
            event = self.q.get()
            self.time = event.time
            try:
                (result, actor) = event.process(self)
                actor.send(result)
            except StopIteration:
                pass
        print "Sim done"

    def prime(self):
        for a in self.actors:
            a.prime()

    def go(self):
        self.prime()
        self.process()