UCS

graph.py

@@ -7,7 +7,7 @@ class Node:
         self.parent = None
         self.name = name
         self.edges = []
-        self.value = 0
+        self.value = 0  # cost reaching this node
 
 class Edge:
 

main.py

@@ -21,43 +21,48 @@ romania = Graph( ['Or', 'Ne', 'Ze', 'Ia', 'Ar', 'Si', 'Fa',
                 ] )
 
 def search(graph, queue, start_node_name, target_node_name):
-    cost = 0
     visited_nodes = []   # Nodes which have been visited
     path = []
 
     start_node = getNode(start_node_name, graph.nodes)
     target_node = getNode(target_node_name, graph.nodes)
 
+    start_node.value = 0
+
     queue.push(start_node)
 
     while not queue.empty():
         current_node = queue.pop()
         visited_nodes.append(current_node.name)
 
-        if current_node == target_node:
-            path.append(current_node.name)
-            tmp = current_node
-            while not tmp == start_node:
-                for edge in tmp.parent.edges:
-                    if edge.end.name == tmp.name:
-                        cost += edge.value
-                tmp = tmp.parent
-                path.insert(0, tmp.name)    # reversed insertion
-        else:
+        if not current_node == target_node:
             for edge in current_node.edges:
                 neighbor = edge.end
+                condition = not visited_nodes.__contains__(neighbor.name)
+                new_cost = current_node.value + edge.value
+
+                # UCS
+                if queue.type == 'PRIO':
+                    condition = not visited_nodes.__contains__(neighbor.name) and new_cost < neighbor.value
 
                 # works with digraph, because current_node is marked at this point, a cycle is not possible
-                if not visited_nodes.__contains__(neighbor.name):
-                    queue.push(neighbor)
+                if condition:
                     neighbor.parent = current_node
+                    neighbor.value = new_cost
+                    queue.push(neighbor)
+        else:
+            path.append(current_node.name)
+            while not current_node == start_node:
+                current_node = current_node.parent
+                path.insert(0, current_node.name)
+
 
     if path.__len__() == 0:
         print('zwischen ' + start_node_name + ' und ' + target_node_name + ' konnte kein Pfad gefunden werden')
     else:
         print('From ' + start_node_name + ' to ' + target_node_name + ': ')
         print('Path: ' + path.__str__().format())
-        print('Cost: ' + cost.__str__())
+        print('Cost: ' + target_node.value.__str__())
 
 def bfs(graph, start_node_name, target_node_name):
     search(graph,Queue('FIFO'),start_node_name, target_node_name)
@@ -65,9 +70,14 @@ def bfs(graph, start_node_name, target_node_name):
 def dfs(graph, start_node_name, target_node_name):
     search(graph,Queue('LIFO'),start_node_name, target_node_name)
 
+def utc(graph, start_node_name, target_node_name):
+    search(graph,Queue('PRIO'),start_node_name, target_node_name)
+
+
 def main():
     bfs(romania, 'Ti', 'Bu')
     dfs(romania, 'Ti', 'Bu')
+    utc(romania, 'Or', 'Si')
 
 if __name__ == "__main__":
     main()