Add A*, summary, bonus tasks, resources

Author: effa

search.py

@@ -239,7 +239,7 @@ def get_root(parents):
 #    return State(world)
 
 
-def show_search_tree(tree, fringe, explored, costs=None):
+def show_search_tree(tree, fringe, explored, costs=None, heuristic=None):
     state = explored[-1] if explored else get_root(tree)
     show_state(state)
     for child, parent in tree.items():
@@ -250,9 +250,18 @@ def show_search_tree(tree, fringe, explored, costs=None):
     xs = [s.spaceship.col + 0.5 for s in explored]
     ys = [state.n - s.spaceship.row - 0.5 for s in explored]
     if costs:
-        labels = [
-            '{order}\nc={cost}'.format(order=i, cost=costs[s])
-            for i, s in enumerate(explored, start=1)]
+        if heuristic:
+            labels = [
+                '{order}\n{g}+{h}={f}'.format(
+                    order=i,
+                    g=costs[s],
+                    h=heuristic[s],
+                    f=costs[s]+heuristic[s])
+                for i, s in enumerate(explored, start=1)]
+        else:
+            labels = [
+                '{order}\nc={cost}'.format(order=i, cost=costs[s])
+                for i, s in enumerate(explored, start=1)]
     else:
         labels = [str(i) for i in range(1,len(explored)+1)]
     for label, x, y in zip(labels, xs, ys):
@@ -269,6 +278,14 @@ def show_search_tree(tree, fringe, explored, costs=None):
         labels = [
             '{order}\nc={cost}'.format(order='?', cost=costs[s])
             for s in fringe]
+        if heuristic:
+            labels = [
+                '{order}\n{g}+{h}={f}'.format(
+                    order='?',
+                    g=costs[s],
+                    h=heuristic[s],
+                    f=costs[s]+heuristic[s])
+                for s in fringe]
         for label, x, y in zip(labels, xs, ys):
             plt.text(
                 x, y, label,
@@ -280,7 +297,8 @@ def show_search_tree(tree, fringe, explored, costs=None):
 
 
 def create_tree_search_widget(explored_states, trees, fringes,
-                              costs=None, interactive=False):
+                              costs=None, heuristic=None,
+                              interactive=False):
     if not trees:
         print('Zadne stromy k zobrazeni.')
         return
@@ -292,6 +310,7 @@ def show_search_tree_at(step):
             tree,
             fringe=fringe,
             costs=costs[step] if costs else None,
+            heuristic=heuristic[step] if heuristic else None,
             explored=explored_states[:step])
 
     if interactive:
@@ -313,17 +332,20 @@ def set_output(self, text=False, widget=False):
         self.output_text = text
         self.output_widget = widget
 
-    def start_search(self, state, costs=False):
+    def start_search(self, state, costs=False, heuristic=False):
         self.explored_states = []
         self.trees = [{state: None}]
         self.fringes = [set([state])]
         self.costs = [{state: 0}] if costs else None
+        # TODO: fix hodnota heuristiky v pocatecnim stavu
+        # (neni jasne jak, mozna post-fix po prvnim zalognuti)
+        self.heuristic = [{state: 0}] if heuristic else None
         self.log('start search')
 
     def end_search(self, interactive=False):
         create_tree_search_widget(
             self.explored_states, self.trees, self.fringes,
-            costs=self.costs,
+            costs=self.costs, heuristic=self.heuristic,
             interactive=interactive)
 
     def log(self, message):
@@ -332,7 +354,7 @@ def log(self, message):
             print('{step}: {message}'.format(
                 step=step, message=message))
 
-    def log_search_step(self, explored_state, fringe, costs=None):
+    def log_search_step(self, explored_state, fringe, costs=None, heuristic=None):
         # TODO: check type of states from fringe
         fringe = set(state for state in fringe)
         last_tree = self.trees[-1]
@@ -350,18 +372,23 @@ def log_search_step(self, explored_state, fringe, costs=None):
             if costs is None:
                 raise ValueError('Zadejte i ceny stavu.')
             self.costs.append(deepcopy(costs))
