[2] Implement pathfinding strategies (BFS, DFS, A*) with Strategy pattern

SavelevMI/docs/data/2-nd-exersize/pathfinding.py

@@ -0,0 +1,115 @@
+# Стратегии поиска пути: BFS, DFS, A* (Strategy pattern)
+
+from collections import deque
+import heapq
+
+
+class PathFindingStrategy:
+    
+    def find_path(self, maze, start, exit_cell):
+        raise NotImplementedError
+    
+    def _reconstruct_path(self, came_from, start, exit_cell):
+        path = []
+        current = exit_cell
+        while current is not None:
+            path.append(current)
+            current = came_from.get(current)
+        path.reverse()
+        return path
+    
+    def get_visited_count(self):
+        return getattr(self, '_visited_count', 0)
+
+
+class BFSStrategy(PathFindingStrategy):
+    
+    def find_path(self, maze, start, exit_cell):
+        queue = deque()
+        queue.append(start)
+        came_from = {start: None}
+        visited = {start}
+        
+        while queue:
+            current = queue.popleft()
+            
+            if current == exit_cell:
+                self._visited_count = len(visited)
+                return self._reconstruct_path(came_from, start, exit_cell)
+            
+            for neighbor in maze.get_neighbors(current):
+                if neighbor not in visited:
+                    visited.add(neighbor)
+                    came_from[neighbor] = current
+                    queue.append(neighbor)
+        
+        self._visited_count = len(visited)
+        return []
+
+
+class DFSStrategy(PathFindingStrategy):
+    
+    def find_path(self, maze, start, exit_cell):
+        stack = [start]
+        came_from = {start: None}
+        visited = {start}
+        
+        while stack:
+            current = stack.pop()
+            
+            if current == exit_cell:
+                self._visited_count = len(visited)
+                return self._reconstruct_path(came_from, start, exit_cell)
+            
+            for neighbor in maze.get_neighbors(current):
+                if neighbor not in visited:
+                    visited.add(neighbor)
+                    came_from[neighbor] = current
+                    stack.append(neighbor)
+        
+        self._visited_count = len(visited)
+        return []
+
+
+class AStarStrategy(PathFindingStrategy):
+    
+    def _heuristic(self, cell, exit_cell):
+        return abs(cell.x - exit_cell.x) + abs(cell.y - exit_cell.y)
+    
+    def find_path(self, maze, start, exit_cell):
+        heap = []
+        counter = 0
+        
+        start_f = self._heuristic(start, exit_cell)
+        heapq.heappush(heap, (start_f, counter, start))
+        counter += 1
+        
+        came_from = {}
+        g_score = {start: 0}
+        f_score = {start: start_f}
+        visited = set()
+        
+        while heap:
+            current_f, _, current = heapq.heappop(heap)
+            visited.add(current)
+            
+            if current == exit_cell:
+                self._visited_count = len(visited)
+                return self._reconstruct_path(came_from, start, exit_cell)
+            
+            if current_f > f_score.get(current, float('inf')):
+                continue
+            
+            for neighbor in maze.get_neighbors(current):
+                tentative_g = g_score[current] + 1
+                
+                if tentative_g < g_score.get(neighbor, float('inf')):
+                    came_from[neighbor] = current
+                    g_score[neighbor] = tentative_g
+                    new_f = tentative_g + self._heuristic(neighbor, exit_cell)
+                    f_score[neighbor] = new_f
+                    heapq.heappush(heap, (new_f, counter, neighbor))
+                    counter += 1
+        
+        self._visited_count = len(visited)
+        return []