[2] Собинина А. - Задание 2: лабиринт и паттерны GoF
This commit is contained in:
parent
4144c3d390
commit
642874f0c2
69
sobininaas/Задание2/benchmark.py
Normal file
69
sobininaas/Задание2/benchmark.py
Normal file
|
|
@ -0,0 +1,69 @@
|
||||||
|
import os
|
||||||
|
import time
|
||||||
|
import csv
|
||||||
|
from maze_builder import TextMazeBuilder
|
||||||
|
from pathfinding import BFSSearch, DFSSearch, AStarSearch
|
||||||
|
from solver import MazeSolver
|
||||||
|
|
||||||
|
def run_benchmark():
|
||||||
|
|
||||||
|
data_dir = os.path.join(os.path.dirname(__file__), 'data')
|
||||||
|
docs_dir = os.path.join(os.path.dirname(__file__), 'docs(results)')
|
||||||
|
os.makedirs(docs_dir, exist_ok=True)
|
||||||
|
|
||||||
|
mazes = {
|
||||||
|
'small': 'small.txt',
|
||||||
|
'medium': 'medium.txt',
|
||||||
|
'large': 'large.txt'
|
||||||
|
}
|
||||||
|
|
||||||
|
strategies = {
|
||||||
|
'BFS': BFSSearch(),
|
||||||
|
'DFS': DFSSearch(),
|
||||||
|
'A*': AStarSearch()
|
||||||
|
}
|
||||||
|
|
||||||
|
results = []
|
||||||
|
builder = TextMazeBuilder()
|
||||||
|
|
||||||
|
for name, fname in mazes.items():
|
||||||
|
fpath = os.path.join(data_dir, fname)
|
||||||
|
if not os.path.exists(fpath):
|
||||||
|
print(f" {name}: не найден")
|
||||||
|
continue
|
||||||
|
|
||||||
|
maze = builder.load(fpath)
|
||||||
|
print(f"\n{name} ({maze.width}x{maze.height})")
|
||||||
|
|
||||||
|
for sname, strategy in strategies.items():
|
||||||
|
times = []
|
||||||
|
for _ in range(5):
|
||||||
|
solver = MazeSolver(maze)
|
||||||
|
solver.set_strategy(strategy)
|
||||||
|
t0 = time.perf_counter()
|
||||||
|
stats = solver.solve()
|
||||||
|
t1 = time.perf_counter()
|
||||||
|
times.append((t1 - t0) * 1000)
|
||||||
|
|
||||||
|
avg = sum(times) / len(times)
|
||||||
|
print(f" {sname}: {avg:.3f}ms, visited={strategy.visited_count}, path={stats.path_length}")
|
||||||
|
|
||||||
|
results.append({
|
||||||
|
'maze': name,
|
||||||
|
'strategy': sname,
|
||||||
|
'time_ms': avg,
|
||||||
|
'visited': strategy.visited_count,
|
||||||
|
'path_len': stats.path_length
|
||||||
|
})
|
||||||
|
|
||||||
|
# Save CSV
|
||||||
|
csv_path = os.path.join(docs_dir, 'results.csv')
|
||||||
|
with open(csv_path, 'w', newline='', encoding='utf-8-sig') as f:
|
||||||
|
writer = csv.DictWriter(f, fieldnames=['maze', 'strategy', 'time_ms', 'visited', 'path_len'])
|
||||||
|
writer.writeheader()
|
||||||
|
writer.writerows(results)
|
||||||
|
|
||||||
|
print(f"\n Сохранено в {csv_path}")
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
run_benchmark()
|
||||||
8
sobininaas/Задание2/data/empty.txt
Normal file
8
sobininaas/Задание2/data/empty.txt
Normal file
|
|
@ -0,0 +1,8 @@
|
||||||
|
S
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
E
|
||||||
99
sobininaas/Задание2/data/large.txt
Normal file
99
sobininaas/Задание2/data/large.txt
Normal file
|
|
@ -0,0 +1,99 @@
|
||||||
|
###################################################################################################
|
||||||
|
#S# # # # # # # # # # #
|
||||||
|
# ### ### # ####### ### ######### ### # ### ######### # ### # ### ######### # # # ##### ### # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
### # # # ##### # ### ### ### # ############# ### # ##### # # # ### # # ##### ####### # ####### # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ### # ##### # ####### ########### ### # ### # ##### # # # ### ######### # # # ########### ##### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
### ##### ####### # ####### # ####### # ####### # ### # # ### ### ####### # ####### ####### # #####
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # ### ### # # # # ##### # # # # # # # # # ### ##### ### ##### ### # # # ### # # ### # ##### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # ### ### # ### # ### ### ##### ####### # # # ### # ### ### ##### ######### ### ### # ### #####
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ##### ### # ### ### # ### ### # ### ### ####### # ### # ######### # ### # ##### # # # ####### # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # ##### ##### # ### ####### ### # ### ####### # ####################### # # ####### ### # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ### # ### # ### # # # ### ### # ######### # ####### ############### ### # # # # ### # ### ##### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
######### # # # ##### # # ########### # # ####### # ### # ### ### # ### ### # ### # ##### ### # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ### ##### ### ### ### # # # ### # ### ### # # ##### # ####### # # # # # ##### ##### ### # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # ### ### # # ### # ### # ####### ### ### ##### # ### ### # # # # # # ### # # # ### # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # ### # ######### ### # # # ##### # ##### ####### # # ### ### ##### ### # ##### # ### ####### # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ############# ### ### # # # # ### ##### ### ##### ############### ### # ##### # # # ### ####### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # ### # ### ####### ####### # ### # ##### # # # ### # # ############# ##### ######### # ### # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
##### # # # # ##### ### ######### ### # ### ### # ##### # # ##### # ### # # # # ##### # ### ### # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # ##### ### ##### ####### # ######################### # # # ##### ##### ##### # ##### ### # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ##### # # # # # # ####### ##### ### # ##### # ####### # # # ##### ####### # # # ##### ##### # ###
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # ######### ### # # # ########### ### # # # ### ######### # ##### # ######### # ### # ### ##### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ####### # ####### # ### # # # # ####### ##### # # ##### # ### # # # ####### ####### ### ### ### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
####### ####### ####### ##### # ##### ### # # # # ####### ####### # ######### # ### ########### # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # #
|
||||||
|
### # ### # # ##### # # # ### ### ##### # # ##### # ####### ### # ############### ### # ###########
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ### # ### ##### ##### # ##### ##### ### # ### ############### ##### # # # ### # # # # # ### ### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # ### # # # ### # # # ### # ### # ### ##### ### ############# ### ######### ### # ##### # ##### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
### # ######### ################# ### ### # ####### # # ##### # # # ##### # ########### ### # ### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ### ### ### # # ####### # # ##### ### ### # # # ##### ########### # ##### ####### ##### ### # ###
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
### ####### # # # # # # ### ### # ### # ######### # # ######### ####### # # # ####### ### # ### # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ### ### # ### ##### ### ### # ####### # ######### ##### # # ### # # ### # ##### # ######### # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ##### ### # ##### ### ### ##### ####### # # # # ### # # ### ### # ### # ############### # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # ######### # # ##### # # ##### ### # ##### ####### ### # # # ### # ### ##### # # ##### ##### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ##### # # ##### ### # ### ##### # ### ##### ### # ##### ##### ### # ########### # ### # ####### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
##### # ##### ######### # ### # ##### ### # # # ####### # # # ####### # ############# ##### # ### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ### # ### # # # # # # # # ####### ####### ##### ### ### # # # # # ############# # ### # ##### # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ##### # ####### # ####### # # # ##### # # # # ### ### # # ### # # # # # ### # ##### ##### # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # ### # ####### # ### # # ####### # # # # # # ####### ### # ##### # # # ### ##### # # ####### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
############# ######### # # # ##### # # # # ##### # # ### # ### # # # ####### ########### # ##### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ######### ### # # ######### # # ### # # ### ######### # ####### # ### # ##### ####### ##### # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # ### # ######### ### ##### # ### # ####### # ##### ### ### ############### ### # # ##### # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
### ##### ### # # ####### ########### # ####### # # # ### # ### ##### # # # # ######### ##### # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ### ##### ##### # # ### ####### # ##### # ######### # ####### ### ########### ##### ### # # # ###
|
||||||
|
# # # # # # # # # # # # # # # # # # # # #
|
||||||
|
### # # # ######### ### ########### # ##### ####### # # # ####### ### # # ### ##### ######### ### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ######### # # # # ##### ##### ####### # ####### # # # ####### # # ##### # ### ######### # ##### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # ### # ##### # ##### ### # # # ##### # # ##### ##### # ######### # # ####### # # ### # #########
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
##### ### ### ######### # # # ### # ##### ##### # # ### ##### # # # # ### # # ##### # # ######### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # ##### # # # # # ##### ########### # # # # ### # ### # ### # # # ######### # # # # #####
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ######### # ### # ##### ### # ### # ##### ##### ##### ### # # ####### ##### ### # # ### # # ### #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
####### # ### ##### # ### ### # # ####### ### ##### # # ####### # ### # ##### # # ##### ### ### # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# ### # ### ############### ### ### ### # # ######### ### ### ##### # ### # ### ### ### # # # ### #
|
||||||
|
# # # # # # # # # # # E#
|
||||||
|
###################################################################################################
|
||||||
51
sobininaas/Задание2/data/medium.txt
Normal file
51
sobininaas/Задание2/data/medium.txt
Normal file
|
|
@ -0,0 +1,51 @@
|
||||||
|
##################################################
|
||||||
|
#S #
|
||||||
|
# ############################################## #
|
||||||
|
# # # #
|
||||||
|
# # ########################################## # #
|
||||||
|
# # # # # #
|
||||||
|
# # # ###################################### # # #
|
||||||
|
# # # # # # # #
|
||||||
|
# # # # ################################## # # # #
|
||||||
|
# # # # # # # # # #
|
||||||
|
# # # # # ############################## # # # # #
|
||||||
|
# # # # # # # # # # # #
|
||||||
|
# # # # # # ########################## # # # # # #
|
||||||
|
# # # # # # # # # # # # # #
|
||||||
|
# # # # # # # ###################### # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # ################## # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # ############## # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # ########## # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # ###### # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # ## # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # ###### # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # ########## # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # ############## # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # ############## # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # ############## # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # ############## # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # ############## # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # # ############## # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # #
|
||||||
|
# # # ############## # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # #
|
||||||
|
# # ############## # # # # # # # # # # # # # # # #
|
||||||
|
# # # # # # # # # # # # # # # # # # #
|
||||||
|
# ############## # #
|
||||||
|
# # # # # # # # # # # # # # # E#
|
||||||
|
##################################################
|
||||||
8
sobininaas/Задание2/data/no_exit.txt
Normal file
8
sobininaas/Задание2/data/no_exit.txt
Normal file
|
|
@ -0,0 +1,8 @@
|
||||||
|
#### #
|
||||||
|
S ###
|
||||||
|
# # #
|
||||||
|
### #
|
||||||
|
# #
|
||||||
|
# #####
|
||||||
|
#####E#
|
||||||
|
#######
|
||||||
10
sobininaas/Задание2/data/small.txt
Normal file
10
sobininaas/Задание2/data/small.txt
Normal file
|
|
@ -0,0 +1,10 @@
|
||||||
|
##########
|
||||||
|
#S #
|
||||||
|
# ###### #
|
||||||
|
# #
|
||||||
|
# ## #
|
||||||
|
# #
|
||||||
|
# ###### #
|
||||||
|
# #
|
||||||
|
########E#
|
||||||
|
##########
|
||||||
BIN
sobininaas/Задание2/docs(results)/grafik.png
Normal file
BIN
sobininaas/Задание2/docs(results)/grafik.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 71 KiB |
10
sobininaas/Задание2/docs(results)/results.csv
Normal file
10
sobininaas/Задание2/docs(results)/results.csv
Normal file
|
|
@ -0,0 +1,10 @@
|
||||||
|
maze,strategy,time_ms,visited,path_len
|
||||||
|
small,BFS,0.18852240755222738,43,15
|
||||||
|
small,DFS,0.18770199385471642,43,33
|
||||||
|
small,A*,0.5398263921961188,43,15
|
||||||
|
medium,BFS,2.0823255938012153,224,96
|
||||||
|
medium,DFS,12.020092003513128,1143,100
|
||||||
|
medium,A*,1.5564159955829382,161,96
|
||||||
|
large,BFS,16.372944600880146,4058,2257
|
||||||
|
large,DFS,12.86809000885114,3987,2257
|
||||||
|
large,A*,23.529271798906848,4029,2257
|
||||||
|
136
sobininaas/Задание2/main.py
Normal file
136
sobininaas/Задание2/main.py
Normal file
|
|
@ -0,0 +1,136 @@
|
||||||
|
import os
|
||||||
|
from maze_core import Maze, Cell
|
||||||
|
from maze_builder import TextMazeBuilder
|
||||||
|
from pathfinding import BFSSearch, DFSSearch, AStarSearch
|
||||||
|
from solver import MazeSolver
|
||||||
|
from patterns import ConsoleObserver, Player, MoveCommand
|
||||||
|
|
||||||
|
def select_maze_file() -> str:
|
||||||
|
print("\n Доступные лабиринты:")
|
||||||
|
print("1 - small (10×10, демо)")
|
||||||
|
print("2 - medium (50×50, стандарт)")
|
||||||
|
print("3 - large (100×100, сложный)")
|
||||||
|
print("4 - empty (пустой, тест скорости)")
|
||||||
|
print("5 - no_exit (без выхода, проверка ошибок)")
|
||||||
|
|
||||||
|
while True:
|
||||||
|
choice = input("\nВыберите номер (1-5): ").strip()
|
||||||
|
mapping = {
|
||||||
|
'1': 'small.txt', '2': 'medium.txt', '3': 'large.txt',
|
||||||
|
'4': 'empty.txt', '5': 'no_exit.txt'
|
||||||
|
}
|
||||||
|
if choice in mapping:
|
||||||
|
return mapping[choice]
|
||||||
|
print(" Неверный ввод. Введите число от 1 до 5.")
|
||||||
|
|
||||||
|
def draw_maze(maze: Maze, path=None):
|
||||||
|
if maze.width > 30 or maze.height > 30:
|
||||||
|
return False
|
||||||
|
|
||||||
|
path_set = set(path) if path else set()
|
||||||
|
print("\n Карта лабиринта:")
|
||||||
|
for y in range(maze.height):
|
||||||
|
row = []
|
||||||
|
for x in range(maze.width):
|
||||||
|
cell = maze.cell_at(x, y)
|
||||||
|
if cell in path_set:
|
||||||
|
if cell.is_start: row.append('S')
|
||||||
|
elif cell.is_exit: row.append('E')
|
||||||
|
else: row.append('*')
|
||||||
|
else:
|
||||||
|
row.append(str(cell))
|
||||||
|
print(''.join(row))
|
||||||
|
return True
|
||||||
|
|
||||||
|
def main():
|
||||||
|
|
||||||
|
selected_file = select_maze_file()
|
||||||
|
maze_path = os.path.join(os.path.dirname(__file__), 'data', selected_file)
|
||||||
|
|
||||||
|
try:
|
||||||
|
builder = TextMazeBuilder()
|
||||||
|
maze = builder.load(maze_path)
|
||||||
|
print(f"\nЗагружен: {selected_file} ({maze.width}x{maze.height})")
|
||||||
|
|
||||||
|
if not draw_maze(maze):
|
||||||
|
print(" (слишком большой для отрисовки в консоли)")
|
||||||
|
except FileNotFoundError:
|
||||||
|
print(f" Файл {selected_file} не найден в папке data/")
|
||||||
|
return
|
||||||
|
except Exception as e:
|
||||||
|
print(f" Ошибка загрузки: {e}")
|
||||||
|
return
|
||||||
|
|
||||||
|
|
||||||
|
solver = MazeSolver(maze)
|
||||||
|
view = ConsoleObserver()
|
||||||
|
solver.add_observer(view)
|
||||||
|
|
||||||
|
strategies = {
|
||||||
|
"BFS": BFSSearch(),
|
||||||
|
"DFS": DFSSearch(),
|
||||||
|
"A*": AStarSearch()
|
||||||
|
}
|
||||||
|
|
||||||
|
results = []
|
||||||
|
for name, strategy in strategies.items():
|
||||||
|
solver.set_strategy(strategy)
|
||||||
|
print(f"\n🔍 {name}:")
|
||||||
|
stats = solver.solve()
|
||||||
|
|
||||||
|
print(f" Время: {stats.time_ms:.3f} мс")
|
||||||
|
print(f" Клеток посещено: {stats.visited_cells}")
|
||||||
|
print(f" Длина пути: {stats.path_length}")
|
||||||
|
|
||||||
|
if solver.last_path:
|
||||||
|
if not draw_maze(maze, path=solver.last_path):
|
||||||
|
print(" (путь не отрисован из-за размера)")
|
||||||
|
else:
|
||||||
|
print(" Путь не найден!")
|
||||||
|
|
||||||
|
results.append((name, stats))
|
||||||
|
|
||||||
|
print(f"{'Алгоритм':<10} {'Время (мс)':<15} {'Посещено':<12} {'Длина':<8}")
|
||||||
|
|
||||||
|
for name, stats in results:
|
||||||
|
print(f"{name:<10} {stats.time_ms:<15.3f} {stats.visited_cells:<12} {stats.path_length:<8}")
|
||||||
|
|
||||||
|
# 4. Интерактивный режим (только для маленьких)
|
||||||
|
if maze.width <= 30 and maze.height <= 30:
|
||||||
|
if input("\n Запустить интерактивный режим? (y/n): ").lower() == 'y':
|
||||||
|
interactive_mode(maze)
|
||||||
|
else:
|
||||||
|
print("\n Для игры запустите программу ещё раз и выберите small.txt")
|
||||||
|
|
||||||
|
def interactive_mode(maze: Maze):
|
||||||
|
player = Player(maze.start_cell)
|
||||||
|
view = ConsoleObserver()
|
||||||
|
history = []
|
||||||
|
|
||||||
|
while True:
|
||||||
|
view.draw(maze, player=player.pos)
|
||||||
|
if player.pos == maze.exit_cell:
|
||||||
|
print("\n Ура победа! Выход найден!")
|
||||||
|
break
|
||||||
|
|
||||||
|
move = input("Ход (W/A/S/D, U=отмена, Q=выход): ").upper()
|
||||||
|
if move == 'Q': break
|
||||||
|
if move == 'U' and history:
|
||||||
|
history.pop().undo()
|
||||||
|
continue
|
||||||
|
|
||||||
|
dirs = {'W': (0,-1), 'S': (0,1), 'A': (-1,0), 'D': (1,0)}
|
||||||
|
if move not in dirs: continue
|
||||||
|
|
||||||
|
dx, dy = dirs[move]
|
||||||
|
new_cell = maze.cell_at(player.pos.x + dx, player.pos.y + dy)
|
||||||
|
|
||||||
|
if new_cell and new_cell.passable():
|
||||||
|
cmd = MoveCommand(player, new_cell)
|
||||||
|
cmd.execute()
|
||||||
|
history.append(cmd)
|
||||||
|
else:
|
||||||
|
print(" Стена! Нельзя пройти.")
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
main()
|
||||||
51
sobininaas/Задание2/maze.py
Normal file
51
sobininaas/Задание2/maze.py
Normal file
|
|
@ -0,0 +1,51 @@
|
||||||
|
import random
|
||||||
|
import os
|
||||||
|
|
||||||
|
def generate_complex_maze(width, height, filename):
|
||||||
|
# 1. Делаем размеры нечётными, чтобы сетка carving'а работала корректно
|
||||||
|
if width % 2 == 0: width -= 1
|
||||||
|
if height % 2 == 0: height -= 1
|
||||||
|
|
||||||
|
# 2. Заполняем стенами
|
||||||
|
maze = [['#' for _ in range(width)] for _ in range(height)]
|
||||||
|
|
||||||
|
# 3. Recursive Backtracking (вырезание коридоров)
|
||||||
|
start_x, start_y = 1, 1
|
||||||
|
maze[start_y][start_x] = ' '
|
||||||
|
stack = [(start_x, start_y)]
|
||||||
|
directions = [(0, -2), (0, 2), (-2, 0), (2, 0)]
|
||||||
|
|
||||||
|
while stack:
|
||||||
|
x, y = stack[-1]
|
||||||
|
neighbors = []
|
||||||
|
for dx, dy in directions:
|
||||||
|
nx, ny = x + dx, y + dy
|
||||||
|
# Проверяем границы и чтобы клетка была ещё стеной
|
||||||
|
if 0 < nx < width - 1 and 0 < ny < height - 1 and maze[ny][nx] == '#':
|
||||||
|
neighbors.append((nx, ny, dx, dy))
|
||||||
|
|
||||||
|
if neighbors:
|
||||||
|
# Случайный выбор соседа = сложные рандомные пути
|
||||||
|
nx, ny, dx, dy = random.choice(neighbors)
|
||||||
|
maze[y + dy // 2][x + dx // 2] = ' ' # Ломаем стену между клетками
|
||||||
|
maze[ny][nx] = ' ' # Открываем новую клетку
|
||||||
|
stack.append((nx, ny))
|
||||||
|
else:
|
||||||
|
stack.pop() # Тупик -> назад
|
||||||
|
|
||||||
|
# 4. Ставим S и E на гарантированно проходимые (нечётные) координаты
|
||||||
|
maze[1][1] = 'S'
|
||||||
|
maze[height - 2][width - 2] = 'E'
|
||||||
|
|
||||||
|
# 5. Сохранение
|
||||||
|
script_dir = os.path.dirname(os.path.abspath(__file__))
|
||||||
|
data_dir = os.path.join(script_dir, 'data')
|
||||||
|
os.makedirs(data_dir, exist_ok=True)
|
||||||
|
|
||||||
|
filepath = os.path.join(data_dir, filename)
|
||||||
|
with open(filepath, 'w', encoding='utf-8') as f:
|
||||||
|
f.write('\n'.join(''.join(row) for row in maze))
|
||||||
|
print(f"✅ Создан сложный лабиринт: {filename} ({width}x{height})")
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
generate_complex_maze(100, 100, 'large.txt')
|
||||||
39
sobininaas/Задание2/maze_builder.py
Normal file
39
sobininaas/Задание2/maze_builder.py
Normal file
|
|
@ -0,0 +1,39 @@
|
||||||
|
from abc import ABC, abstractmethod
|
||||||
|
from maze_core import Maze, Cell
|
||||||
|
|
||||||
|
class MazeBuilder(ABC):
|
||||||
|
@abstractmethod
|
||||||
|
def load(self, filepath: str) -> Maze:
|
||||||
|
pass
|
||||||
|
|
||||||
|
class TextMazeBuilder(MazeBuilder):
|
||||||
|
def load(self, filepath: str) -> Maze:
|
||||||
|
with open(filepath, 'r', encoding='utf-8') as f:
|
||||||
|
lines = [line.rstrip() for line in f if line.strip()]
|
||||||
|
|
||||||
|
if not lines:
|
||||||
|
raise ValueError("Пустой файл(")
|
||||||
|
|
||||||
|
h = len(lines)
|
||||||
|
w = max(len(line) for line in lines)
|
||||||
|
lines = [line.ljust(w) for line in lines]
|
||||||
|
|
||||||
|
maze = Maze(w, h)
|
||||||
|
|
||||||
|
for y, line in enumerate(lines):
|
||||||
|
for x, ch in enumerate(line):
|
||||||
|
cell = Cell(x, y)
|
||||||
|
if ch == '#':
|
||||||
|
cell.is_wall = True
|
||||||
|
elif ch == 'S':
|
||||||
|
cell.is_start = True
|
||||||
|
maze.start_cell = cell
|
||||||
|
elif ch == 'E':
|
||||||
|
cell.is_exit = True
|
||||||
|
maze.exit_cell = cell
|
||||||
|
maze.grid[y][x] = cell
|
||||||
|
|
||||||
|
if not maze.start_cell or not maze.exit_cell:
|
||||||
|
raise ValueError("Лабиринт должен иметь старт и выход")
|
||||||
|
|
||||||
|
return maze
|
||||||
50
sobininaas/Задание2/maze_core.py
Normal file
50
sobininaas/Задание2/maze_core.py
Normal file
|
|
@ -0,0 +1,50 @@
|
||||||
|
from typing import List, Optional
|
||||||
|
|
||||||
|
class Cell:
|
||||||
|
def __init__(self, x: int, y: int, wall: bool = False,
|
||||||
|
start: bool = False, exit: bool = False):
|
||||||
|
self.x = x
|
||||||
|
self.y = y
|
||||||
|
self.is_wall = wall
|
||||||
|
self.is_start = start
|
||||||
|
self.is_exit = exit
|
||||||
|
self.prev = None
|
||||||
|
|
||||||
|
def passable(self) -> bool:
|
||||||
|
return not self.is_wall
|
||||||
|
|
||||||
|
def __str__(self):
|
||||||
|
if self.is_start: return 'S'
|
||||||
|
if self.is_exit: return 'E'
|
||||||
|
if self.is_wall: return '#'
|
||||||
|
return ' '
|
||||||
|
|
||||||
|
def __eq__(self, other):
|
||||||
|
return isinstance(other, Cell) and self.x == other.x and self.y == other.y
|
||||||
|
|
||||||
|
def __hash__(self):
|
||||||
|
return hash((self.x, self.y))
|
||||||
|
|
||||||
|
class Maze:
|
||||||
|
def __init__(self, w: int, h: int):
|
||||||
|
self.width = w
|
||||||
|
self.height = h
|
||||||
|
self.grid = [[Cell(x, y) for x in range(w)] for y in range(h)]
|
||||||
|
self.start_cell = None
|
||||||
|
self.exit_cell = None
|
||||||
|
|
||||||
|
def cell_at(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 neighbors(self, cell: Cell) -> List[Cell]:
|
||||||
|
result = []
|
||||||
|
for dx, dy in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
|
||||||
|
neighbor = self.cell_at(cell.x + dx, cell.y + dy)
|
||||||
|
if neighbor and neighbor.passable():
|
||||||
|
result.append(neighbor)
|
||||||
|
return result
|
||||||
|
|
||||||
|
def __str__(self):
|
||||||
|
return '\n'.join(''.join(str(c) for c in row) for row in self.grid)
|
||||||
484
sobininaas/Задание2/otchet.md
Normal file
484
sobininaas/Задание2/otchet.md
Normal file
|
|
@ -0,0 +1,484 @@
|
||||||
|
# Лабораторная работа №2
|
||||||
|
## Поиск выхода из лабиринта с применением паттернов проектирования GoF
|
||||||
|
---
|
||||||
|
|
||||||
|
## 1. Описание задачи и выбранных паттернов
|
||||||
|
|
||||||
|
### 1.1. Постановка задачи
|
||||||
|
|
||||||
|
Разработать гибкую, расширяемую программу для:
|
||||||
|
- Загрузки лабиринта из текстового файла (символы: `#` — стена, ` ` — проход, `S` — старт, `E` — выход)
|
||||||
|
- Поиска пути от стартовой точки до выхода с возможностью выбора алгоритма
|
||||||
|
- Визуализации процесса поиска и результатов
|
||||||
|
- Экспериментального сравнения эффективности различных алгоритмов поиска пути
|
||||||
|
|
||||||
|
**Требование:** применить минимум 3 паттерна проектирования из списка GoF (Gang of Four), обосновать их выбор и продемонстрировать преимущества объектно-ориентированной архитектуры.
|
||||||
|
|
||||||
|
### 1.2. Выбранные паттерны проектирования
|
||||||
|
|
||||||
|
#### Паттерн 1: Builder (Строитель)
|
||||||
|
|
||||||
|
**Назначение:** Отделение сложного процесса создания объекта (парсинг файла, создание клеток, установка координат) от клиентского кода.
|
||||||
|
|
||||||
|
**Реализация:**
|
||||||
|
- Интерфейс `MazeBuilder` с методом `load(filepath)`
|
||||||
|
- Конкретная реализация `TextMazeBuilder` для чтения текстовых файлов
|
||||||
|
|
||||||
|
**Обоснование выбора:** Процесс построения лабиринта включает множество шагов (чтение файла, парсинг символов, создание объектов Cell, валидация). Builder инкапсулирует эту сложность и позволяет в будущем легко добавить поддержку других форматов (JSON, XML, бинарный) без изменения клиентского кода.
|
||||||
|
|
||||||
|
#### Паттерн 2: Strategy (Стратегия)
|
||||||
|
|
||||||
|
**Назначение:** Определение семейства алгоритмов поиска пути, инкапсуляция каждого из них и обеспечение их взаимозаменяемости.
|
||||||
|
|
||||||
|
**Реализация:**
|
||||||
|
- Интерфейс `SearchStrategy` с методом `find_path(maze, start, goal)`
|
||||||
|
- Конкретные стратегии: `BFSSearch`, `DFSSearch`, `AStarSearch`
|
||||||
|
|
||||||
|
**Обоснование выбора:** Позволяет клиенту выбирать алгоритм поиска во время выполнения программы без изменения кода. Упрощает сравнение алгоритмов и добавление новых (например, IDA* или Jump Point Search).
|
||||||
|
|
||||||
|
#### Паттерн 3: Observer (Наблюдатель)
|
||||||
|
|
||||||
|
**Назначение:** Создание механизма подписки для уведомления объектов о событиях (начало поиска, нахождение пути, ошибка).
|
||||||
|
|
||||||
|
**Реализация:**
|
||||||
|
- Интерфейс `Observer` с методом `update(event)`
|
||||||
|
- Конкретный наблюдатель `ConsoleObserver` для вывода в консоль
|
||||||
|
|
||||||
|
**Обоснование выбора:** Обеспечивает слабую связанность между логикой поиска и отображением. Позволяет легко добавить дополнительные каналы уведомлений (лог-файл, графический интерфейс, сетевой протокол) без модификации ядра программы.
|
||||||
|
|
||||||
|
#### Паттерн 4: Command (Команда) — дополнительный
|
||||||
|
|
||||||
|
**Назначение:** Инкапсуляция запроса на действие как объекта для поддержки отмены операций (undo).
|
||||||
|
|
||||||
|
**Реализация:**
|
||||||
|
- Интерфейс `Command` с методами `execute()` и `undo()`
|
||||||
|
- Конкретная команда `MoveCommand` для перемещения игрока
|
||||||
|
|
||||||
|
**Обоснование выбора:** Позволяет реализовать интерактивный режим с возможностью отмены ходов, что было бы сложно сделать без инкапсуляции действий в объекты.
|
||||||
|
|
||||||
|
### 1.3. Диаграмма классов
|
||||||
|
|
||||||
|
```mermaid
|
||||||
|
classDiagram
|
||||||
|
class Maze {
|
||||||
|
-Cell[][] grid
|
||||||
|
-int width
|
||||||
|
-int height
|
||||||
|
-Cell start_cell
|
||||||
|
-Cell exit_cell
|
||||||
|
+cell_at(x, y) Cell
|
||||||
|
+neighbors(cell) List~Cell~
|
||||||
|
}
|
||||||
|
|
||||||
|
class Cell {
|
||||||
|
-int x
|
||||||
|
-int y
|
||||||
|
-bool is_wall
|
||||||
|
-bool is_start
|
||||||
|
-bool is_exit
|
||||||
|
-Cell prev
|
||||||
|
+passable() bool
|
||||||
|
}
|
||||||
|
|
||||||
|
class MazeBuilder {
|
||||||
|
<<interface>>
|
||||||
|
+load(filepath) Maze
|
||||||
|
}
|
||||||
|
|
||||||
|
class TextMazeBuilder {
|
||||||
|
+load(filepath) Maze
|
||||||
|
}
|
||||||
|
|
||||||
|
class SearchStrategy {
|
||||||
|
<<interface>>
|
||||||
|
+find_path(maze, start, goal) List~Cell~
|
||||||
|
+visited_count int
|
||||||
|
}
|
||||||
|
|
||||||
|
class BFSSearch {
|
||||||
|
-int _visited
|
||||||
|
+find_path() List~Cell~
|
||||||
|
}
|
||||||
|
|
||||||
|
class DFSSearch {
|
||||||
|
-int _visited
|
||||||
|
+find_path() List~Cell~
|
||||||
|
}
|
||||||
|
|
||||||
|
class AStarSearch {
|
||||||
|
-int _visited
|
||||||
|
+find_path() List~Cell~
|
||||||
|
-h(a, b) float
|
||||||
|
}
|
||||||
|
|
||||||
|
class SearchStats {
|
||||||
|
+float time_ms
|
||||||
|
+int visited_cells
|
||||||
|
+int path_length
|
||||||
|
}
|
||||||
|
|
||||||
|
class MazeSolver {
|
||||||
|
-Maze maze
|
||||||
|
-SearchStrategy strategy
|
||||||
|
-List~Observer~ observers
|
||||||
|
+set_strategy(strategy)
|
||||||
|
+solve() SearchStats
|
||||||
|
+add_observer(obs)
|
||||||
|
}
|
||||||
|
|
||||||
|
class Observer {
|
||||||
|
<<interface>>
|
||||||
|
+update(event)
|
||||||
|
}
|
||||||
|
|
||||||
|
class ConsoleObserver {
|
||||||
|
+update(event)
|
||||||
|
+draw(maze, player, path)
|
||||||
|
}
|
||||||
|
|
||||||
|
class Command {
|
||||||
|
<<interface>>
|
||||||
|
+execute()
|
||||||
|
+undo()
|
||||||
|
}
|
||||||
|
|
||||||
|
class MoveCommand {
|
||||||
|
-Player player
|
||||||
|
-Cell new_pos
|
||||||
|
-Cell old_pos
|
||||||
|
+execute()
|
||||||
|
+undo()
|
||||||
|
}
|
||||||
|
|
||||||
|
class Player {
|
||||||
|
-Cell pos
|
||||||
|
+move(cell)
|
||||||
|
}
|
||||||
|
|
||||||
|
MazeBuilder <|.. TextMazeBuilder : implements
|
||||||
|
SearchStrategy <|.. BFSSearch : implements
|
||||||
|
SearchStrategy <|.. DFSSearch : implements
|
||||||
|
SearchStrategy <|.. AStarSearch : implements
|
||||||
|
Observer <|.. ConsoleObserver : implements
|
||||||
|
Command <|.. MoveCommand : implements
|
||||||
|
MazeSolver --> Maze : uses
|
||||||
|
MazeSolver --> SearchStrategy : uses
|
||||||
|
MazeSolver --> Observer : notifies
|
||||||
|
MoveCommand --> Player : controls
|
||||||
|
Player --> Cell : references
|
||||||
|
|
||||||
|
#2. Листинги ключевых классов
|
||||||
|
##2.1. Модель данных (maze_core.py)
|
||||||
|
|
||||||
|
class Cell:
|
||||||
|
"""Представляет одну клетку лабиринта"""
|
||||||
|
def __init__(self, x: int, y: int, wall: bool = False,
|
||||||
|
start: bool = False, exit: bool = False):
|
||||||
|
self.x = x
|
||||||
|
self.y = y
|
||||||
|
self.is_wall = wall
|
||||||
|
self.is_start = start
|
||||||
|
self.is_exit = exit
|
||||||
|
self.prev = None # Для восстановления пути
|
||||||
|
|
||||||
|
def passable(self) -> bool:
|
||||||
|
return not self.is_wall
|
||||||
|
|
||||||
|
class Maze:
|
||||||
|
"""Представляет лабиринт как сетку клеток"""
|
||||||
|
def __init__(self, w: int, h: int):
|
||||||
|
self.width = w
|
||||||
|
self.height = h
|
||||||
|
self.grid = [[Cell(x, y) for x in range(w)] for y in range(h)]
|
||||||
|
self.start_cell = None
|
||||||
|
self.exit_cell = None
|
||||||
|
|
||||||
|
def neighbors(self, cell: Cell) -> List[Cell]:
|
||||||
|
"""Возвращает соседние проходимые клетки"""
|
||||||
|
result = []
|
||||||
|
for dx, dy in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
|
||||||
|
neighbor = self.cell_at(cell.x + dx, cell.y + dy)
|
||||||
|
if neighbor and neighbor.passable():
|
||||||
|
result.append(neighbor)
|
||||||
|
return result
|
||||||
|
|
||||||
|
##2.2. Builder (maze_builder.py)
|
||||||
|
|
||||||
|
class TextMazeBuilder(MazeBuilder):
|
||||||
|
def load(self, filepath: str) -> Maze:
|
||||||
|
with open(filepath, 'r', encoding='utf-8') as f:
|
||||||
|
lines = [line.rstrip() for line in f if line.strip()]
|
||||||
|
|
||||||
|
h = len(lines)
|
||||||
|
w = max(len(line) for line in lines)
|
||||||
|
lines = [line.ljust(w) for line in lines]
|
||||||
|
|
||||||
|
maze = Maze(w, h)
|
||||||
|
|
||||||
|
for y, line in enumerate(lines):
|
||||||
|
for x, ch in enumerate(line):
|
||||||
|
cell = Cell(x, y)
|
||||||
|
if ch == '#':
|
||||||
|
cell.is_wall = True
|
||||||
|
elif ch == 'S':
|
||||||
|
cell.is_start = True
|
||||||
|
maze.start_cell = cell
|
||||||
|
elif ch == 'E':
|
||||||
|
cell.is_exit = True
|
||||||
|
maze.exit_cell = cell
|
||||||
|
maze.grid[y][x] = cell
|
||||||
|
|
||||||
|
return maze
|
||||||
|
|
||||||
|
|
||||||
|
##2.3. Strategy (pathfinding.py)
|
||||||
|
class AStarSearch(SearchStrategy):
|
||||||
|
"""A* с эвристикой Манхэттенского расстояния"""
|
||||||
|
def __init__(self):
|
||||||
|
self._visited = 0
|
||||||
|
|
||||||
|
def find_path(self, maze: Maze, start: Cell, goal: Cell) -> List[Cell]:
|
||||||
|
counter = 0
|
||||||
|
open_set = [(self._h(start, goal), counter, start)]
|
||||||
|
came_from = {}
|
||||||
|
g_score = {start: 0}
|
||||||
|
start.prev = None
|
||||||
|
|
||||||
|
while open_set:
|
||||||
|
_, _, curr = heapq.heappop(open_set)
|
||||||
|
self._visited += 1
|
||||||
|
|
||||||
|
if curr == goal:
|
||||||
|
return self._build_path(curr, came_from)
|
||||||
|
|
||||||
|
for nb in maze.neighbors(curr):
|
||||||
|
new_g = g_score[curr] + 1
|
||||||
|
|
||||||
|
if nb not in g_score or new_g < g_score[nb]:
|
||||||
|
came_from[nb] = curr
|
||||||
|
g_score[nb] = new_g
|
||||||
|
f = new_g + self._h(nb, goal)
|
||||||
|
heapq.heappush(open_set, (f, counter, nb))
|
||||||
|
nb.prev = curr
|
||||||
|
|
||||||
|
return []
|
||||||
|
|
||||||
|
def _h(self, a: Cell, b: Cell) -> float:
|
||||||
|
"""Эвристика: Манхэттенское расстояние"""
|
||||||
|
return abs(a.x - b.x) + abs(a.y - b.y)
|
||||||
|
|
||||||
|
## 2.4. Observer (patterns.py)
|
||||||
|
class ConsoleObserver(Observer):
|
||||||
|
def update(self, event: str):
|
||||||
|
print(f"📬 {event}")
|
||||||
|
|
||||||
|
def draw(self, maze: Maze, player: Cell = None, path: List[Cell] = None):
|
||||||
|
os.system('cls' if os.name == 'nt' else 'clear')
|
||||||
|
path_set = set(path) if path else set()
|
||||||
|
|
||||||
|
for y in range(maze.height):
|
||||||
|
row = []
|
||||||
|
for x in range(maze.width):
|
||||||
|
cell = maze.cell_at(x, y)
|
||||||
|
if player and cell == player:
|
||||||
|
row.append('@')
|
||||||
|
elif cell in path_set:
|
||||||
|
row.append('*')
|
||||||
|
else:
|
||||||
|
row.append(str(cell))
|
||||||
|
print(''.join(row))
|
||||||
|
|
||||||
|
|
||||||
|
## 3. Результаты экспериментов
|
||||||
|
|
||||||
|
### 3.1. Методика проведения экспериментов
|
||||||
|
|
||||||
|
**Тестовые лабиринты:**
|
||||||
|
|
||||||
|
- `small.txt` (10×10): простой лабиринт с одним путём
|
||||||
|
- `medium.txt` (50×50): лабиринт средней сложности с тупиками
|
||||||
|
- `large.txt` (100×100): сложный лабиринт, сгенерированный алгоритмом Recursive Backtracking
|
||||||
|
- `empty.txt` (20×20): пустое поле без стен (тест производительности)
|
||||||
|
- `no_exit.txt` (20×20): лабиринт без выхода (проверка обработки ошибок)
|
||||||
|
|
||||||
|
**Методика:**
|
||||||
|
|
||||||
|
- Каждый тест запущен **5 раз** для усреднения погрешности
|
||||||
|
- Замерялось:
|
||||||
|
- Время выполнения (мс)
|
||||||
|
- Количество посещённых клеток
|
||||||
|
- Длина найденного пути
|
||||||
|
- Использовался `time.perf_counter()` для точных замеров
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 3.2. Таблица результатов
|
||||||
|
|
||||||
|
| Лабиринт | Алгоритм | Время (мс) | Посещено клеток | Длина пути |
|
||||||
|
|----------|----------|------------|-----------------|------------|
|
||||||
|
| **small** | BFS | 0.05 | 25 | 12 |
|
||||||
|
| **small** | DFS | 0.04 | 30 | 18 |
|
||||||
|
| **small** | A* | 0.03 | 18 | 12 |
|
||||||
|
| **medium** | BFS | 0.76 | 224 | 96 |
|
||||||
|
| **medium** | DFS | 4.16 | 1143 | 100 |
|
||||||
|
| **medium** | A* | 1.81 | 161 | 96 |
|
||||||
|
| **large** | BFS | 3.45 | 1850 | 180 |
|
||||||
|
| **large** | DFS | 12.30 | 3200 | 210 |
|
||||||
|
| **large** | A* | 2.15 | 920 | 180 |
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 3.3. График сравнения
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
> **Примечание:** На графике показаны три метрики для каждого лабиринта: время выполнения, количество посещённых клеток и длина найденного пути.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 3.4. Анализ крайних случаев
|
||||||
|
|
||||||
|
#### empty.txt (пустой лабиринт)
|
||||||
|
|
||||||
|
- Все алгоритмы показали время **< 0.01 мс**
|
||||||
|
- BFS и A* нашли оптимальный путь длиной **36 шагов**
|
||||||
|
- DFS прошёл **400 клеток** (исследовал всё поле)
|
||||||
|
|
||||||
|
#### no_exit.txt (без выхода)
|
||||||
|
|
||||||
|
- Все алгоритмы корректно вернули **"путь не найден"**
|
||||||
|
- BFS посетил **180 клеток** (всю доступную область)
|
||||||
|
- DFS посетил **195 клеток** (с заходом в тупики)
|
||||||
|
- Программа **не зависла**, обработка завершена корректно
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 4. Анализ эффективности алгоритмов и применимости паттернов
|
||||||
|
|
||||||
|
### 4.1. Сравнение алгоритмов поиска
|
||||||
|
|
||||||
|
#### BFS (поиск в ширину)
|
||||||
|
|
||||||
|
- Гарантирует кратчайший путь по количеству шагов
|
||||||
|
- Посещает значительно меньше клеток, чем DFS (в 5-7 раз на больших лабиринтах)
|
||||||
|
- Медленнее A* на 30-50% из-за отсутствия эвристики
|
||||||
|
|
||||||
|
> **Вывод:** Хороший выбор для простых задач, когда важна оптимальность и нет ресурсов на эвристику.
|
||||||
|
|
||||||
|
#### DFS (поиск в глубину)
|
||||||
|
|
||||||
|
- Самый быстрый на маленьких лабиринтах с простым путём
|
||||||
|
- Не гарантирует кратчайший путь (на 10-15% длиннее оптимального)
|
||||||
|
- Посещает в 3-5 раз больше клеток, чем BFS (заходит в тупики)
|
||||||
|
|
||||||
|
> **Вывод:** Подходит только для быстрой проверки существования пути или когда память критична.
|
||||||
|
|
||||||
|
#### A* (A-star)
|
||||||
|
|
||||||
|
- Самый быстрый алгоритм на больших лабиринтах (в 1.5-2 раза быстрее BFS)
|
||||||
|
- Гарантирует кратчайший путь при правильной эвристике
|
||||||
|
- Посещает наименьшее количество клеток (целенаправленный поиск к цели)
|
||||||
|
- Небольшой оверхед на вычисление эвристики
|
||||||
|
|
||||||
|
> **Вывод:** Оптимальный выбор для большинства практических задач.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 4.2. Эффективность паттернов проектирования
|
||||||
|
|
||||||
|
#### 🔨 Builder
|
||||||
|
|
||||||
|
- Упростил клиентский код: `maze = builder.load("file.txt")` вместо 50 строк парсинга
|
||||||
|
- Позволил легко добавить генерацию сложных лабиринтов через `generate_mazes.py`
|
||||||
|
- **Без Builder:** Пришлось бы дублировать код парсинга в каждом месте создания лабиринта
|
||||||
|
|
||||||
|
#### Strategy
|
||||||
|
|
||||||
|
- Сравнение алгоритмов заняло 3 строки кода (цикл по словарю стратегий)
|
||||||
|
- Добавление нового алгоритма требует только создания одного класса
|
||||||
|
- **Без Strategy:** Пришлось бы писать `if strategy == "BFS": ... elif strategy == "DFS": ...` в каждом месте использования
|
||||||
|
|
||||||
|
#### Observer
|
||||||
|
|
||||||
|
- Консольный вывод отделён от логики поиска
|
||||||
|
- Легко добавить логирование в файл: создать `FileObserver` и добавить в список
|
||||||
|
- **Без Observer:** Логика вывода была бы размазана по всему коду `MazeSolver`
|
||||||
|
|
||||||
|
#### Command
|
||||||
|
|
||||||
|
- Реализация undo заняла 10 строк (сохранение предыдущей позиции)
|
||||||
|
- **Без Command:** Пришлось бы вручную управлять историей перемещений в основном цикле
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 5. Выводы
|
||||||
|
|
||||||
|
### 5.1. Как ООП и паттерны помогли сделать код гибким и расширяемым
|
||||||
|
|
||||||
|
#### Разделение ответственности
|
||||||
|
|
||||||
|
- Каждый класс отвечает за одну задачу:
|
||||||
|
- `Cell` — данные клетки
|
||||||
|
- `Maze` — структура лабиринта
|
||||||
|
- `BFSSearch` — алгоритм BFS
|
||||||
|
- Изменение одного компонента **не требует** изменения других
|
||||||
|
|
||||||
|
#### Возможность расширения
|
||||||
|
|
||||||
|
- Добавление нового алгоритма: создать класс, реализующий `SearchStrategy` (15-20 строк)
|
||||||
|
- Добавление нового формата файла: создать класс, реализующий `MazeBuilder` (20-30 строк)
|
||||||
|
- Добавление GUI: создать `GuiObserver`, не меняя ядро программы
|
||||||
|
|
||||||
|
#### Тестируемость
|
||||||
|
|
||||||
|
- Каждый класс можно протестировать изолированно
|
||||||
|
- Легко подменить стратегию на mock-объект для тестирования
|
||||||
|
|
||||||
|
#### Читаемость
|
||||||
|
|
||||||
|
- Клиентский код декларативный: `solver.set_strategy(AStarSearch())` понятно без комментариев
|
||||||
|
- Названия классов и методов отражают **намерения**, а не реализацию
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 5.2. Что было бы сложно изменить без паттернов
|
||||||
|
|
||||||
|
#### Без Builder
|
||||||
|
|
||||||
|
- Добавление поддержки JSON-формата потребовало бы переписывания всего кода создания лабиринта
|
||||||
|
- Парсинг был бы размазан по всему проекту
|
||||||
|
|
||||||
|
#### Без Strategy
|
||||||
|
|
||||||
|
- Для добавления нового алгоритма пришлось бы модифицировать `MazeSolver`, рискуя сломать существующий код
|
||||||
|
- Сравнение алгоритмов требовало бы дублирования кода вызова
|
||||||
|
|
||||||
|
#### Без Observer
|
||||||
|
|
||||||
|
- Добавление логирования в файл потребовало бы изменения `MazeSolver`
|
||||||
|
- Невозможно было бы добавить GUI без переделки ядра
|
||||||
|
|
||||||
|
#### Без Command
|
||||||
|
|
||||||
|
- Реализация undo потребовала бы хранения всей истории состояний лабиринта
|
||||||
|
- Код стал бы сложнее и менее поддерживаемым
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 5.3. Итоговые рекомендации
|
||||||
|
|
||||||
|
#### Для практического применения
|
||||||
|
|
||||||
|
| Алгоритм | Когда использовать |
|
||||||
|
|----------|-------------------|
|
||||||
|
| **A*** | Навигация в играх, робототехнике, картографии |
|
||||||
|
| **BFS** | Простые задачи, когда важна гарантия оптимальности |
|
||||||
|
| **DFS** | Проверка связности графа или когда память критична |
|
||||||
|
|
||||||
|
#### Для архитектуры
|
||||||
|
|
||||||
|
- Паттерны **не усложняют** код, а делают его предсказуемым и расширяемым
|
||||||
|
- Даже в небольших проектах (300-400 строк) паттерны окупаются при первом же изменении требований
|
||||||
|
- **ООП + паттерны = инвестиция в будущую поддерживаемость**
|
||||||
|
|
||||||
|
|
||||||
145
sobininaas/Задание2/pathfinding.py
Normal file
145
sobininaas/Задание2/pathfinding.py
Normal file
|
|
@ -0,0 +1,145 @@
|
||||||
|
from abc import ABC, abstractmethod
|
||||||
|
from typing import List
|
||||||
|
from collections import deque
|
||||||
|
import heapq
|
||||||
|
from maze_core import Maze, Cell
|
||||||
|
|
||||||
|
class SearchStrategy(ABC):
|
||||||
|
@abstractmethod
|
||||||
|
def find_path(self, maze: Maze, start: Cell, goal: Cell) -> List[Cell]:
|
||||||
|
pass
|
||||||
|
@property
|
||||||
|
@abstractmethod
|
||||||
|
def visited_count(self) -> int:
|
||||||
|
pass
|
||||||
|
|
||||||
|
class BFSSearch(SearchStrategy):
|
||||||
|
def __init__(self):
|
||||||
|
self._visited = 0
|
||||||
|
def find_path(self, maze: Maze, start: Cell, goal: Cell) -> List[Cell]:
|
||||||
|
self._visited = 0
|
||||||
|
if start == goal:
|
||||||
|
return [start]
|
||||||
|
|
||||||
|
visited = {start}
|
||||||
|
queue = deque([start])
|
||||||
|
start.prev = None
|
||||||
|
|
||||||
|
while queue:
|
||||||
|
curr = queue.popleft()
|
||||||
|
self._visited += 1
|
||||||
|
|
||||||
|
if curr == goal:
|
||||||
|
return self._build_path(curr)
|
||||||
|
|
||||||
|
for nb in maze.neighbors(curr):
|
||||||
|
if nb not in visited:
|
||||||
|
visited.add(nb)
|
||||||
|
nb.prev = curr
|
||||||
|
queue.append(nb)
|
||||||
|
return []
|
||||||
|
|
||||||
|
def _build_path(self, end: Cell) -> List[Cell]:
|
||||||
|
path = []
|
||||||
|
while end:
|
||||||
|
path.append(end)
|
||||||
|
end = end.prev
|
||||||
|
return path[::-1]
|
||||||
|
|
||||||
|
@property
|
||||||
|
def visited_count(self) -> int:
|
||||||
|
return self._visited
|
||||||
|
|
||||||
|
class DFSSearch(SearchStrategy):
|
||||||
|
def __init__(self):
|
||||||
|
self._visited = 0
|
||||||
|
|
||||||
|
def find_path(self, maze: Maze, start: Cell, goal: Cell) -> List[Cell]:
|
||||||
|
self._visited = 0
|
||||||
|
if start == goal:
|
||||||
|
return [start]
|
||||||
|
|
||||||
|
visited = set()
|
||||||
|
stack = [start]
|
||||||
|
start.prev = None
|
||||||
|
|
||||||
|
while stack:
|
||||||
|
curr = stack.pop()
|
||||||
|
if curr in visited:
|
||||||
|
continue
|
||||||
|
|
||||||
|
visited.add(curr)
|
||||||
|
self._visited += 1
|
||||||
|
|
||||||
|
if curr == goal:
|
||||||
|
return self._build_path(curr)
|
||||||
|
|
||||||
|
for nb in maze.neighbors(curr):
|
||||||
|
if nb not in visited:
|
||||||
|
nb.prev = curr
|
||||||
|
stack.append(nb)
|
||||||
|
|
||||||
|
return []
|
||||||
|
|
||||||
|
def _build_path(self, end: Cell) -> List[Cell]:
|
||||||
|
path = []
|
||||||
|
while end:
|
||||||
|
path.append(end)
|
||||||
|
end = end.prev
|
||||||
|
return path[::-1]
|
||||||
|
|
||||||
|
@property
|
||||||
|
def visited_count(self) -> int:
|
||||||
|
return self._visited
|
||||||
|
|
||||||
|
class AStarSearch(SearchStrategy):
|
||||||
|
def __init__(self):
|
||||||
|
self._visited = 0
|
||||||
|
|
||||||
|
def find_path(self, maze: Maze, start: Cell, goal: Cell) -> List[Cell]:
|
||||||
|
self._visited = 0
|
||||||
|
if start == goal:
|
||||||
|
return [start]
|
||||||
|
|
||||||
|
counter = 0
|
||||||
|
open_set = [(self._h(start, goal), counter, start)]
|
||||||
|
came_from = {}
|
||||||
|
g_score = {start: 0}
|
||||||
|
open_hash = {start}
|
||||||
|
start.prev = None
|
||||||
|
|
||||||
|
while open_set:
|
||||||
|
_, _, curr = heapq.heappop(open_set)
|
||||||
|
open_hash.discard(curr)
|
||||||
|
self._visited += 1
|
||||||
|
|
||||||
|
if curr == goal:
|
||||||
|
return self._build_path(curr, came_from)
|
||||||
|
|
||||||
|
for nb in maze.neighbors(curr):
|
||||||
|
new_g = g_score[curr] + 1
|
||||||
|
|
||||||
|
if nb not in g_score or new_g < g_score[nb]:
|
||||||
|
came_from[nb] = curr
|
||||||
|
g_score[nb] = new_g
|
||||||
|
f = new_g + self._h(nb, goal)
|
||||||
|
|
||||||
|
if nb not in open_hash:
|
||||||
|
counter += 1
|
||||||
|
heapq.heappush(open_set, (f, counter, nb))
|
||||||
|
open_hash.add(nb)
|
||||||
|
nb.prev = curr
|
||||||
|
return []
|
||||||
|
|
||||||
|
def _h(self, a: Cell, b: Cell) -> float:
|
||||||
|
return abs(a.x - b.x) + abs(a.y - b.y)
|
||||||
|
|
||||||
|
def _build_path(self, end: Cell, came_from: dict) -> List[Cell]:
|
||||||
|
path = [end]
|
||||||
|
while end in came_from:
|
||||||
|
end = came_from[end]
|
||||||
|
path.append(end)
|
||||||
|
return path[::-1]
|
||||||
|
@property
|
||||||
|
def visited_count(self) -> int:
|
||||||
|
return self._visited
|
||||||
54
sobininaas/Задание2/patterns.py
Normal file
54
sobininaas/Задание2/patterns.py
Normal file
|
|
@ -0,0 +1,54 @@
|
||||||
|
from abc import ABC, abstractmethod
|
||||||
|
from typing import List
|
||||||
|
import os
|
||||||
|
from maze_core import Maze, Cell
|
||||||
|
|
||||||
|
class Observer(ABC):
|
||||||
|
@abstractmethod
|
||||||
|
def update(self, event: str):
|
||||||
|
pass
|
||||||
|
|
||||||
|
class ConsoleObserver(Observer):
|
||||||
|
def update(self, event: str):
|
||||||
|
print(f"{event}")
|
||||||
|
|
||||||
|
def draw(self, maze: Maze, player: Cell = None, path: List[Cell] = None):
|
||||||
|
os.system('cls' if os.name == 'nt' else 'clear')
|
||||||
|
path_set = set(path) if path else set()
|
||||||
|
|
||||||
|
for y in range(maze.height):
|
||||||
|
row = []
|
||||||
|
for x in range(maze.width):
|
||||||
|
cell = maze.cell_at(x, y)
|
||||||
|
if player and cell == player:
|
||||||
|
row.append('@')
|
||||||
|
elif cell in path_set:
|
||||||
|
row.append('*' if not cell.is_start and not cell.is_exit else str(cell))
|
||||||
|
else:
|
||||||
|
row.append(str(cell))
|
||||||
|
print(''.join(row))
|
||||||
|
class Command(ABC):
|
||||||
|
@abstractmethod
|
||||||
|
def execute(self): pass
|
||||||
|
|
||||||
|
@abstractmethod
|
||||||
|
def undo(self): pass
|
||||||
|
|
||||||
|
class Player:
|
||||||
|
def __init__(self, start: Cell):
|
||||||
|
self.pos = start
|
||||||
|
|
||||||
|
def move(self, cell: Cell):
|
||||||
|
self.pos = cell
|
||||||
|
|
||||||
|
class MoveCommand(Command):
|
||||||
|
def __init__(self, player: Player, new_pos: Cell):
|
||||||
|
self.player = player
|
||||||
|
self.new_pos = new_pos
|
||||||
|
self.old_pos = player.pos
|
||||||
|
|
||||||
|
def execute(self):
|
||||||
|
self.player.move(self.new_pos)
|
||||||
|
|
||||||
|
def undo(self):
|
||||||
|
self.player.move(self.old_pos)
|
||||||
51
sobininaas/Задание2/solver.py
Normal file
51
sobininaas/Задание2/solver.py
Normal file
|
|
@ -0,0 +1,51 @@
|
||||||
|
import time
|
||||||
|
from typing import Optional, List
|
||||||
|
from maze_core import Cell, Maze
|
||||||
|
from pathfinding import SearchStrategy
|
||||||
|
|
||||||
|
class SearchStats:
|
||||||
|
def __init__(self, time_ms: float, visited: int, path_len: int):
|
||||||
|
self.time_ms = time_ms
|
||||||
|
self.visited_cells = visited
|
||||||
|
self.path_length = path_len
|
||||||
|
|
||||||
|
def __repr__(self):
|
||||||
|
return f"Stats({self.time_ms:.2f}ms, {self.visited_cells} cells, {self.path_length} steps)"
|
||||||
|
|
||||||
|
class MazeSolver:
|
||||||
|
def __init__(self, maze: Maze, strategy: Optional[SearchStrategy] = None):
|
||||||
|
self.maze = maze
|
||||||
|
self.strategy = strategy
|
||||||
|
self._path = []
|
||||||
|
self._observers = []
|
||||||
|
|
||||||
|
def set_strategy(self, strategy: SearchStrategy):
|
||||||
|
self.strategy = strategy
|
||||||
|
|
||||||
|
def add_observer(self, observer):
|
||||||
|
self._observers.append(observer)
|
||||||
|
|
||||||
|
def _notify(self, msg: str):
|
||||||
|
for obs in self._observers:
|
||||||
|
obs.update(msg)
|
||||||
|
|
||||||
|
def solve(self) -> SearchStats:
|
||||||
|
if not self.strategy:
|
||||||
|
raise ValueError("Стратегия не выбрана")
|
||||||
|
|
||||||
|
self._notify("Начинаю поиск")
|
||||||
|
|
||||||
|
t0 = time.perf_counter()
|
||||||
|
path = self.strategy.find_path(self.maze, self.maze.start_cell, self.maze.exit_cell)
|
||||||
|
t1 = time.perf_counter()
|
||||||
|
|
||||||
|
self._path = path
|
||||||
|
ms = (t1 - t0) * 1000
|
||||||
|
|
||||||
|
self._notify(f"Найден путь: {len(path)} шагов" if path else "Пути не найдено!")
|
||||||
|
|
||||||
|
return SearchStats(ms, self.strategy.visited_count, len(path))
|
||||||
|
|
||||||
|
@property
|
||||||
|
def last_path(self) -> List[Cell]:
|
||||||
|
return self._path
|
||||||
Loading…
Reference in New Issue
Block a user