Search: Bidirectional Search (aimacode#554)

* Add bidirectional search + update h function

* add bidirectional search test

Author: antmarakis

search.py

@@ -305,6 +305,85 @@ def iterative_deepening_search(problem):
         if result != 'cutoff':
             return result
 
+# ______________________________________________________________________________
+# Bidirectional Search
+# Pseudocode from https://webdocs.cs.ualberta.ca/%7Eholte/Publications/MM-AAAI2016.pdf
+
+def bidirectional_search(problem):
+    e = problem.find_min_edge()
+    gF, gB = {problem.initial : 0}, {problem.goal : 0}
+    openF, openB = [problem.initial], [problem.goal]
+    closedF, closedB = [], []
+    U = infinity
+
+
+    def extend(U, open_dir, open_other, g_dir, g_other, closed_dir):
+        """Extend search in given direction"""
+        n = find_key(C, open_dir, g_dir)
+
+        open_dir.remove(n)
+        closed_dir.append(n)
+
+        for c in problem.actions(n):
+            if c in open_dir or c in closed_dir:
+                if g_dir[c] <= problem.path_cost(g_dir[n], n, None, c):
+                    continue
+
+                open_dir.remove(c)
+
+            g_dir[c] = problem.path_cost(g_dir[n], n, None, c)
+            open_dir.append(c)
+
+            if c in open_other:
+                U = min(U, g_dir[c] + g_other[c])
+
+        return U, open_dir, closed_dir, g_dir
+
+
+    def find_min(open_dir, g):
+        """Finds minimum priority, g and f values in open_dir"""
+        m, m_f = infinity, infinity
+        for n in open_dir:
+            f = g[n] + problem.h(n)
+            pr = max(f, 2*g[n])
+            m = min(m, pr)
+            m_f = min(m_f, f)
+
+        return m, m_f, min(g.values())
+
+
+    def find_key(pr_min, open_dir, g):
+        """Finds key in open_dir with value equal to pr_min
+        and minimum g value."""
+        m = infinity
+        state = -1
+        for n in open_dir:
+            pr = max(g[n] + problem.h(n), 2*g[n])
+            if pr == pr_min:
+                if g[n] < m:
+                    m = g[n]
+                    state = n
+
+        return state
+
+
+    while openF and openB:
+        pr_min_f, f_min_f, g_min_f = find_min(openF, gF)
+        pr_min_b, f_min_b, g_min_b = find_min(openB, gB)
+        C = min(pr_min_f, pr_min_b)
+
+        if U <= max(C, f_min_f, f_min_b, g_min_f + g_min_b + e):
+            return U
+
+        if C == pr_min_f:
+            # Extend forward
+            U, openF, closedF, gF = extend(U, openF, openB, gF, gB, closedF)
+        else:
+            # Extend backward
+            U, openB, closedB, gB = extend(U, openB, openF, gB, gF, closedB)
+
+    return infinity
+
 # ______________________________________________________________________________
 # Informed (Heuristic) Search
 
@@ -848,6 +927,9 @@ def h(self, node):
         """h function is straight-line distance from a node's state to goal."""
         locs = getattr(self.graph, 'locations', None)
         if locs:
+            if type(node) is str:
+                return int(distance(locs[node], locs[self.goal]))
+
             return int(distance(locs[node.state], locs[self.goal]))
         else:
             return infinity

tests/test_search.py

@@ -43,6 +43,10 @@ def test_depth_limited_search():
     assert solution_50[-1] == 'Bucharest'
 
 
+def test_bidirectional_search():
+    assert bidirectional_search(romania_problem) == 418
+
+
 def test_astar_search():
     assert astar_search(romania_problem).solution() == ['Sibiu', 'Rimnicu', 'Pitesti', 'Bucharest']