+        if self.heuristic:
+            if heuristic is None:
+                raise ValueError('Zadejte i heuristiky.')
+            self.heuristic.append(deepcopy(heuristic))
         self.log(str(fringe))
 
 
 LOGGER = Logger()
 LOGGER.set_output(text=False, widget=True)
 
 @contextmanager
-def visualize_search(state, interactive=False, costs=False):
-    LOGGER.start_search(state, costs=costs)
+def visualize_search(state, interactive=False, costs=False, heuristic=False):
+    LOGGER.start_search(state, costs=costs, heuristic=heuristic)
     yield
     LOGGER.end_search(interactive=interactive)
 
 
-def log_search_step(explored_state, fringe, costs=None):
-    LOGGER.log_search_step(explored_state, fringe, costs=costs)
+def log_search_step(explored_state, fringe, costs=None, heuristic=None):
+    LOGGER.log_search_step(
+        explored_state, fringe, costs=costs, heuristic=heuristic)

solutions.py

@@ -83,3 +83,88 @@ def ucs(initial_state):
                 costs[next_state] = new_cost
                 plans[next_state] = plans[state] + action
         log_search_step(state, fringe, costs)
+
+
+def heuristic_distance(state):
+    # Cilovy radek ma hodnotu 0, radek pod nim 1, atd.
+    vertical_distance = state.spaceship.row
+    # Jaka by byla cena, kdyby raketka mohla letet porad rovne.
+    return vertical_distance * ACTION_COSTS['f']
+
+
+def a_star(initial_state):
+    fringe = {initial_state}
+    costs = {initial_state: 0}
+    heuristic = {initial_state: heuristic_distance(initial_state)}
+    plans = {initial_state: ''}
+    while fringe:
+        state = min(fringe, key=lambda s: costs[s] + heuristic[s])
+        fringe.remove(state)
+        if is_goal(state):
+            log_search_step(state, fringe, costs, heuristic)
+            return plans[state]
+        for action in actions(state):
+            next_state = move(state, action)
+            new_cost = costs[state] + ACTION_COSTS[action]
+            old_cost = costs.get(next_state, inf)
+            if new_cost < old_cost:
+                fringe.add(next_state)
+                costs[next_state] = new_cost
+                plans[next_state] = plans[state] + action
+            if next_state not in heuristic:
+                heuristic[next_state] = heuristic_distance(next_state)
+        log_search_step(state, fringe, costs, heuristic)
+
+
+# ----------------------------------------------------------------------------
+
+# Obecne schema stromoveho prohledavani.
+# Je parametrizovane typem okraje (Fringe), ktery
+# popisuje strategii pro vyber stavu k prozkoumani.
+def tree_search(initial_state, Fringe=set):
+    fringe = Fringe([initial_state])
+    plans = {initial_state: ''}
+    while fringe:
+        # Vyber jednoho stavu z okraje.
+        state = fringe.pop()
+        # Pokud je tento stav cilovy, muzeme prohledavani ukoncit.
+        if is_goal(state):
+            log_search_step(state, fringe)
+            return plans[state]
+        # Pokud neni, expandujeme tento stav, tj. pridame na okraj
+        # vsechny jeho nasledniky.
+        for action in actions(state):
+            next_state = move(state, action)
+            plans[next_state] = plans[state] + action
+            fringe.add(next_state)
+        log_search_step(state, fringe)
+
+
+# Rekurzivni DFS pro stromy (nehlida zacykleni)
+def recursive_dfs(state):
+    if is_goal(state):
+        return [state]
+    for action in actions(state):
+        next_state = move(state, action)
+        path = recursive_dfs(next_state)
+        if path:
+            return [state] + path
+    return None  # no path found
+
+
+# Rekurzivni DFS pro grafy (hlida zacykleni)
+def recursive_graph_dfs(start_state):
+    explored = set()
+    def dfs(state):
+        explored.add(state)
+        if is_goal(state):
+            return [state]
+        for action in actions(state):
+            next_state = move(state, action)
+            if next_state in explored:
+                continue
+            path = dfs(next_state)
+            if path:
+                return [state] + path
+        return None  # no path found
+    return dfs(start_state)