diff --git a/groshevava/docs/data/builders.py b/groshevava/docs/data/builders.py
new file mode 100644
index 0000000..3235376
--- /dev/null
+++ b/groshevava/docs/data/builders.py
@@ -0,0 +1,75 @@
+# maze_solver/builders.py
+from abc import ABC, abstractmethod
+from models import Cell, Maze
+
+
+class MazeBuilder(ABC):
+    """Интерфейс строителя лабиринта."""
+    @abstractmethod
+    def buildFromFile(self, filename: str) -> Maze:
+        """Строит объект Maze из файла."""
+        pass
+
+
+class TextFileMazeBuilder(MazeBuilder):
+    """Строитель для текстового формата: ■ стена, ' ' проход, S старт, E выход."""
+    
+    # Поддерживаемые символы стен
+    WALL_SYMBOLS = {'#', '■', '█', '▓', '▒', '░'}
+    
+    def __init__(self, require_exit: bool = True):
+        """
+        Args:
+            require_exit: Если False, позволяет создавать лабиринты без выхода
+        """
+        self.require_exit = require_exit
+
+    def buildFromFile(self, filename: str) -> Maze:
+        with open(filename, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+
+        # Убираем символы новой строки и пустые строки в конце файла
+        cleaned_lines = [line.rstrip('\n') for line in lines if line.strip() != '']
+
+        if not cleaned_lines:
+            raise ValueError("Файл лабиринта пуст")
+
+        height = len(cleaned_lines)
+        width = len(cleaned_lines[0])
+
+        grid = []
+        start_cell = None
+        exit_cell = None
+
+        for y, line in enumerate(cleaned_lines):
+            row = []
+            if len(line) != width:
+                raise ValueError(
+                    f"Строка {y} имеет длину {len(line)}, ожидалось {width}. "
+                    f"Лабиринт должен быть прямоугольным."
+                )
+
+            for x, char in enumerate(line):
+                is_wall = char in self.WALL_SYMBOLS
+                cell = Cell(x, y, is_wall)
+
+                if char == 'S':
+                    cell.isStart = True
+                    start_cell = cell
+                elif char == 'E':
+                    cell.isExit = True
+                    exit_cell = cell
+
+                row.append(cell)
+            grid.append(row)
+
+        if not start_cell:
+            raise ValueError("В лабиринте не найдена стартовая позиция (S)")
+        
+        if self.require_exit and not exit_cell:
+            raise ValueError("В лабиринте не найдена выходная позиция (E)")
+
+        maze = Maze(width, height, grid)
+        maze.start = start_cell
+        maze.exit = exit_cell
+        return maze
\ No newline at end of file
diff --git a/groshevava/docs/data/empty_maze.txt b/groshevava/docs/data/empty_maze.txt
new file mode 100644
index 0000000..87c27f3
--- /dev/null
+++ b/groshevava/docs/data/empty_maze.txt
@@ -0,0 +1,10 @@
+■■■■■■■■■■
+■S       ■
+■        ■
+■        ■
+■        ■
+■        ■
+■        ■
+■        ■
+■       E■
+■■■■■■■■■■
\ No newline at end of file
diff --git a/groshevava/docs/data/large_maze.txt b/groshevava/docs/data/large_maze.txt
new file mode 100644
index 0000000..837792d
--- /dev/null
+++ b/groshevava/docs/data/large_maze.txt
@@ -0,0 +1,100 @@
+■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
+■S                  ■ ■ ■             ■     ■     ■     ■     ■   ■     ■           ■ ■             
+■■■ ■ ■■■■■■■■■■■■■■■ ■ ■ ■■■■■ ■■■■■■■ ■■■■■ ■ ■■■ ■ ■■■ ■■■■■ ■■■■■ ■■■ ■■■■■ ■■■■■ ■ ■■■■■ ■ ■■■■
+■   ■   ■   ■               ■ ■ ■ ■       ■ ■ ■ ■   ■ ■   ■ ■ ■ ■   ■ ■       ■ ■ ■     ■   ■ ■     
+■ ■■■ ■ ■ ■■■■■ ■ ■ ■ ■■■■■■■ ■■■ ■■■■■ ■■■ ■ ■■■ ■■■■■■■ ■ ■ ■ ■ ■■■ ■ ■■■■■ ■■■ ■ ■ ■■■ ■ ■■■■■ ■■
+■ ■   ■ ■       ■ ■ ■       ■   ■ ■             ■ ■ ■   ■       ■   ■       ■       ■     ■     ■   
+■■■■■ ■■■ ■■■■■ ■■■ ■ ■■■ ■■■ ■■■ ■■■ ■ ■■■■■■■■■ ■ ■ ■■■■■ ■■■■■ ■ ■ ■■■■■ ■■■ ■■■■■■■■■■■■■■■■■■■ 
+■             ■ ■ ■ ■   ■   ■   ■     ■ ■ ■ ■     ■ ■   ■       ■ ■       ■ ■         ■   ■ ■ ■ ■ ■ 
+■ ■ ■ ■ ■ ■■■■■ ■ ■ ■■■■■■■■■ ■■■ ■■■ ■■■ ■ ■ ■ ■■■ ■ ■■■ ■■■■■■■ ■■■ ■■■■■ ■■■■■■■■■■■ ■■■ ■ ■ ■ ■■
+■ ■ ■ ■ ■     ■ ■ ■       ■         ■     ■   ■   ■ ■   ■     ■     ■ ■   ■ ■ ■   ■   ■             
+■ ■■■ ■ ■ ■ ■■■■■ ■■■■■■■■■ ■■■■■■■ ■ ■■■■■ ■■■■■■■ ■■■ ■ ■■■■■ ■■■ ■■■ ■ ■■■ ■ ■ ■ ■ ■ ■■■ ■ ■■■■■■
+■ ■   ■ ■ ■ ■ ■     ■ ■ ■ ■   ■   ■ ■   ■ ■ ■   ■ ■ ■         ■   ■     ■       ■ ■ ■ ■   ■ ■     ■ 
+■ ■■■ ■■■ ■■■ ■■■■■ ■ ■ ■ ■ ■■■ ■■■■■■■■■ ■ ■ ■■■ ■ ■ ■■■■■ ■ ■ ■■■■■■■■■ ■ ■■■ ■■■ ■■■ ■■■■■■■■■■■ 
+■ ■     ■     ■ ■   ■                         ■ ■         ■ ■ ■ ■ ■ ■ ■ ■ ■   ■ ■ ■   ■   ■     ■ ■ 
+■■■■■ ■■■■■■■■■ ■■■ ■ ■■■■■ ■■■■■■■■■■■ ■ ■ ■■■ ■■■■■ ■■■ ■■■■■ ■ ■ ■ ■ ■■■■■ ■■■ ■ ■■■ ■ ■ ■■■■■ ■ 
+■           ■             ■ ■       ■   ■ ■       ■     ■       ■         ■ ■     ■   ■ ■   ■   ■   
+■■■■■ ■ ■ ■■■ ■■■ ■■■ ■ ■■■■■ ■■■■■ ■■■ ■■■■■ ■■■ ■ ■■■■■ ■ ■ ■■■ ■■■■■■■ ■ ■ ■ ■ ■ ■■■ ■■■■■ ■■■ ■■
+■     ■ ■       ■ ■ ■ ■           ■ ■     ■ ■ ■         ■ ■ ■       ■   ■ ■   ■ ■   ■   ■ ■ ■       
+■■■■■ ■■■ ■ ■ ■■■ ■ ■■■ ■■■ ■ ■■■■■ ■ ■ ■ ■ ■■■ ■ ■ ■ ■■■ ■■■ ■■■ ■■■ ■ ■■■■■■■■■■■■■ ■ ■ ■ ■■■ ■■■■
+■     ■   ■ ■ ■       ■   ■ ■   ■ ■ ■ ■ ■     ■ ■ ■ ■ ■   ■     ■     ■ ■       ■     ■ ■           
+■ ■ ■ ■■■■■ ■ ■■■ ■ ■ ■■■■■■■ ■■■ ■■■■■ ■■■■■ ■ ■ ■ ■ ■ ■ ■■■■■ ■■■ ■■■■■■■ ■■■■■ ■■■■■■■ ■■■■■■■■■ 
+■ ■ ■     ■ ■   ■ ■ ■   ■ ■       ■   ■     ■ ■ ■ ■ ■ ■ ■     ■ ■     ■   ■   ■   ■   ■ ■         ■ 
+■ ■■■ ■ ■■■ ■ ■■■ ■■■ ■■■ ■■■■■■■ ■ ■■■ ■ ■■■ ■■■■■■■■■■■ ■■■■■■■■■ ■ ■ ■■■ ■■■■■ ■ ■■■ ■ ■■■ ■■■ ■■
+■   ■ ■ ■   ■ ■     ■         ■ ■   ■ ■ ■ ■     ■   ■ ■ ■         ■ ■                     ■ ■   ■   
+■ ■■■ ■ ■■■■■■■■■ ■■■ ■■■ ■■■ ■ ■■■■■ ■■■■■ ■■■■■ ■■■ ■ ■ ■■■ ■ ■■■■■ ■ ■■■■■■■ ■■■ ■ ■ ■■■ ■ ■ ■■■ 
+■   ■ ■     ■ ■   ■ ■ ■     ■   ■         ■ ■ ■ ■           ■ ■     ■ ■ ■         ■ ■ ■   ■ ■ ■   ■ 
+■■■ ■■■ ■■■■■ ■■■ ■ ■■■■■■■ ■■■ ■ ■ ■■■■■ ■■■ ■ ■■■ ■■■ ■■■ ■■■■■■■ ■ ■■■■■■■ ■ ■■■ ■■■■■ ■ ■■■■■■■■
+■   ■     ■ ■       ■ ■ ■ ■ ■ ■   ■     ■ ■ ■ ■ ■ ■ ■     ■     ■ ■ ■   ■ ■   ■ ■     ■ ■         ■ 
+■ ■ ■■■■■■■ ■■■■■■■ ■ ■ ■ ■■■ ■ ■ ■ ■■■■■■■ ■ ■ ■ ■ ■ ■■■■■ ■ ■ ■ ■ ■■■■■ ■ ■ ■■■■■ ■■■ ■■■■■■■■■■■ 
+■ ■   ■ ■                     ■ ■ ■ ■             ■ ■     ■ ■ ■   ■       ■ ■   ■                   
+■ ■ ■■■ ■ ■ ■ ■■■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■■■ ■■■ ■ ■ ■■■■■■■ ■ ■■■■■■■■■■■ ■ ■■■■■■■ ■ ■ ■■■■■■■ ■ ■ ■■
+■ ■ ■     ■ ■ ■   ■ ■ ■ ■ ■ ■ ■ ■ ■     ■   ■ ■ ■ ■     ■ ■     ■     ■ ■       ■ ■ ■ ■ ■     ■ ■   
+■■■ ■■■■■ ■ ■ ■■■ ■ ■ ■■■ ■■■■■■■■■■■■■■■ ■■■■■■■■■ ■ ■■■■■ ■ ■ ■ ■■■■■■■■■■■■■ ■■■ ■■■ ■■■ ■ ■ ■■■ 
+■   ■     ■ ■ ■   ■ ■   ■   ■       ■   ■ ■ ■       ■     ■ ■ ■     ■ ■ ■     ■ ■       ■   ■ ■   ■ 
+■■■ ■■■ ■ ■ ■■■■■■■■■ ■■■■■■■ ■■■■■■■■■ ■■■ ■■■ ■■■ ■■■■■ ■ ■ ■■■ ■■■ ■ ■ ■ ■■■ ■ ■ ■ ■ ■ ■ ■■■ ■ ■■
+■   ■   ■ ■ ■           ■   ■ ■ ■ ■       ■       ■     ■ ■ ■   ■         ■   ■ ■ ■ ■ ■ ■ ■ ■   ■   
+■ ■■■ ■■■■■ ■ ■■■■■■■ ■■■ ■■■ ■ ■ ■■■■■■■ ■ ■ ■■■■■■■■■■■■■■■ ■ ■ ■ ■■■■■ ■■■ ■■■■■■■ ■■■■■■■■■ ■ ■■
+■ ■   ■ ■   ■ ■   ■   ■ ■     ■ ■ ■         ■ ■   ■ ■     ■   ■ ■ ■     ■   ■       ■   ■ ■     ■ ■ 
+■ ■■■■■ ■■■ ■ ■■■ ■ ■ ■ ■ ■■■■■ ■ ■ ■■■ ■■■ ■■■ ■■■ ■ ■ ■■■■■ ■ ■ ■ ■■■■■■■■■ ■ ■■■■■■■■■ ■ ■ ■ ■■■ 
+■   ■       ■ ■     ■     ■   ■ ■     ■   ■           ■     ■ ■ ■ ■         ■ ■ ■ ■ ■     ■ ■ ■     
+■■■■■ ■ ■ ■ ■■■■■ ■■■ ■ ■ ■■■ ■ ■ ■■■■■ ■■■ ■ ■■■■■■■■■■■ ■■■■■ ■■■ ■ ■ ■■■■■■■■■ ■ ■ ■■■■■ ■ ■ ■■■ 
+■     ■ ■ ■   ■   ■   ■ ■         ■ ■ ■ ■   ■           ■ ■   ■ ■ ■ ■ ■               ■ ■   ■ ■   ■ 
+■ ■ ■■■■■■■ ■■■ ■ ■ ■ ■ ■ ■■■ ■■■ ■ ■ ■■■ ■■■ ■ ■ ■■■■■■■■■■■ ■■■ ■■■■■ ■ ■■■ ■ ■ ■■■ ■ ■■■ ■■■■■ ■ 
+■ ■ ■       ■ ■ ■ ■ ■ ■ ■ ■     ■       ■ ■   ■ ■                   ■ ■ ■ ■ ■ ■ ■   ■   ■   ■ ■ ■ ■ 
+■■■ ■■■ ■■■ ■ ■■■ ■■■■■ ■ ■ ■ ■■■ ■■■■■■■■■■■ ■ ■ ■■■■■■■■■■■■■■■ ■■■ ■■■■■ ■■■■■■■■■■■ ■■■■■ ■ ■ ■ 
+■   ■   ■   ■         ■ ■ ■ ■   ■ ■   ■ ■     ■ ■       ■ ■   ■       ■   ■   ■     ■ ■       ■   ■ 
+■ ■ ■■■ ■ ■ ■ ■■■ ■■■■■ ■■■■■ ■ ■ ■ ■■■ ■■■ ■ ■■■ ■■■ ■■■ ■ ■■■■■ ■■■ ■■■ ■■■ ■ ■ ■■■ ■■■■■■■■■ ■■■ 
+■ ■ ■ ■ ■ ■ ■ ■   ■     ■   ■ ■ ■       ■   ■ ■ ■   ■ ■     ■   ■   ■           ■   ■ ■   ■     ■ ■ 
+■■■■■ ■■■ ■ ■ ■■■ ■ ■■■ ■ ■■■ ■■■ ■■■■■■■■■■■ ■ ■■■■■■■■■ ■■■ ■■■ ■■■■■ ■ ■■■■■■■ ■■■ ■ ■■■■■■■■■ ■■
+■         ■ ■ ■   ■ ■     ■   ■         ■                       ■     ■ ■       ■       ■   ■     ■ 
+■■■ ■ ■■■■■■■■■ ■ ■■■ ■ ■■■■■■■ ■■■ ■■■ ■■■ ■ ■■■■■ ■■■ ■■■■■■■ ■■■■■■■■■ ■ ■ ■■■ ■■■■■■■■■ ■■■ ■■■ 
+■   ■ ■     ■   ■ ■   ■     ■   ■     ■ ■   ■     ■   ■ ■ ■   ■       ■ ■ ■ ■ ■     ■ ■       ■     
+■ ■ ■■■■■ ■■■ ■ ■ ■■■ ■■■ ■■■ ■■■ ■ ■■■ ■■■ ■■■ ■ ■ ■■■ ■ ■ ■■■ ■ ■ ■ ■ ■ ■ ■■■■■■■■■ ■ ■ ■■■■■ ■■■ 
+■ ■ ■ ■ ■     ■ ■ ■     ■   ■   ■ ■   ■   ■   ■ ■ ■   ■       ■ ■ ■ ■ ■ ■ ■             ■ ■ ■     ■ 
+■ ■■■ ■ ■ ■■■ ■ ■ ■ ■■■ ■ ■ ■■■ ■■■ ■ ■ ■■■■■ ■■■ ■ ■ ■ ■■■■■■■■■■■ ■ ■ ■ ■ ■■■ ■ ■■■■■ ■■■ ■ ■ ■ ■ 
+■   ■       ■ ■ ■ ■   ■ ■ ■ ■     ■ ■ ■ ■       ■ ■ ■ ■     ■     ■ ■   ■ ■   ■ ■     ■ ■     ■ ■ ■ 
+■ ■■■ ■■■■■■■■■■■ ■ ■ ■■■ ■ ■■■ ■■■■■ ■■■■■■■ ■■■■■ ■ ■■■■■ ■ ■ ■ ■ ■■■ ■■■■■■■■■■■■■■■■■ ■■■■■ ■■■■
+■   ■       ■     ■ ■   ■ ■ ■     ■ ■ ■         ■   ■     ■   ■ ■ ■   ■ ■   ■   ■             ■     
+■ ■■■ ■■■■■■■ ■ ■■■ ■ ■■■ ■ ■ ■ ■■■ ■■■■■■■■■ ■ ■■■■■■■ ■■■■■■■ ■■■ ■ ■■■■■ ■ ■■■■■ ■■■ ■■■■■ ■ ■■■ 
+■   ■   ■     ■ ■   ■   ■ ■ ■ ■         ■     ■     ■ ■ ■ ■   ■   ■ ■                 ■     ■ ■   ■ 
+■ ■■■■■■■■■ ■■■ ■ ■ ■■■■■ ■ ■■■ ■■■■■■■ ■ ■■■■■ ■■■■■ ■ ■ ■ ■■■■■■■■■■■ ■ ■■■■■ ■■■■■ ■■■■■ ■■■ ■■■ 
+■   ■       ■   ■ ■     ■ ■ ■         ■ ■     ■   ■       ■           ■ ■ ■   ■     ■ ■   ■   ■   ■ 
+■■■■■ ■ ■■■ ■■■ ■■■■■ ■■■ ■■■ ■ ■■■ ■■■ ■■■ ■ ■ ■■■ ■■■ ■ ■ ■■■■■ ■■■■■■■ ■ ■ ■ ■ ■■■■■ ■■■■■ ■■■■■■
+■     ■ ■   ■     ■ ■ ■     ■ ■   ■   ■ ■   ■ ■   ■   ■ ■       ■ ■     ■   ■ ■ ■       ■ ■         
+■ ■ ■ ■■■■■ ■■■■■ ■ ■■■■■ ■■■ ■ ■■■ ■■■ ■ ■■■ ■ ■ ■■■■■ ■ ■ ■ ■ ■■■ ■ ■ ■■■ ■■■ ■■■■■■■ ■ ■■■■■■■■■ 
+■ ■ ■ ■ ■     ■         ■ ■   ■ ■   ■   ■   ■ ■ ■   ■   ■ ■ ■ ■     ■ ■ ■     ■       ■   ■   ■ ■   
+■ ■■■■■ ■ ■■■ ■ ■ ■■■■■■■■■■■ ■ ■ ■ ■■■ ■ ■■■ ■■■ ■■■ ■ ■ ■■■■■■■ ■ ■■■ ■■■ ■■■■■ ■■■ ■ ■■■ ■■■ ■■■■
+■ ■         ■ ■ ■     ■       ■ ■ ■ ■   ■   ■ ■   ■   ■ ■       ■ ■   ■   ■   ■ ■   ■ ■             
+■ ■■■■■ ■■■■■ ■■■ ■ ■■■■■■■ ■■■ ■ ■ ■■■■■ ■ ■ ■ ■ ■ ■ ■ ■■■ ■ ■ ■ ■ ■ ■ ■■■ ■■■ ■■■■■■■■■ ■ ■ ■■■■■■
+■ ■ ■ ■   ■   ■ ■ ■   ■   ■   ■ ■ ■     ■ ■ ■ ■ ■ ■ ■ ■   ■ ■ ■ ■ ■ ■ ■   ■   ■ ■ ■     ■ ■ ■ ■ ■   
+■■■ ■ ■ ■■■ ■■■ ■ ■ ■ ■■■ ■ ■■■ ■■■ ■ ■ ■ ■ ■■■■■ ■ ■■■ ■■■■■ ■ ■■■■■■■■■■■ ■ ■ ■ ■ ■ ■■■■■■■■■ ■■■ 
+■       ■   ■ ■   ■ ■ ■       ■ ■   ■ ■ ■ ■     ■ ■ ■   ■     ■ ■     ■     ■       ■       ■ ■   ■ 
+■■■■■ ■ ■■■■■ ■ ■ ■■■■■■■ ■ ■■■■■■■■■■■■■■■■■ ■ ■■■ ■ ■ ■ ■■■ ■ ■ ■■■■■ ■■■ ■■■■■■■ ■ ■ ■ ■■■ ■ ■■■ 
+■     ■ ■       ■     ■   ■           ■ ■ ■ ■ ■ ■   ■ ■ ■ ■   ■     ■ ■ ■       ■   ■ ■ ■ ■       ■ 
+■ ■ ■ ■■■ ■ ■■■ ■ ■ ■■■■■ ■■■■■■■ ■ ■■■ ■ ■ ■■■ ■■■ ■■■ ■ ■ ■ ■■■ ■■■ ■■■■■ ■ ■■■■■■■■■■■■■■■ ■■■■■ 
+■ ■ ■ ■   ■ ■   ■ ■ ■           ■ ■ ■     ■   ■ ■     ■ ■ ■ ■   ■ ■ ■     ■ ■     ■       ■         
+■■■ ■ ■■■ ■■■ ■ ■ ■■■ ■■■ ■ ■ ■■■ ■■■ ■■■ ■ ■■■■■■■ ■■■■■ ■ ■■■■■ ■ ■ ■■■ ■ ■■■ ■ ■■■ ■■■■■ ■■■■■ ■■
+■   ■ ■ ■ ■   ■ ■   ■   ■ ■ ■ ■     ■ ■ ■     ■       ■ ■ ■   ■     ■   ■     ■ ■               ■ ■ 
+■■■ ■■■ ■■■■■■■ ■ ■ ■■■ ■■■ ■ ■ ■ ■ ■ ■ ■ ■ ■■■■■■■ ■■■ ■ ■ ■ ■ ■ ■■■ ■ ■ ■ ■■■■■ ■ ■ ■■■ ■■■ ■ ■■■ 
+■   ■           ■ ■   ■ ■   ■ ■ ■ ■     ■ ■   ■ ■   ■     ■ ■ ■ ■   ■ ■ ■ ■   ■   ■ ■   ■ ■ ■ ■     
+■■■ ■■■■■ ■■■■■ ■■■■■ ■ ■■■ ■■■ ■ ■ ■■■■■ ■ ■■■ ■■■ ■■■■■■■ ■■■ ■ ■■■ ■ ■ ■ ■ ■■■ ■■■■■ ■ ■ ■ ■ ■ ■ 
+■     ■   ■     ■ ■   ■ ■ ■ ■   ■ ■     ■ ■     ■ ■ ■         ■ ■   ■ ■ ■ ■ ■   ■     ■ ■   ■ ■ ■ ■ 
+■ ■ ■ ■■■ ■■■■■ ■ ■■■ ■■■ ■ ■■■ ■ ■ ■■■■■■■■■ ■ ■ ■■■■■ ■ ■ ■ ■■■ ■■■■■■■■■ ■ ■ ■ ■■■ ■ ■■■ ■■■■■■■ 
+■ ■ ■ ■ ■ ■     ■         ■   ■ ■ ■         ■ ■   ■ ■   ■ ■ ■   ■     ■     ■ ■ ■   ■ ■   ■     ■   
+■ ■ ■■■ ■■■ ■ ■■■ ■■■ ■ ■■■ ■ ■ ■ ■ ■■■■■ ■■■ ■■■■■ ■ ■ ■ ■ ■ ■ ■ ■■■ ■ ■ ■ ■■■ ■ ■ ■■■ ■■■■■ ■■■■■ 
+■ ■ ■ ■     ■   ■   ■ ■   ■ ■ ■ ■ ■     ■ ■         ■ ■ ■ ■ ■ ■ ■   ■ ■ ■ ■ ■   ■ ■   ■     ■ ■ ■ ■ 
+■■■■■ ■ ■ ■■■ ■■■ ■ ■■■■■■■■■ ■■■ ■ ■■■■■■■■■ ■■■■■ ■ ■■■ ■ ■■■ ■ ■■■■■ ■■■■■ ■ ■ ■■■■■ ■ ■■■ ■ ■ ■ 
+■   ■   ■ ■   ■   ■       ■     ■ ■       ■   ■ ■   ■   ■ ■   ■ ■   ■       ■ ■ ■   ■ ■ ■ ■   ■   ■ 
+■■■ ■■■■■■■ ■ ■ ■■■ ■ ■ ■ ■■■ ■ ■■■ ■■■■■■■ ■ ■ ■■■ ■ ■ ■ ■■■■■ ■ ■■■■■ ■■■■■■■ ■■■■■ ■■■■■■■ ■ ■■■ 
+■ ■ ■       ■ ■   ■ ■ ■ ■   ■ ■   ■       ■ ■   ■   ■ ■ ■   ■   ■ ■         ■             ■       ■ 
+■ ■ ■ ■ ■■■ ■■■ ■■■ ■■■■■■■■■ ■■■■■ ■■■ ■■■■■ ■ ■■■ ■ ■ ■ ■■■ ■■■ ■ ■■■■■■■ ■■■ ■■■■■ ■■■■■■■ ■ ■■■ 
+■ ■   ■ ■     ■   ■ ■   ■     ■       ■   ■   ■   ■ ■ ■ ■   ■   ■ ■ ■ ■ ■     ■ ■ ■       ■ ■ ■ ■   
+■ ■ ■■■ ■ ■ ■ ■ ■■■ ■ ■■■■■ ■ ■ ■ ■ ■■■■■■■ ■ ■■■■■■■ ■■■■■■■ ■ ■ ■ ■ ■ ■■■ ■ ■ ■ ■■■■■ ■■■ ■ ■ ■ ■■
+■     ■ ■ ■ ■ ■ ■     ■ ■   ■ ■ ■ ■       ■ ■       ■     ■ ■ ■ ■ ■     ■   ■ ■       ■ ■     ■ ■   
+■ ■■■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■■■ ■■■ ■ ■ ■ ■■■■■ ■■■ ■ ■ ■ ■ ■ ■ ■ ■ ■■■ ■■■ ■■■■■ ■ ■■■■■■■ ■■■ ■ ■■■ ■ 
+■   ■ ■ ■ ■ ■ ■ ■ ■ ■   ■   ■ ■ ■ ■ ■   ■     ■ ■ ■ ■ ■ ■   ■ ■ ■     ■   ■ ■ ■   ■ ■     ■ ■   ■ ■ 
+■ ■■■■■ ■■■ ■■■ ■■■ ■■■■■ ■ ■ ■ ■■■■■ ■■■ ■■■■■ ■ ■■■■■ ■■■■■■■ ■■■ ■■■■■■■ ■ ■ ■■■ ■■■ ■■■ ■■■■■■■■
+■ ■       ■   ■   ■     ■ ■ ■     ■   ■       ■ ■ ■       ■   ■ ■         ■   ■       ■ ■     ■   ■ 
+■ ■■■ ■■■ ■ ■■■ ■■■ ■ ■■■ ■ ■■■ ■■■■■ ■■■■■ ■■■■■ ■■■■■ ■■■ ■■■ ■■■ ■■■■■ ■ ■ ■■■ ■ ■ ■ ■■■■■ ■ ■■E 
+■ ■   ■   ■ ■   ■   ■   ■ ■   ■ ■         ■     ■ ■         ■   ■       ■ ■ ■ ■   ■ ■ ■   ■         
diff --git a/groshevava/docs/data/main.py b/groshevava/docs/data/main.py
new file mode 100644
index 0000000..303c32c
--- /dev/null
+++ b/groshevava/docs/data/main.py
@@ -0,0 +1,201 @@
+from builders import TextFileMazeBuilder
+from strategies import BFSStrategy, DFSStrategy, AStarStrategy
+from solver import MazeSolver
+from observers import ConsoleView
+from experiments import run_experiments, save_to_csv
+import random
+
+WALL = '■'
+PASSAGE = ' '
+START = 'S'
+EXIT = 'E'
+
+
+def generate_maze_prim(size: int, filename: str, label: str):
+    random.seed(hash(filename) % 10000)
+    
+    grid = [[WALL for _ in range(size)] for _ in range(size)]
+    
+    start_x, start_y = 1, 1
+    grid[start_y][start_x] = PASSAGE
+    
+    walls = []
+    
+    for dx, dy in [(0, -1), (0, 1), (-1, 0), (1, 0)]:
+        wall_x = start_x + dx
+        wall_y = start_y + dy
+        cell_x = start_x + 2*dx
+        cell_y = start_y + 2*dy
+        
+        if 0 <= cell_x < size and 0 <= cell_y < size:
+            if grid[wall_y][wall_x] == WALL:
+                walls.append((wall_x, wall_y, start_x, start_y, cell_x, cell_y))
+    
+    while walls:
+        idx = random.randint(0, len(walls) - 1)
+        wall_x, wall_y, from_x, from_y, to_x, to_y = walls.pop(idx)
+        
+        if grid[to_y][to_x] == WALL:
+            grid[wall_y][wall_x] = PASSAGE
+            grid[to_y][to_x] = PASSAGE
+            
+            for dx, dy in [(0, -1), (0, 1), (-1, 0), (1, 0)]:
+                new_wall_x = to_x + dx
+                new_wall_y = to_y + dy
+                new_cell_x = to_x + 2*dx
+                new_cell_y = to_y + 2*dy
+                
+                if 0 <= new_cell_x < size and 0 <= new_cell_y < size:
+                    if grid[new_wall_y][new_wall_x] == WALL:
+                        walls.append((new_wall_x, new_wall_y, to_x, to_y, new_cell_x, new_cell_y))
+    
+    grid[1][1] = START
+    grid[size-2][size-2] = EXIT
+    
+    with open(filename, 'w', encoding='utf-8') as f:
+        for row in grid:
+            f.write(''.join(row) + '\n')
+    
+    print(f"✓ {label}: {filename}")
+
+
+def generate_small_maze(filename='small_maze.txt'):
+    maze = [
+        "■■■■■■■■■■",
+        "■S       ■",
+        "■ ■■■■ ■ ■",
+        "■ ■  ■ ■ ■",
+        "■ ■ ■■ ■ ■",
+        "■ ■    ■ ■",
+        "■ ■■■■■■ ■",
+        "■        ■",
+        "■ ■■■■■■■■",
+        "■       E■",
+        "■■■■■■■■■■"
+    ]
+    
+    with open(filename, 'w', encoding='utf-8') as f:
+        f.write('\n'.join(maze))
+    print(f"Маленький лабиринт 10x10: {filename}")
+
+
+def generate_no_exit_maze(filename='no_exit_maze.txt'):
+    maze = [
+        "■■■■■■■■■■",
+        "■S       ■",
+        "■ ■■■■ ■ ■",
+        "■ ■  ■ ■ ■",
+        "■ ■ ■■ ■ ■",
+        "■ ■    ■ ■",
+        "■ ■■■■■■ ■",
+        "■        ■",
+        "■ ■■■■■■■■",
+        "■   ■■■■■■",
+        "■■■■■E■■■■"
+    ]
+    
+    with open(filename, 'w', encoding='utf-8') as f:
+        f.write('\n'.join(maze))
+    print(f"Лабиринт без выхода 10x10: {filename}")
+
+
+def generate_empty_maze(filename='empty_maze.txt'):
+    size = 10
+    maze = []
+    maze.append(WALL * size)
+    
+    for i in range(size - 2):
+        if i == 0:
+            row = WALL + START + PASSAGE * (size - 3) + WALL
+        elif i == size - 3:
+            row = WALL + PASSAGE * (size - 3) + EXIT + WALL
+        else:
+            row = WALL + PASSAGE * (size - 2) + WALL
+        maze.append(row)
+    
+    maze.append(WALL * size)
+    
+    with open(filename, 'w', encoding='utf-8') as f:
+        f.write('\n'.join(maze))
+    print(f"Пустой лабиринт 10x10: {filename}")
+
+
+def main():
+    print("=" * 60)
+    print("ГЕНЕРАЦИЯ ЛАБИРИНТОВ")
+    print("=" * 60)
+    
+    generate_small_maze('small_maze.txt')
+    generate_maze_prim(50, 'medium_maze.txt', 'Средний лабиринт 50x50')
+    generate_maze_prim(100, 'large_maze.txt', 'Большой лабиринт 100x100')
+    generate_no_exit_maze('no_exit_maze.txt')
+    generate_empty_maze('empty_maze.txt')
+    
+    print("\n" + "=" * 60)
+    print("ДЕМОНСТРАЦИЯ НА МАЛЕНЬКОМ ЛАБИРИНТЕ")
+    print("=" * 60)
+    
+    builder = TextFileMazeBuilder()
+    maze = builder.buildFromFile('small_maze.txt')
+    
+    print(f"Размер: {maze.width}x{maze.height}")
+    print(f"Старт: ({maze.start.x}, {maze.start.y})")
+    print(f"Выход: ({maze.exit.x}, {maze.exit.y})")
+    
+    view = ConsoleView()
+    solver = MazeSolver(maze)
+    solver.attach(view)
+    
+    strategies = {
+        "BFS (поиск в ширину)": BFSStrategy(),
+        "DFS (поиск в глубину)": DFSStrategy(),
+        "A*": AStarStrategy()
+    }
+    
+    for name, strat in strategies.items():
+        print(f"\n{'─' * 40}")
+        print(f"Стратегия: {name}")
+        
+        solver.setStrategy(strat)
+        path, stats = solver.solve()
+        
+        if path:
+            print(f"Путь найден! Длина: {len(path)} шагов")
+            print(f"  Время: {stats.time_ms:.3f} мс | Посещено: {stats.visited_count}")
+            view.render(maze, path=path)
+        else:
+            print("Путь не найден!")
+    
+    # Эксперименты
+    print("\n" + "=" * 60)
+    print("ЭКСПЕРИМЕНТЫ НА ВСЕХ ЛАБИРИНТАХ")
+    print("=" * 60)
+    
+    test_mazes = {}
+    maze_files = [
+        ("Маленький (10x10)", "small_maze.txt"),
+        ("Средний (50x50)", "medium_maze.txt"),
+        ("Большой (100x100)", "large_maze.txt"),
+        ("Без выхода (10x10)", "no_exit_maze.txt"),
+        ("Пустой (10x10)", "empty_maze.txt")
+    ]
+    
+    for name, filename in maze_files:
+        try:
+            test_mazes[name] = builder.buildFromFile(filename)
+            m = test_mazes[name]
+            print(f"{name} загружен ({m.width}x{m.height})")
+        except Exception as e:
+            print(f"Ошибка {name}: {e}")
+    
+    if test_mazes:
+        print(f"\nЗапуск тестов (по 3 прогона)...")
+        results = run_experiments(test_mazes, strategies, runs=3)
+        save_to_csv(results)
+        
+        print("ГОТОВО! Графики: python visualize_results.py")
+
+
+
+if __name__ == "__main__":
+    main()
diff --git a/groshevava/docs/data/maze_experiment_results.csv b/groshevava/docs/data/maze_experiment_results.csv
new file mode 100644
index 0000000..3fae22f
--- /dev/null
+++ b/groshevava/docs/data/maze_experiment_results.csv
@@ -0,0 +1,16 @@
+maze,strategy,time_ms,visited,path_length
+Маленький (10x10),BFS (поиск в ширину),0.1492,44.0,16.0
+Маленький (10x10),DFS (поиск в глубину),0.095,30.0,30.0
+Маленький (10x10),A* (A-star),0.1717,39.0,16.0
+Средний (50x50),BFS (поиск в ширину),3.6384,1243.0,97.0
+Средний (50x50),DFS (поиск в глубину),1.9872,614.0,97.0
+Средний (50x50),A* (A-star),2.048,444.0,97.0
+Большой (100x100),BFS (поиск в ширину),16.6951,4997.0,213.0
+Большой (100x100),DFS (поиск в глубину),10.7515,3610.0,213.0
+Большой (100x100),A* (A-star),13.2112,2836.0,213.0
+Без выхода (10x10),BFS (поиск в ширину),0,0,0
+Без выхода (10x10),DFS (поиск в глубину),0,0,0
+Без выхода (10x10),A* (A-star),0,0,0
+Пустой (10x10),BFS (поиск в ширину),0.1921,64.0,15.0
+Пустой (10x10),DFS (поиск в глубину),0.1362,43.0,29.0
+Пустой (10x10),A* (A-star),0.2633,64.0,15.0
diff --git a/groshevava/docs/data/medium_maze.txt b/groshevava/docs/data/medium_maze.txt
new file mode 100644
index 0000000..95de1ec
--- /dev/null
+++ b/groshevava/docs/data/medium_maze.txt
@@ -0,0 +1,50 @@
+■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
+■S■ ■   ■       ■ ■ ■ ■ ■ ■ ■     ■           ■   
+■ ■ ■ ■■■■■ ■ ■ ■ ■ ■ ■ ■ ■ ■■■ ■■■ ■■■■■■■■■■■ ■■
+■     ■ ■   ■ ■ ■       ■             ■           
+■ ■■■■■ ■■■ ■■■■■ ■■■ ■■■■■ ■■■ ■ ■■■■■ ■■■■■■■■■■
+■ ■   ■           ■ ■ ■ ■ ■   ■ ■ ■ ■ ■         ■ 
+■ ■ ■■■ ■■■■■ ■■■ ■ ■■■ ■ ■ ■■■■■ ■ ■ ■ ■■■ ■■■ ■ 
+■     ■     ■ ■           ■   ■ ■       ■ ■   ■   
+■ ■■■■■ ■■■■■■■ ■ ■■■ ■■■ ■ ■■■ ■■■ ■ ■■■ ■■■■■■■ 
+■             ■ ■ ■   ■           ■ ■       ■   ■ 
+■■■ ■■■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■■■ ■■■■■ ■■■ ■■■ ■■
+■   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■     ■   ■       
+■ ■ ■ ■ ■■■■■ ■ ■■■■■■■ ■ ■ ■ ■ ■ ■ ■■■ ■■■ ■■■■■■
+■ ■   ■ ■ ■   ■ ■       ■ ■ ■   ■ ■   ■   ■       
+■ ■ ■ ■■■ ■■■■■■■ ■ ■■■ ■ ■ ■ ■ ■ ■■■ ■■■■■ ■■■■■ 
+■ ■ ■     ■ ■   ■ ■   ■ ■ ■ ■ ■ ■   ■     ■   ■ ■ 
+■ ■■■ ■ ■ ■ ■ ■ ■■■■■■■■■ ■■■ ■ ■■■■■ ■ ■■■■■ ■ ■ 
+■ ■   ■ ■     ■ ■   ■   ■   ■ ■   ■   ■ ■ ■ ■ ■ ■ 
+■ ■■■■■■■ ■■■■■■■ ■■■ ■ ■■■ ■■■■■ ■■■■■ ■ ■ ■■■ ■■
+■     ■             ■ ■ ■ ■ ■   ■   ■ ■     ■     
+■■■ ■ ■■■ ■■■■■ ■■■ ■ ■■■ ■■■ ■■■■■■■ ■■■■■■■ ■ ■ 
+■   ■ ■ ■     ■   ■ ■ ■   ■     ■         ■ ■ ■ ■ 
+■■■■■ ■ ■■■ ■■■■■■■■■ ■■■ ■ ■■■ ■ ■■■■■■■ ■ ■ ■■■■
+■       ■     ■ ■ ■ ■         ■   ■ ■ ■ ■         
+■■■ ■■■■■ ■ ■■■ ■ ■ ■ ■■■■■■■■■■■■■ ■ ■ ■ ■■■■■ ■■
+■       ■ ■             ■ ■ ■           ■     ■   
+■ ■ ■■■ ■■■ ■ ■■■■■ ■ ■ ■ ■ ■ ■■■■■ ■■■ ■■■ ■■■ ■■
+■ ■ ■ ■ ■   ■ ■   ■ ■ ■           ■   ■   ■ ■     
+■ ■ ■ ■■■ ■ ■ ■ ■■■ ■ ■■■ ■■■■■ ■■■■■ ■■■ ■ ■ ■ ■■
+■ ■ ■     ■ ■     ■ ■ ■       ■   ■     ■ ■ ■ ■   
+■ ■ ■ ■■■ ■ ■ ■ ■■■■■ ■■■ ■ ■ ■ ■■■■■ ■■■■■ ■■■■■ 
+■ ■ ■ ■ ■ ■ ■ ■     ■ ■   ■ ■ ■   ■ ■ ■   ■     ■ 
+■ ■■■ ■ ■■■■■■■ ■ ■ ■ ■■■■■ ■ ■■■ ■ ■■■ ■■■ ■ ■■■■
+■   ■       ■   ■ ■ ■   ■   ■   ■   ■ ■   ■ ■ ■   
+■■■ ■ ■ ■ ■ ■■■■■ ■■■ ■ ■ ■■■ ■ ■ ■ ■ ■ ■■■■■ ■ ■■
+■   ■ ■ ■ ■     ■ ■ ■ ■ ■   ■ ■ ■ ■     ■ ■ ■ ■ ■ 
+■ ■■■ ■■■ ■ ■■■ ■ ■ ■■■■■ ■■■ ■ ■ ■■■■■ ■ ■ ■■■ ■ 
+■ ■     ■ ■ ■   ■     ■ ■ ■   ■ ■   ■             
+■■■■■ ■■■■■ ■■■ ■ ■ ■■■ ■■■■■ ■■■■■ ■ ■■■ ■■■■■ ■■
+■       ■     ■ ■ ■       ■       ■ ■   ■   ■ ■   
+■■■■■ ■ ■■■■■■■ ■ ■■■ ■ ■ ■■■■■■■■■ ■■■■■ ■■■ ■■■ 
+■     ■ ■       ■   ■ ■ ■         ■     ■     ■   
+■■■■■ ■■■■■ ■■■ ■ ■■■■■ ■■■■■ ■■■■■ ■ ■ ■■■ ■■■ ■ 
+■         ■ ■   ■     ■     ■     ■ ■ ■   ■   ■ ■ 
+■■■■■ ■ ■■■ ■ ■ ■ ■ ■ ■ ■■■■■ ■■■ ■■■ ■ ■■■■■■■ ■ 
+■     ■   ■ ■ ■ ■ ■ ■ ■   ■     ■   ■ ■   ■ ■ ■ ■ 
+■■■ ■■■ ■ ■■■■■■■ ■ ■■■■■■■■■ ■■■ ■■■■■ ■ ■ ■ ■■■ 
+■     ■ ■     ■   ■     ■       ■ ■ ■ ■ ■   ■     
+■■■ ■■■ ■ ■■■■■■■ ■ ■ ■■■ ■ ■■■ ■■■ ■ ■■■■■ ■■■ E 
+■     ■ ■   ■     ■ ■ ■   ■   ■           ■   ■ ■ 
diff --git a/groshevava/docs/data/models.py b/groshevava/docs/data/models.py
new file mode 100644
index 0000000..0ddb4ff
--- /dev/null
+++ b/groshevava/docs/data/models.py
@@ -0,0 +1,46 @@
+# maze_solver/models.py
+from typing import Optional, List
+
+
+class Cell:
+    """Представляет одну клетку лабиринта."""
+    def __init__(self, x: int, y: int, is_wall: bool = False):
+        self.x = x
+        self.y = y
+        self.isWall = is_wall
+        self.isStart = False
+        self.isExit = False
+
+    def isPassable(self) -> bool:
+        """Можно ли пройти через клетку."""
+        return not self.isWall
+
+    def __repr__(self):
+        return f"Cell({self.x}, {self.y}, Wall={self.isWall})"
+
+
+class Maze:
+    """Хранит полную карту лабиринта."""
+    def __init__(self, width: int, height: int, grid: Optional[List[List[Cell]]] = None):
+        self.width = width
+        self.height = height
+        self.grid = grid if grid else []
+        self.start: Optional[Cell] = None
+        self.exit: Optional[Cell] = None
+
+    def getCell(self, x: int, y: int) -> Optional[Cell]:
+        """Безопасное получение клетки по координатам."""
+        if 0 <= x < self.width and 0 <= y < self.height:
+            return self.grid[y][x]
+        return None
+
+    def getNeighbors(self, cell: Cell) -> List[Cell]:
+        """Возвращает список соседних ПРОХОДИМЫХ клеток."""
+        neighbors = []
+        directions = [(0, -1), (0, 1), (-1, 0), (1, 0)]  # up, down, left, right
+        for dx, dy in directions:
+            nx, ny = cell.x + dx, cell.y + dy
+            neighbor = self.getCell(nx, ny)
+            if neighbor and neighbor.isPassable():
+                neighbors.append(neighbor)
+        return neighbors
\ No newline at end of file
diff --git a/groshevava/docs/data/no_exit_maze.txt b/groshevava/docs/data/no_exit_maze.txt
new file mode 100644
index 0000000..31658c0
--- /dev/null
+++ b/groshevava/docs/data/no_exit_maze.txt
@@ -0,0 +1,11 @@
+■■■■■■■■■■
+■S       ■
+■ ■■■■ ■ ■
+■ ■  ■ ■ ■
+■ ■ ■■ ■ ■
+■ ■    ■ ■
+■ ■■■■■■ ■
+■        ■
+■ ■■■■■■■■
+■   ■■■■■■
+■■■■■E■■■■
\ No newline at end of file
diff --git a/groshevava/docs/data/observers.py b/groshevava/docs/data/observers.py
new file mode 100644
index 0000000..effd9a3
--- /dev/null
+++ b/groshevava/docs/data/observers.py
@@ -0,0 +1,60 @@
+import os
+from abc import ABC, abstractmethod
+from typing import Optional, List
+from models import Maze, Cell
+
+
+class Observer(ABC):
+    @abstractmethod
+    def update(self, event: str, data=None):
+        pass
+
+
+class ConsoleView(Observer):
+    WALL_CHAR = '■'
+    START_CHAR = 'S'
+    EXIT_CHAR = 'E'
+    PATH_CHAR = '•'  
+    PLAYER_CHAR = 'P'
+    PASSAGE_CHAR = ' '
+
+    def update(self, event: str, data=None):
+        if event == "search_started":
+            print(f"\n Запущен поиск с помощью: {data['strategy']}")
+        elif event == "path_found":
+            stats = data['stats']
+            print(f" Путь найден! {stats}")
+        elif event == "path_not_found":
+            stats = data['stats']
+            print(f" Путь НЕ найден. {stats}")
+        elif event == "step":
+            self.render(data['maze'], data['current'], data.get('path'))
+
+    @staticmethod
+    def render(maze: Maze, player_pos: Optional[Cell] = None, path: Optional[List[Cell]] = None):
+        os.system('cls' if os.name == 'nt' else 'clear')
+        path_set = set(path) if path else set()
+
+        print("┌" + "─" * maze.width + "┐")
+        
+        for y in range(maze.height):
+            row_str = "│"
+            for x in range(maze.width):
+                cell = maze.getCell(x, y)
+                
+                if player_pos and cell == player_pos:
+                    row_str += ConsoleView.PLAYER_CHAR
+                elif cell.isStart:
+                    row_str += ConsoleView.START_CHAR
+                elif cell.isExit:
+                    row_str += ConsoleView.EXIT_CHAR
+                elif cell in path_set:
+                    row_str += ConsoleView.PATH_CHAR
+                elif cell.isWall:
+                    row_str += ConsoleView.WALL_CHAR
+                else:
+                    row_str += ConsoleView.PASSAGE_CHAR
+            row_str += "│"
+            print(row_str)
+        
+        print("└" + "─" * maze.width + "┘")
\ No newline at end of file
diff --git a/groshevava/docs/data/small_maze.txt b/groshevava/docs/data/small_maze.txt
new file mode 100644
index 0000000..5d0835f
--- /dev/null
+++ b/groshevava/docs/data/small_maze.txt
@@ -0,0 +1,11 @@
+■■■■■■■■■■
+■S       ■
+■ ■■■■ ■ ■
+■ ■  ■ ■ ■
+■ ■ ■■ ■ ■
+■ ■    ■ ■
+■ ■■■■■■ ■
+■        ■
+■ ■■■■■■■■
+■       E■
+■■■■■■■■■■
\ No newline at end of file
diff --git a/groshevava/docs/data/solver.py b/groshevava/docs/data/solver.py
new file mode 100644
index 0000000..90b7903
--- /dev/null
+++ b/groshevava/docs/data/solver.py
@@ -0,0 +1,61 @@
+import time
+from typing import List, Tuple, Optional
+from models import Maze, Cell
+from strategies import PathFindingStrategy
+
+
+class SearchStats:
+    def __init__(self, time_ms: float, visited: int, path_length: int):
+        self.time_ms = time_ms
+        self.visited_count = visited
+        self.path_length = path_length
+
+    def __str__(self):
+        return (f"Время: {self.time_ms:.4f} мс | "
+                f"Посещено: {self.visited_count} | "
+                f"Длина пути: {self.path_length}")
+
+
+class MazeSolver:
+    def __init__(self, maze: Maze, strategy: Optional[PathFindingStrategy] = None):
+        self.maze = maze
+        self.strategy = strategy
+        self._observers = []
+
+    def setStrategy(self, strategy: PathFindingStrategy):
+        self.strategy = strategy
+
+    def attach(self, observer):
+        self._observers.append(observer)
+
+    def detach(self, observer):
+        self._observers.remove(observer)
+
+    def _notify(self, event: str, data=None):
+        for observer in self._observers:
+            observer.update(event, data)
+
+    def solve(self) -> Tuple[List[Cell], SearchStats]:
+        if not self.strategy:
+            raise ValueError("Стратегия поиска не установлена.")
+        if not self.maze.start or not self.maze.exit:
+            raise ValueError("В лабиринте не определены старт или выход.")
+
+        self._notify("search_started", {"strategy": type(self.strategy).__name__})
+
+        start_time = time.perf_counter()
+        path = self.strategy.findPath(self.maze, self.maze.start, self.maze.exit)
+        end_time = time.perf_counter()
+
+        elapsed_ms = (end_time - start_time) * 1000
+        visited = self.strategy.visited_count
+        path_len = len(path)
+
+        stats = SearchStats(elapsed_ms, visited, path_len)
+
+        if path:
+            self._notify("path_found", {"path": path, "stats": stats})
+        else:
+            self._notify("path_not_found", {"stats": stats})
+
+        return path, stats
\ No newline at end of file
diff --git a/groshevava/docs/data/strategies.py b/groshevava/docs/data/strategies.py
new file mode 100644
index 0000000..4120d27
--- /dev/null
+++ b/groshevava/docs/data/strategies.py
@@ -0,0 +1,104 @@
+from abc import ABC, abstractmethod
+from collections import deque
+import heapq
+from typing import List, Dict, Optional
+from models import Cell, Maze
+
+
+class PathFindingStrategy(ABC):
+    def __init__(self):
+        self.visited_count = 0
+
+    @abstractmethod
+    def findPath(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
+        pass
+
+    def _reconstruct_path(self, parent: Dict[Cell, Optional[Cell]], current: Cell) -> List[Cell]:
+        path = []
+        while current:
+            path.append(current)
+            current = parent.get(current)
+        return path[::-1]  
+
+
+class BFSStrategy(PathFindingStrategy):
+    def findPath(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
+        self.visited_count = 0
+        queue = deque([start])
+        visited = {start}
+        parent = {start: None}
+
+        while queue:
+            current = queue.popleft()
+            self.visited_count += 1
+
+            if current == exit:
+                return self._reconstruct_path(parent, current)
+
+            for neighbor in maze.getNeighbors(current):
+                if neighbor not in visited:
+                    visited.add(neighbor)
+                    parent[neighbor] = current
+                    queue.append(neighbor)
+        return [] 
+
+
+class DFSStrategy(PathFindingStrategy):
+    def findPath(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
+        self.visited_count = 0
+        stack = [start]
+        visited = {start}
+        parent = {start: None}
+
+        while stack:
+            current = stack.pop()
+            self.visited_count += 1
+
+            if current == exit:
+                return self._reconstruct_path(parent, current)
+
+            for neighbor in maze.getNeighbors(current):
+                if neighbor not in visited:
+                    visited.add(neighbor)
+                    parent[neighbor] = current
+                    stack.append(neighbor)
+        return []
+
+
+class AStarStrategy(PathFindingStrategy):
+
+    @staticmethod
+    def _heuristic(a: Cell, b: Cell) -> int:
+        return abs(a.x - b.x) + abs(a.y - b.y)
+
+    def findPath(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
+        self.visited_count = 0
+        counter = 0
+        open_set = []
+        heapq.heappush(open_set, (0, counter, start))
+        counter += 1
+
+        came_from = {start: None}
+        g_score = {start: 0}
+        visited = set()
+
+        while open_set:
+            _, _, current = heapq.heappop(open_set)
+            self.visited_count += 1
+
+            if current == exit:
+                return self._reconstruct_path(came_from, current)
+
+            if current in visited:
+                continue
+            visited.add(current)
+
+            for neighbor in maze.getNeighbors(current):
+                tentative_g_score = g_score[current] + 1
+                if neighbor not in g_score or tentative_g_score < g_score[neighbor]:
+                    came_from[neighbor] = current
+                    g_score[neighbor] = tentative_g_score
+                    f_score = tentative_g_score + self._heuristic(neighbor, exit)
+                    heapq.heappush(open_set, (f_score, counter, neighbor))
+                    counter += 1
+        return []
\ No newline at end of file
diff --git a/groshevava/docs/data/unreachable_maze.txt b/groshevava/docs/data/unreachable_maze.txt
new file mode 100644
index 0000000..bc0c7ce
--- /dev/null
+++ b/groshevava/docs/data/unreachable_maze.txt
@@ -0,0 +1,11 @@
+##########
+#S       #
+# #####  #
+# #   #  #
+# # # # ##
+#   # #  #
+##### # ##
+#     #  #
+# #####  #
+#   ######
+#####E####
\ No newline at end of file
diff --git a/groshevava/docs/data/visualize_results.py b/groshevava/docs/data/visualize_results.py
new file mode 100644
index 0000000..1cca2df
--- /dev/null
+++ b/groshevava/docs/data/visualize_results.py
@@ -0,0 +1,163 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import csv
+from typing import Dict, List
+import os
+
+plt.style.use('seaborn-v0_8-darkgrid')
+
+def load_results(filename: str = 'maze_experiment_results.csv') -> List[Dict]:
+    if not os.path.exists(filename):
+        print(f"Файл {filename} не найден! Сначала запустите main.py")
+        return []
+    
+    with open(filename, 'r', encoding='utf-8') as f:
+        reader = csv.DictReader(f)
+        results = []
+        for row in reader:
+            row['time_ms'] = float(row['time_ms'])
+            row['visited'] = int(float(row['visited']))
+            row['path_length'] = int(float(row['path_length']))
+            results.append(row)
+    return results
+
+def organize_data(results: List[Dict]) -> Dict:
+    data = {}
+    for row in results:
+        maze = row['maze']
+        strategy = row['strategy'].split('(')[0].strip()
+        
+        if maze not in data:
+            data[maze] = {}
+        if strategy not in data[maze]:
+            data[maze][strategy] = {'time_ms': [], 'visited': [], 'path_length': []}
+        
+        data[maze][strategy]['time_ms'].append(row['time_ms'])
+        data[maze][strategy]['visited'].append(row['visited'])
+        data[maze][strategy]['path_length'].append(row['path_length'])
+    return data
+
+def create_main_chart(data: Dict, save_dir: str = 'charts'):
+    
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+    
+    maze_names = list(data.keys())
+    strategies = ['BFS', 'DFS', 'A*']
+    colors = {'BFS': '#3498db', 'DFS': '#e74c3c', 'A*': '#2ecc71'}
+    
+    fig, axes = plt.subplots(1, 3, figsize=(16, 6))
+    fig.suptitle('Сравнение алгоритмов поиска пути', fontsize=16, fontweight='bold')
+    
+    x = np.arange(len(maze_names))
+    width = 0.25
+    
+    # График 1: Время
+    for i, strat in enumerate(strategies):
+        values = []
+        for maze in maze_names:
+            if strat in data[maze] and data[maze][strat]['time_ms']:
+                values.append(np.mean(data[maze][strat]['time_ms']))
+            else:
+                values.append(0)
+        
+        bars = axes[0].bar(x + i * width, values, width, label=strat, 
+                          color=colors[strat], edgecolor='black', linewidth=0.5)
+        
+        for bar, val in zip(bars, values):
+            if val > 0:
+                axes[0].text(bar.get_x() + bar.get_width()/2., bar.get_height(),
+                           f'{val:.1f}', ha='center', va='bottom', fontsize=7)
+    
+    axes[0].set_title('Время выполнения (мс)', fontweight='bold')
+    axes[0].set_xticks(x + width)
+    axes[0].set_xticklabels([n.split('(')[0].strip() for n in maze_names], rotation=15, fontsize=8)
+    axes[0].legend(fontsize=8)
+    
+    # График 2: Посещённые клетки
+    for i, strat in enumerate(strategies):
+        values = []
+        for maze in maze_names:
+            if strat in data[maze] and data[maze][strat]['visited']:
+                values.append(np.mean(data[maze][strat]['visited']))
+            else:
+                values.append(0)
+        
+        bars = axes[1].bar(x + i * width, values, width, label=strat,
+                          color=colors[strat], edgecolor='black', linewidth=0.5)
+        
+        for bar, val in zip(bars, values):
+            if val > 0:
+                axes[1].text(bar.get_x() + bar.get_width()/2., bar.get_height(),
+                           f'{int(val)}', ha='center', va='bottom', fontsize=7)
+    
+    axes[1].set_title('Посещённые клетки', fontweight='bold')
+    axes[1].set_xticks(x + width)
+    axes[1].set_xticklabels([n.split('(')[0].strip() for n in maze_names], rotation=15, fontsize=8)
+    
+    # График 3: Длина пути
+    for i, strat in enumerate(strategies):
+        values = []
+        for maze in maze_names:
+            if strat in data[maze] and data[maze][strat]['path_length']:
+                values.append(np.mean(data[maze][strat]['path_length']))
+            else:
+                values.append(0)
+        
+        bars = axes[2].bar(x + i * width, values, width, label=strat,
+                          color=colors[strat], edgecolor='black', linewidth=0.5)
+        
+        for bar, val in zip(bars, values):
+            if val > 0:
+                axes[2].text(bar.get_x() + bar.get_width()/2., bar.get_height(),
+                           f'{int(val)}', ha='center', va='bottom', fontsize=7)
+    
+    axes[2].set_title('Длина пути (шагов)', fontweight='bold')
+    axes[2].set_xticks(x + width)
+    axes[2].set_xticklabels([n.split('(')[0].strip() for n in maze_names], rotation=15, fontsize=8)
+    
+    plt.tight_layout()
+    filepath = os.path.join(save_dir, 'comparison_all_metrics.png')
+    plt.savefig(filepath, dpi=150, bbox_inches='tight')
+    plt.close()
+    print(f" График сохранён: {filepath}")
+
+def print_table(data: Dict):
+    print("\n" + "=" * 80)
+    print("РЕЗУЛЬТАТЫ ТЕСТИРОВАНИЯ")
+    print("=" * 80)
+    
+    for maze_name, strategies in data.items():
+        print(f"\n{maze_name}")
+        print("-" * 60)
+        print(f"{'Алгоритм':<10} {'Время(мс)':<12} {'Посещено':<12} {'Длина пути':<12}")
+        print("-" * 46)
+        
+        for strat in ['BFS', 'DFS', 'A*']:
+            if strat in strategies and strategies[strat]['time_ms']:
+                t = np.mean(strategies[strat]['time_ms'])
+                v = np.mean(strategies[strat]['visited'])
+                p = np.mean(strategies[strat]['path_length'])
+                print(f"{strat:<10} {t:<12.2f} {int(v):<12} {int(p):<12}")
+
+def main():
+    print("=" * 60)
+    print("ВИЗУАЛИЗАЦИЯ РЕЗУЛЬТАТОВ")
+    print("=" * 60)
+    
+    results = load_results('maze_experiment_results.csv')
+    
+    if not results:
+        print("Нет данных. Запустите сначала main.py")
+        return
+    
+    data = organize_data(results)
+    
+    print_table(data)
+    
+    # Один график
+    print("\nСоздание графика...")
+    create_main_chart(data)
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/groshevava/docs/task_2.doc b/groshevava/docs/task_2.doc
new file mode 100644
index 0000000..358605b
Binary files /dev/null and b/groshevava/docs/task_2.doc differ