Example #1
0
def shortest_path(graph, sourceVertex):

    min_heap = PriorityQueue(True)
    distance = {}
    parent = {}

    for vertex in graph.all_vertex.values():
        min_heap.add_task(sys.maxsize, vertex)

    min_heap.change_task_priority(0, sourceVertex)
    distance[sourceVertex] = 0
    parent[sourceVertex] = None

    while min_heap.is_empty() is False:
        task = min_heap.peek_task()
        weight = min_heap.get_task_priority(task)               
        current =  min_heap.pop_task()
        distance[current] = weight

        for edge in current.edges:
            adjacent = get_other_vertex_for_edge(current, edge)
            if min_heap.contains_task(adjacent) is False:
                continue

            new_distance = distance[current] + edge.weight;
            if min_heap.get_task_priority(adjacent) > new_distance:
                min_heap.change_task_priority(new_distance, adjacent)
                parent[adjacent] = current
                

    return distance
Example #2
0
def minimum_spanning_tree(graph):

    min_heap = PriorityQueue(True)
    vertex_to_edge = {}
    result = []

    for vertex in graph.all_vertex.values():
        min_heap.add_task(sys.maxsize, vertex)

    start_vertex = next(iter((graph.all_vertex.values())))
    min_heap.change_task_priority(0, start_vertex)
    while min_heap.is_empty() is False:
        current = min_heap.pop_task()

        if (current in vertex_to_edge):
            spanning_tree_edge = vertex_to_edge[current]
            result.append(spanning_tree_edge)

        for edge in current.edges:
            adjacent = get_other_vertex_for_edge(current, edge)
            if min_heap.contains_task(
                    adjacent) is True and min_heap.get_task_priority(
                        adjacent) > edge.weight:
                min_heap.change_task_priority(edge.weight, adjacent)
                vertex_to_edge[adjacent] = edge

    return result
Example #3
0
 def print_ordered(self):
     pq = PriorityQueue()
     for n in self.d:
         prob = self.d[n]
         pq.add_task(n, prob)
     #endfor
     sorted = pq.sorted_queue()
     norms = [x for x in reversed(sorted)]
     for n in norms:
         print n, self.d[n]
  def most_probable_norms(self, topN):
    """Computes the topN most probable norms within a suite, returning either a single norm 
       (if there is a unique most likely norm) or all norms tied at the top"""
    pq = PriorityQueue()
    for n in self.d:
        prob = self.d[n]
        pq.add_task(n, prob)
    #endfor
    sorted_norms = pq.sorted_queue()
    norms = [x for x in reversed(sorted_norms)]
    
    # Check that we select either the topN, or the first ones with the same odds
    for (i,n) in enumerate(norms):
        if(i+1 == topN):
            tied = len(norms) > i+1 and (self.d[n] == self.d[norms[i+1]])
            if (tied): 
                topN += 1
#                 print "Tie between norms %s and %s with prob=%d, topN is now %d" % (n,norms[i-1],self.d[n],topN)                         else: 
                break
    #endfor
    return (norms[0:topN],topN)
Example #5
0
    def most_probable_norms(self, topN):
        """Computes the topN most probable norms within a suite, returning either """
        pq = PriorityQueue()
        for n in self.d:
            prob = self.d[n]
            pq.add_task(n, prob)
        #endfor
        sorted = pq.sorted_queue()
        norms = [x for x in reversed(sorted)]
        # Check that we select either the topN, or the first ones with the same odds
        i = 1
        for n in norms[1:]:
            tied = (self.d[n] == self.d[norms[i - 1]])
            if (i > topN):
                if (tied):
                    topN += 1


#                 print "Tie between norms %s and %s with prob=%d, topN is now %d" % (n,norms[i-1],self.d[n],topN)
                else:
                    break
            i += 1
        #endfor
        return (norms[0:topN], topN)