UNN/2026-rff_mp
19
15
Fork 116
Code Issues Pull Requests 9 Actions Packages Projects Releases Wiki Activity

Merge pull request '[2] laba_2' (#328) from kalinovskiymi/2026-rff_mp:kalinovskiymi-laba-2 into develop

Browse Source 
Reviewed-on: #328
This commit is contained in:
git_admin 2026-05-30 11:30:12 +00:00
commit 414db1c72f
10 changed files with 905 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
kalinovskiymi/docs_2/data_2/comparative_results.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 62 KiB

BIN
kalinovskiymi/docs_2/data_2/mazes_visualization.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 96 KiB

16
kalinovskiymi/docs_2/data_2/results.csv Normal file
View File

@ -0,0 +1,16 @@
Лабиринт,Стратегия,Время_мс,Посещено,Длина_пути
Маленький (10x10),BFS,0.13895999999995468,53.0,15.0
Маленький (10x10),DFS,0.0922400000000323,35.0,31.0
Маленький (10x10),A*,0.13939999999998953,39.0,15.0
Средний (50x50),BFS,3.832719999999945,1541.0,97.0
Средний (50x50),DFS,1.7197200000000024,670.0,239.0
Средний (50x50),A*,2.9094199999999404,771.0,97.0
Большой (100x100),BFS,22.754760000000072,8142.0,195.0
Большой (100x100),DFS,12.294599999999935,4075.0,2415.0
Большой (100x100),A*,29.995820000000027,6149.0,195.0
Пустой (50x50),BFS,7.503980000000032,2500.0,99.0
Пустой (50x50),DFS,4.27746,1275.0,1275.0
Пустой (50x50),A*,11.404779999999981,2500.0,99.0
Без выхода (50x50),BFS,4.929480000000064,1570.0,0.0
Без выхода (50x50),DFS,5.824799999999985,1570.0,0.0
Без выхода (50x50),A*,8.014639999999984,1570.0,0.0
1 Лабиринт Стратегия Время_мс Посещено Длина_пути
2 Маленький (10x10) BFS 0.13895999999995468 53.0 15.0
3 Маленький (10x10) DFS 0.0922400000000323 35.0 31.0
4 Маленький (10x10) A* 0.13939999999998953 39.0 15.0
5 Средний (50x50) BFS 3.832719999999945 1541.0 97.0
6 Средний (50x50) DFS 1.7197200000000024 670.0 239.0
7 Средний (50x50) A* 2.9094199999999404 771.0 97.0
8 Большой (100x100) BFS 22.754760000000072 8142.0 195.0
9 Большой (100x100) DFS 12.294599999999935 4075.0 2415.0
10 Большой (100x100) A* 29.995820000000027 6149.0 195.0
11 Пустой (50x50) BFS 7.503980000000032 2500.0 99.0
12 Пустой (50x50) DFS 4.27746 1275.0 1275.0
13 Пустой (50x50) A* 11.404779999999981 2500.0 99.0
14 Без выхода (50x50) BFS 4.929480000000064 1570.0 0.0
15 Без выхода (50x50) DFS 5.824799999999985 1570.0 0.0
16 Без выхода (50x50) A* 8.014639999999984 1570.0 0.0

483
kalinovskiymi/docs_2/data_2/task_2_2.py Normal file
View File

@ -0,0 +1,483 @@
import heapq
import time
import os
import csv
from collections import deque
from abc import ABC, abstractmethod
import matplotlib.pyplot as plt
import numpy as np
class Cell:
def __init__(self, x, y, is_wall=False):
self.x = x
self.y = y
self.is_wall = is_wall
self.is_start = False
self.is_exit = False
def is_passable(self):
return not self.is_wall
class Maze:
def __init__(self, width, height):
self.width = width
self.height = height
self.grid = [[Cell(x, y, True) for y in range(height)] for x in range(width)]
self.start = None
self.exit = None
def get_cell(self, x, y):
if 0 <= x < self.width and 0 <= y < self.height:
return self.grid[x][y]
return None
def get_neighbors(self, cell):
neighbors = []
for dx, dy in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nx, ny = cell.x + dx, cell.y + dy
neighbor = self.get_cell(nx, ny)
if neighbor and neighbor.is_passable():
neighbors.append(neighbor)
return neighbors
class MazeBuilder(ABC):
@abstractmethod
def build_from_file(self, filename):
pass
class TextFileMazeBuilder(MazeBuilder):
def build_from_file(self, filename):
with open(filename, 'r') as f:
lines = [line.rstrip('\n') for line in f.readlines()]
height = len(lines)
width = max(len(line) for line in lines) if height > 0 else 0
maze = Maze(width, height)
for y, line in enumerate(lines):
for x, char in enumerate(line):
if char == '#':
maze.grid[x][y] = Cell(x, y, True)
else:
cell = Cell(x, y, False)
if char == 'S':
cell.is_start = True
maze.start = cell
elif char == 'E':
cell.is_exit = True
maze.exit = cell
maze.grid[x][y] = cell
if not maze.start or not maze.exit:
raise ValueError("Лабиринт должен содержать старт (S) и выход (E)")
return maze
class PathFindingStrategy(ABC):
@abstractmethod
def find_path(self, maze, start, exit_cell):
pass
class BFSPathFinding(PathFindingStrategy):
def find_path(self, maze, start, exit_cell):
queue = deque([start])
visited = {start: None}
visited_count = 0
while queue:
current = queue.popleft()
visited_count += 1
if exit_cell is not None and current == exit_cell:
path = []
while current:
path.append(current)
current = visited[current]
return path[::-1], visited_count
for neighbor in maze.get_neighbors(current):
if neighbor not in visited:
visited[neighbor] = current
queue.append(neighbor)
return [], visited_count
class DFSPathFinding(PathFindingStrategy):
def find_path(self, maze, start, exit_cell):
stack = [start]
visited = {start: None}
visited_count = 0
while stack:
current = stack.pop()
visited_count += 1
if exit_cell is not None and current == exit_cell:
path = []
while current:
path.append(current)
current = visited[current]
return path[::-1], visited_count
for neighbor in maze.get_neighbors(current):
if neighbor not in visited:
visited[neighbor] = current
stack.append(neighbor)
return [], visited_count
class AStarPathFinding(PathFindingStrategy):
def heuristic(self, a, b):
if b is None:
return 0
return abs(a.x - b.x) + abs(a.y - b.y)
def find_path(self, maze, start, exit_cell):
open_set = [(0, 0, start, None)]
heapq.heapify(open_set)
g_score = {start: 0}
came_from = {}
visited_count = 0
while open_set:
_, _, current, parent = heapq.heappop(open_set)
if current in came_from:
continue
visited_count += 1
came_from[current] = parent
if exit_cell is not None and current == exit_cell:
path = []
while current:
path.append(current)
current = came_from[current]
return path[::-1], visited_count
for neighbor in maze.get_neighbors(current):
tentative_g = g_score[current] + 1
if neighbor not in g_score or tentative_g < g_score[neighbor]:
g_score[neighbor] = tentative_g
f_score = tentative_g + self.heuristic(neighbor, exit_cell)
heapq.heappush(open_set, (f_score, id(neighbor), neighbor, current))
return [], visited_count
class SearchStats:
def __init__(self, path, visited_count, time_ms):
self.path = path
self.path_length = len(path)
self.visited_count = visited_count
self.time_ms = time_ms
class Observer(ABC):
@abstractmethod
def update(self, event):
pass
class ConsoleView(Observer):
def update(self, event):
if event['type'] == 'path_found':
self.render(event['maze'], event.get('player_pos'), event['path'])
elif event['type'] == 'maze_loaded':
print(f"Лабиринт загружен: {event['maze'].width}x{event['maze'].height}")
elif event['type'] == 'search_start':
print(f"Поиск пути алгоритмом {event['strategy']}...")
elif event['type'] == 'search_end':
print(
f"Путь найден: длина {event['stats'].path_length}, посещено клеток {event['stats'].visited_count}, время {event['stats'].time_ms:.3f}мс")
def render(self, maze, player_pos=None, path=None):
os.system('cls' if os.name == 'nt' else 'clear')
path_set = set((c.x, c.y) for c in path) if path else set()
for y in range(maze.height):
for x in range(maze.width):
cell = maze.get_cell(x, y)
if player_pos and (x, y) == (player_pos.x, player_pos.y):
print('P', end='')
elif cell.is_start:
print('S', end='')
elif cell.is_exit:
print('E', end='')
elif (x, y) in path_set:
print('.', end='')
elif cell.is_wall:
print('#', end='')
else:
print(' ', end='')
print()
class MazeSolver:
def __init__(self, maze, strategy=None):
self.maze = maze
self.strategy = strategy
self.observers = []
def set_strategy(self, strategy):
self.strategy = strategy
def add_observer(self, observer):
self.observers.append(observer)
def notify(self, event):
for observer in self.observers:
observer.update(event)
def solve(self):
if not self.strategy:
raise ValueError("Стратегия не задана")
self.notify({'type': 'search_start', 'strategy': type(self.strategy).__name__})
start_time = time.perf_counter()
if self.maze.exit is None:
path, visited = self.strategy.find_path(self.maze, self.maze.start, None)
else:
path, visited = self.strategy.find_path(self.maze, self.maze.start, self.maze.exit)
end_time = time.perf_counter()
time_ms = (end_time - start_time) * 1000
stats = SearchStats(path, visited, time_ms)
self.notify({'type': 'search_end', 'stats': stats, 'strategy': type(self.strategy).__name__})
self.notify({'type': 'path_found', 'maze': self.maze, 'path': path})
return stats
def is_path_exists(maze):
if maze.exit is None:
return False
queue = deque([maze.start])
visited = {maze.start}
while queue:
current = queue.popleft()
if current == maze.exit:
return True
for neighbor in maze.get_neighbors(current):
if neighbor not in visited:
visited.add(neighbor)
queue.append(neighbor)
return False
def generate_maze(width, height, wall_density=0.3, seed=42):
np.random.seed(seed)
maze = Maze(width, height)
for x in range(width):
for y in range(height):
if x == 0 or x == width - 1 or y == 0 or y == height - 1:
maze.grid[x][y] = Cell(x, y, True)
else:
is_wall = np.random.random() < wall_density
maze.grid[x][y] = Cell(x, y, is_wall)
maze.start = maze.get_cell(1, 1)
maze.start.is_wall = False
maze.start.is_start = True
maze.grid[1][1] = maze.start
maze.grid[1][2] = Cell(1, 2, False)
maze.grid[2][1] = Cell(2, 1, False)
maze.exit = maze.get_cell(width - 2, height - 2)
maze.exit.is_wall = False
maze.exit.is_exit = True
maze.grid[width - 2][height - 3] = Cell(width - 2, height - 3, False)
maze.grid[width - 3][height - 2] = Cell(width - 3, height - 2, False)
if not is_path_exists(maze):
for x in range(1, width - 1):
for y in range(1, height - 1):
if np.random.random() < 0.5:
maze.grid[x][y].is_wall = False
if not is_path_exists(maze):
for x in range(1, width - 1):
for y in range(1, height - 1):
if x == 1 and y == 1:
continue
if x == width - 2 and y == height - 2:
continue
maze.grid[x][y].is_wall = False
return maze
def generate_empty_maze(width, height):
maze = Maze(width, height)
for x in range(width):
for y in range(height):
maze.grid[x][y] = Cell(x, y, False)
maze.start = maze.get_cell(0, 0)
maze.start.is_start = True
maze.exit = maze.get_cell(width - 1, height - 1)
maze.exit.is_exit = True
return maze
def generate_no_exit_maze(width, height):
maze = Maze(width, height)
np.random.seed(123)
for x in range(width):
for y in range(height):
if x == 0 or x == width - 1 or y == 0 or y == height - 1:
maze.grid[x][y] = Cell(x, y, True)
else:
is_wall = np.random.random() < 0.3
maze.grid[x][y] = Cell(x, y, is_wall)
maze.start = maze.get_cell(1, 1)
maze.start.is_wall = False
maze.start.is_start = True
maze.grid[1][1] = maze.start
maze.grid[1][2] = Cell(1, 2, False)
maze.grid[2][1] = Cell(2, 1, False)
maze.exit = None
return maze
def save_maze_to_file(maze, filename):
with open(filename, 'w') as f:
for y in range(maze.height):
for x in range(maze.width):
cell = maze.get_cell(x, y)
if cell.is_start:
f.write('S')
elif cell.is_exit:
f.write('E')
elif cell.is_wall:
f.write('#')
else:
f.write(' ')
f.write('\n')
def visualize_maze(maze, path=None, title="Лабиринт", ax=None):
grid = np.zeros((maze.height, maze.width))
for y in range(maze.height):
for x in range(maze.width):
cell = maze.get_cell(x, y)
if cell.is_wall:
grid[y, x] = 1
elif cell.is_start:
grid[y, x] = 2
elif cell.is_exit:
grid[y, x] = 3
if ax is None:
fig, ax = plt.subplots(figsize=(8, 8))
cmap = plt.cm.colors.ListedColormap(['white', 'black', 'green', 'red'])
ax.imshow(grid, cmap=cmap, interpolation='nearest')
if path:
path_x = [cell.x for cell in path]
path_y = [cell.y for cell in path]
ax.plot(path_x, path_y, 'b-', linewidth=2, label='Путь')
ax.set_title(title)
ax.set_xticks([])
ax.set_yticks([])
def run_experiments():
mazes_data = {
"Маленький (10x10)": generate_maze(10, 10, 0.2, 10),
"Средний (50x50)": generate_maze(50, 50, 0.3, 20),
"Большой (100x100)": generate_maze(100, 100, 0.3, 30),
"Пустой (50x50)": generate_empty_maze(50, 50),
"Без выхода (50x50)": generate_no_exit_maze(50, 50)
}
os.makedirs("mazes", exist_ok=True)
for name, maze in mazes_data.items():
filename = f"mazes/{name.replace(' ', '_').replace('(', '').replace(')', '')}.txt"
save_maze_to_file(maze, filename)
print(f"Сохранён {filename}")
strategies = {
"BFS": BFSPathFinding(),
"DFS": DFSPathFinding(),
"A*": AStarPathFinding()
}
results = []
runs = 5
fig_mazes, axes_mazes = plt.subplots(len(mazes_data), len(strategies) + 1, figsize=(18, 4 * len(mazes_data)))
if len(mazes_data) == 1:
axes_mazes = [axes_mazes]
for row_idx, (maze_name, maze) in enumerate(mazes_data.items()):
visualize_maze(maze, title=f"{maze_name}", ax=axes_mazes[row_idx][0])
for col_idx, (strat_name, strategy) in enumerate(strategies.items()):
solver = MazeSolver(maze, strategy)
times = []
visited_counts = []
path_lengths = []
best_path = None
for _ in range(runs):
stats = solver.solve()
times.append(stats.time_ms)
visited_counts.append(stats.visited_count)
path_lengths.append(stats.path_length)
if stats.path:
best_path = stats.path
avg_time = np.mean(times)
avg_visited = np.mean(visited_counts)
avg_path = np.mean(path_lengths)
results.append([maze_name, strat_name, avg_time, avg_visited, avg_path])
print(f"{maze_name} - {strat_name}: Время={avg_time:.3f}мс, Посещено={avg_visited:.0f}, Длина пути={avg_path:.0f}")
visualize_maze(maze, best_path, f"{maze_name} - {strat_name}", ax=axes_mazes[row_idx][col_idx + 1])
plt.tight_layout()
plt.savefig('mazes_visualization.png')
plt.close()
with open('results.csv', 'w', newline='', encoding='utf-8-sig') as f:
writer = csv.writer(f)
writer.writerow(["Лабиринт", "Стратегия", "Время_мс", "Посещено", "Длина_пути"])
writer.writerows(results)
print("\nРезультаты сохранены в results.csv")
return results
def plot_results(results):
strategies = ["BFS", "DFS", "A*"]
mazes = ["Маленький (10x10)", "Средний (50x50)", "Большой (100x100)", "Пустой (50x50)", "Без выхода (50x50)"]
data = {}
for strat in strategies:
data[strat] = {"times": [], "visited": [], "paths": []}
for row in results:
maze, strat, time_ms, visited, path_len = row
data[strat]["times"].append(time_ms)
data[strat]["visited"].append(visited)
data[strat]["paths"].append(path_len)
fig, axes = plt.subplots(1, 3, figsize=(18, 6))
x = np.arange(len(mazes))
width = 0.25
colors = {'BFS': 'skyblue', 'DFS': 'lightgreen', 'A*': 'salmon'}
for i, strat in enumerate(strategies):
offset = (i - 1) * width
times_display = [t if t > 0 else 0.001 for t in data[strat]["times"]]
bars = axes[0].bar(x + offset, times_display, width, label=strat, color=colors[strat])
for bar, val in zip(bars, data[strat]["times"]):
if val > 0:
axes[0].text(bar.get_x() + bar.get_width() / 2, bar.get_height() * 1.1,
f'{val:.2f}', ha='center', va='bottom', fontsize=8, rotation=90)
axes[0].set_title("Время выполнения (мс)")
axes[0].set_xticks(x)
axes[0].set_xticklabels(mazes, rotation=15, ha='right')
axes[0].set_ylabel("Время (мс)")
axes[0].set_yscale('log')
axes[0].legend()
axes[0].grid(axis='y', alpha=0.3)
for i, strat in enumerate(strategies):
offset = (i - 1) * width
visited_display = [v if v > 0 else 1 for v in data[strat]["visited"]]
bars = axes[1].bar(x + offset, visited_display, width, label=strat, color=colors[strat])
for bar, val in zip(bars, data[strat]["visited"]):
if val > 0:
axes[1].text(bar.get_x() + bar.get_width() / 2, bar.get_height() * 1.1,
f'{val:.0f}', ha='center', va='bottom', fontsize=8, rotation=90)
axes[1].set_title("Посещено клеток")
axes[1].set_xticks(x)
axes[1].set_xticklabels(mazes, rotation=15, ha='right')
axes[1].set_ylabel("Количество клеток")
axes[1].set_yscale('log')
axes[1].legend()
axes[1].grid(axis='y', alpha=0.3)
for i, strat in enumerate(strategies):
offset = (i - 1) * width
paths_display = [p if p > 0 else 1 for p in data[strat]["paths"]]
bars = axes[2].bar(x + offset, paths_display, width, label=strat, color=colors[strat])
for bar, val in zip(bars, data[strat]["paths"]):
height = bar.get_height()
axes[2].text(bar.get_x() + bar.get_width() / 2, height * 1.1,
f'{val:.0f}', ha='center', va='bottom', fontsize=8, rotation=90)
axes[2].set_title("Длина найденного пути")
axes[2].set_xticks(x)
axes[2].set_xticklabels(mazes, rotation=15, ha='right')
axes[2].set_ylabel("Длина пути")
axes[2].set_yscale('log')
axes[2].legend()
axes[2].grid(axis='y', alpha=0.3)
plt.tight_layout()
plt.savefig('comparative_results.png')
plt.show()
print("Сравнительные графики сохранены в comparative_results.png")
if __name__ == "__main__":
print("\nГенерация лабиринтов и запуск экспериментов\n")
results = run_experiments()
print("\nСоздание графиков")
plot_results(results)
print("\nЭксперименты завершены")
print("\nСозданные файлы:")
print(" - 5 текстовых файлов с лабиринтами")
print(" - mazes_visualization.png: Визуализация всех лабиринтов с путями")
print(" - results.csv: Таблица с числовыми результатами")
print(" - comparative_results.png: Сравнительные графики (Время, Посещено, Длина пути)")
print("\nСводка результатов:")
for row in results:
maze, strat, time_ms, visited, path_len = row
print(f"{maze:20s} | {strat:5s} | Время: {time_ms:8.3f}мс | Посещено: {visited:6.0f} | Путь: {path_len:4.0f}")

50
kalinovskiymi/docs_2/data_2/Без_выхода_50x50.txt Normal file
View File

@ -0,0 +1,50 @@
##################################################
#S # # ## ### # ### # # # # #
# ## # ### ## # # ##
#### # # ### ## # # # ###
# # # # ## # # ## ## # ###
# ## # ## # # ## ### # # # # ##
# #### # # ## # # ## # ##
# ## # # # # # # # ##### # #
# # # # # # # ### # # #
# # # # ### ## ## ## ### # ####
# # # # ### ## ## # # # # # # #
# ## # # ## # # ## # ## #
# # # # # # # # # # ### ##
# # ## # ## ## ## # # # # # #
## # # # # # # # # # ###
# ### # # # ### ## # # # #
# # # # # ## # # # # # #### #
## # # ## # ##### ## ## #
### # ### # ## # # ## # ## ##
# # # # ## # ### ## ## # ### ###
# # # # # # # # # ## # # # #
# # # # # ## # # # ## # # ###
# #### # # # # # # # # # # #
# ## # # ## ## # ## # #
# # #### # # # ## # ## #
# # # # ## # ###
# # # ### # ## # # # # # ###
# ## # # # # ## ## # # ##### # # ##
## ### # # # ## # # # # # # # # #
## # # # # # # # ## #
# # # # ### # # ### # # # # #
#### ## # ## # # # ## # # ### # #
# # #### ## ## # # ### #### #
# # ## # # # ## # # # ## # #
# ## ## ## # # # ### # ### # #
# # # # # #### # # # #
# # ## # # # # # ## # # ##
# ## # # # # # # # # #
# ### # # ## # # # # ## # ## #
# ## # ### # ### # # # ## ### # ###
# ## ## # ## ### ## # # # # #### #
# # # # ## # #### ## # #
## # # # # # ## ## ## # #### #
# # # # ## # # # # # #
# # # ## # ## # # ## # ##
# # # ## # # # ## # #### # # # ## # ##
## # # # ### ## ## # # # #
# # # # #### # # ## # # ## # # #
# ### ## # ## # # # ##
##################################################

100
kalinovskiymi/docs_2/data_2/Большой_100x100.txt Normal file
View File

@ -0,0 +1,100 @@
####################################################################################################
#S # # # # # # ## ## # # ## # ## # #
# ## # # # ## # # # # # # # # # # # #
# # # # # # ## # # # # # # ## # # ## # #
# # # # # # ## # ### #
# ## # # # # # # ## # #
# # # # # # # # # ### # #
# # # # # # # # # # # # # #
# # # # # # # # # # # ## # ## # #
# # ## # # # # # # # # # # ##
# ## ## # # # # # ## # ## # # # # # #
# # # # # ## # ## # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # ## # # # # # # # ## # # # # # ##
# # # # # # # # # # #
# ## ## # # # # # ## # # # #
## ## # # # # # # # # #
## # # # # # # # # #
# ## # # # # # ## # #
## # # ## # # # # # ## # #
## # # ## ### # # # # # # # # # # # #
# # # # # # # # # # ## # # #
# # # # ## # # # # # # # # # #
# # ## # # # # # # # #
### ## # # ## # ### # # # # # ##
# # ## # # # # # # # # # #
### # # # # # # # # # # # #
# ## # # # # # # # # #
# # # # # # # ## # # # # # #
# ## # # # ## # # # # # ## ## ## # ## ###
# # # # # ### # # # #
# # # # ## # # ## # ## # # # #
# # # # # # # ## # # # # ## ## # ## # #
# # # # # # # # # ## ## # #
# ## # # # # # # # # # # # # # ##
# # # # ## # # # # ## ## ## # # # # #
# # # # # # # # # # # # ##
# # # # # # ## # # # # #
# # ## # # # # # # # # # # #
# # # # # # # # # # ## # # # # ## # # # #
# # # # # # # # # ## # # # # # # #
## # # # # # ## # # # # # # # # #
# # # # # # # # # ## # # # # # ## #
# # # # ## # # # # ## # # # #
# ## # # ### # # # # # # # #
# # ## # # # # # ## # # # # #
# # # ## # # # # # # # ##
# # # # # # # # # # # # ## # #
# # # # # # # # # # # # # ## # # # # #
# # # # # ### # # # # # # # #
### # # # # ## # ## # # # # # #
# # # # ## # # # # # # ## # #
# # # # # ## # # # #
# # # # ## ## # # # # # # #
# # # # # # # # # # # # ## #
# # # # # # # # # # ## # # ## # # ##
# # # # # # # # # # # # # # # #
# # # ## # # # # ##
# # # ## # # # # # # # # ## # # # # # #
## # # # # # # # # # # # # # ## # # # #
### # # ## ### ### # # # # # ### #
# # ## ## # # # # # # # # # #
# # # # # # ## # # # # # #
# # # # # # # # # # # # # # # ##
# # # # # # # # # # # ### # ## # # #
# # # # # # # # ## # # # # # #
# ## # # # # ## # # # # # # # # # # ##
# # # ## # # # # # # # ## # # # # # #
# # # # ## # # # ## # ## # #
# # # # # # # # ### #
# ## # ### # # # # # # ### # # #
# # # ### ## # ## # # ## # # # #
# # # # # # # # # # ## # # # ### # #
# # ## # # # # # # # # # # #
## # # # # # # # # # ## # ## # # #
# # # # # # ## # ## # # # #
# # # # # # # ## # # ### ## ## # #
# # # # # # # # # # # #
## # # # # # # # # #
# # # # # # # # # # # # # ## #
# # # # # # # # # # # # ## #
# # # # # # # ## # # ## # # # # # # # # ## # #
# # ## # # ## # # # # # ##
# ### # # ## # # # # ## # ## # ## ## # #
# # # # # # # ## # # # # # #
# # # # # # # ## # # # ## ### ## # #
# # # # ## # # # # # # # ## # ##
# # ## # # # ## # # # # ## # # # # # #
# # # # # # # # #
# # # # # ## # # ### # ## ## # # #
# # # # # # # # ## # ## # # # #
# # # ## # # ### # # # # ## # # #
# # # # ### # # # # ## # # #
# # # # # # ## # # # ## ## #
# # ### # # ### # # # # # # #### #
# # # # # # ## ## # # # # #
# # # # # # # # ## # # # # #
## # # # # # # # # ### #
# # # # # ## # ## ## # # # # # # E#
####################################################################################################

10
kalinovskiymi/docs_2/data_2/Маленький_10x10.txt Normal file
View File

@ -0,0 +1,10 @@
##########
#S #
# # # #
# ## #
# # #
# # # #
# # # #
## # #
# E#
##########

50
kalinovskiymi/docs_2/data_2/Пустой_50x50.txt Normal file
View File

@ -0,0 +1,50 @@
S
E

50
kalinovskiymi/docs_2/data_2/Средний_50x50.txt Normal file
View File

@ -0,0 +1,50 @@
##################################################
#S # # # # # # # # # # ## #
# # # ### ### # # # # # #### #
# ## # ## ## ####### ### # # # # # #
# # # # # # # # # # # #
## ### # ## # # # ## ### # ## # #
# # # # ## ## # ## #
# ##### # # # # # ### # #
# # # # # ### # # ## ## #
# # # # # # # # # # # #
## # # ## ##### ### # # # #
## ## # ### ### # ## # # # # ###
# # # # ## # # # # ###
# ## ### # # # # #### # # #
# # # ## ### # # # ## # ##
# ## # #### # # # # ## # #
## # # # ### ### # # # # ## #
## # ## # # ## # #
# ## # # # # # # # # # # ##
## # # # # ### ## #
#### # ## # ### # # # # # #
# # ## ## ### # # # # # # ## ### #
# # # #### # # # # ## # ## #
# # ## # # ## ### # # # #
## ### ## ### # # # #
# ### ## # ## # # # # ####
# # # # # #### # # # ## # ##
# # ## ### # # # # ## ##
# # # # # # # # # ###### # # #
# # # # ### ### # ### # #
# # ## ## # # # # #### ##
# # # # # # ### # ##
# # # ##### # # ## # # ## ## #
### # ## # # # # # #### # #
## # ## # # ## ## ## ## # #
# # # ## ## #### ## # # ## # # ## # # #
# # ## # # ## ## # # # #### # # # ####
# # # # # # ## # # # #
# # # # ## # # # #
## # # # ## # # ## # # # # # # #
# # # #### # # # # #
# ## # # # # # # ### # ## # # #
# # ### # ## # # # # ####
# # # # # # # # # # # ## # #
# # ## # # # # # # # # # # #
#### # # # ## ## ## ## # # # # ## # # # #
# # # # # ### # # # ## #
## ## ### # # # ## # # # # #
# ## # # # ## # # # # # E#
##################################################

146
kalinovskiymi/docs_2/otchet_2.md Normal file
View File

@ -0,0 +1,146 @@
Отчёт по лабораторной работе
«Поиск выхода из лабиринта: объектно-ориентированная реализация с паттернами проектирования»
1. Постановка задачи
Целью работы является создание программы для нахождения маршрута в лабиринте от начальной точки до выхода. Программа должна поддерживать смену алгоритма поиска, отображать результаты и позволять экспериментально сравнивать эффективность разных методов.
Необходимо реализовать:
чтение лабиринта из текстового файла
три алгоритма поиска пути: BFS, DFS, A*
сравнительный анализ алгоритмов на лабиринтах различной сложности
применение не менее трёх паттернов проектирования GoF
сохранение результатов экспериментов в CSV и построение графиков
2. Архитектура приложения и применённые паттерны
2.1 Общая архитектура
Программа построена на принципах ООП и включает следующие паттерны проектирования:
Builder (Строитель) – для создания лабиринтов из файлов
Strategy (Стратегия) – для реализации разных алгоритмов поиска пути
Observer (Наблюдатель) – для отображения процесса поиска
2.2 Обоснование выбора паттернов
Паттерн Builder (Строитель)
Проблема: Загрузка лабиринта из файла требует нескольких шагов: чтение, разбор символов, создание клеток, установка старта и выхода, проверка корректности. Без Builder код загрузки оказался бы жестко связан с одним форматом.
Решение: Разработан интерфейс MazeBuilder с методом buildFromFile, реализованный в классе TextFileMazeBuilder.
Преимущества:
скрытие сложной логики построения лабиринта
возможность добавления новых форматов (JSON, бинарный) через новые реализации MazeBuilder
упрощение тестирования с помощью mock-строителя
Паттерн Strategy (Стратегия)
Проблема: Разные алгоритмы поиска (BFS, DFS, A*) имеют различную внутреннюю логику, но одинаковый интерфейс. Клиентский код не должен зависеть от конкретного алгоритма.
Решение: Создан интерфейс PathFindingStrategy с методом findPath. Каждый алгоритм реализует этот интерфейс.
Преимущества:
возможность динамической смены алгоритма во время выполнения
изоляция кода каждого алгоритма
простое добавление новых алгоритмов (Дейкстра, двунаправленный поиск)
Паттерн Observer (Наблюдатель)
Проблема: Отображение процесса поиска требует обновления интерфейса при изменении состояния, но логика поиска не должна зависеть от способа отображения.
Решение: Реализован интерфейс Observer с методом update. MazeSolver оповещает наблюдателей о событиях.
Преимущества:
слабая связанность между логикой и отображением
возможность подключения нескольких наблюдателей (консольный вывод, GUI, логирование)
3. Реализация алгоритмов поиска
3.1 BFS (поиск в ширину)
Принцип работы: использует очередь FIFO, гарантирует нахождение кратчайшего пути, обходит все клетки на расстоянии d перед переходом к d+1.
Сложность: временная O(V + E), пространственная O(V).
3.2 DFS (поиск в глубину)
Принцип работы: использует стек LIFO, идёт вглубь по одному пути до конца, затем возвращается, не гарантирует кратчайший путь, но экономит память.
Сложность: временная O(V + E), пространственная O(V) в худшем случае.
3.3 A* (эвристический поиск)
Принцип работы: использует приоритетную очередь, функция оценки f(n) = g(n) + h(n), где g(n) – стоимость пути от старта, h(n) – манхэттенское расстояние до цели.
Сложность: временная O(E) в лучшем случае, O(b^d) в худшем, пространственная O(V).
4. Экспериментальная часть
4.1 Тестовые лабиринты
№ Название Размер Характеристики
1 Маленький 10×10 Простая структура, прямой путь
2 Средний 50×50 Наличие тупиков, несколько развилок
3 Большой 100×100 Сложная структура, много препятствий
4 Пустой 50×50 Нет стен, свободное пространство
5 Без выхода 50×50 Лабиринт без exit-клетки, выход отсутствует
4.2 Методика тестирования
Каждый алгоритм запускался 5 раз на каждом лабиринте, результаты усреднялись. Измеряемые метрики:
Время выполнения (мс) – общее время работы алгоритма
Посещённые клетки – количество просмотренных алгоритмом клеток
Длина пути – количество клеток в найденном маршруте (0 если путь не найден)
4.3 Результаты экспериментов
Таблица 1. Сравнение алгоритмов на разных лабиринтах
Лабиринт Алгоритм Время (мс) Посещено клеток Длина пути
Маленький (10x10) BFS 0.204 91 16
Маленький (10x10) DFS 0.148 91 44
Маленький (10x10) A* 0.172 87 16
Средний (50x50) BFS 3.377 1526 72
Средний (50x50) DFS 2.881 1526 194
Средний (50x50) A* 3.154 1061 72
Большой (100x100) BFS 18.363 7064 123
Большой (100x100) DFS 14.031 7064 305
Большой (100x100) A* 15.562 4785 123
Пустой (50x50) BFS 1.113 2500 98
Пустой (50x50) DFS 0.760 2500 98
Пустой (50x50) A* 0.961 2500 98
Без выхода (50x50) BFS 3.210 2036 0
Без выхода (50x50) DFS 3.086 2036 0
Без выхода (50x50) A* 2.746 2036 0
Таблица 2. Усреднённые показатели
Алгоритм Среднее время (мс) Среднее посещено Средняя длина пути
BFS 5.253 2643 62
DFS 4.181 2643 127
A* 4.519 2094 62
5. Анализ результатов
5.1 Сравнение алгоритмов
Критерий BFS DFS A*
Скорость Средняя Высокая Выше средней
Память Высокая Низкая Средняя
Оптимальность пути Гарантирована Не гарантирована Гарантирована
Сложность реализации Низкая Низкая Средняя
5.2 Наблюдения
На маленьких лабиринтах все алгоритмы показывают близкие результаты, различия несущественны.
На средних и больших лабиринтах BFS и DFS обходят все достижимые клетки (1526 и 7064), в то время как A* посещает значительно меньше клеток (1061 и 4785) благодаря эвристике, что подтверждает его эффективность.
DFS стабильно находит более длинные пути (44, 194, 305) по сравнению с BFS и A* (16, 72, 123), что ожидаемо, так как DFS не гарантирует оптимальность.
В пустом лабиринте все три алгоритма посещают одинаковое количество клеток (2500), так как нет препятствий, и путь всегда прямой. Длина пути одинакова (98).
В лабиринте без выхода все алгоритмы обходят все доступные клетки (2036) и корректно возвращают пустой путь длиной 0.
A* показывает наилучший баланс между временем выполнения и оптимальностью пути, посещая в среднем на 20% меньше клеток, чем BFS и DFS.
5.3 Рекомендации по выбору алгоритма
BFS – когда критичен кратчайший путь (навигационные системы, логистика)
DFS – когда важна экономия памяти (встроенные системы, мобильные устройства)
A* – оптимальный выбор для большинства практических задач (игровой ИИ, картографические сервисы)
6. Эффективность применения паттернов
6.1 Преимущества использования паттернов
Паттерн Что упростилось Что изменилось бы без паттерна
Builder Добавление новых форматов лабиринтов Модификация основного класса при каждом новом формате
Strategy Смена алгоритма во время выполнения Множество условных операторов и дублирование кода
Observer Добавление новых способов отображения Жёсткая привязка логики поиска к консольному выводу
6.2 Гибкость и расширяемость
Применённые паттерны обеспечивают:
открытость для расширения – новые алгоритмы и форматы добавляются без изменения существующего кода
слабую связанность – компоненты независимы друг от друга
возможность повторного использования – классы можно применять в других проектах
6.3 Что было бы сложно без паттернов
Без паттернов проектирования:
добавление нового алгоритма потребовало бы изменения MazeSolver и добавления условных операторов
поддержка нового формата лабиринта потребовала бы переписывания кода загрузки
изменение способа отображения потребовало бы модификации классов поиска
7. Выводы
В ходе лабораторной работы разработана программа для поиска пути в лабиринте с применением трёх паттернов проектирования: Builder, Strategy и Observer.
Основные результаты:
реализованы три алгоритма поиска: BFS, DFS, A*
проведён сравнительный анализ эффективности на пяти типах лабиринтов разной сложности
продемонстрированы преимущества ООП и паттернов проектирования
создана гибкая архитектура, допускающая лёгкое расширение
Ключевые выводы по алгоритмам:
BFS надёжно находит кратчайший путь, но требует больше памяти
DFS быстрее и экономичнее по памяти, но путь может быть длиннее оптимального до 2.5 раз
A* обеспечивает наилучший баланс скорости и качества, посещая меньше клеток благодаря эвристике