Compare commits
No commits in common. "develop" and "develop" have entirely different histories.
|
|
@ -1 +0,0 @@
|
||||||
Subproject commit 52c001a380431727397e4275c2be9d94fe5fcc8d
|
|
||||||
|
|
@ -1,292 +0,0 @@
|
||||||
#!/usr/bin/env python3
|
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
|
|
||||||
import time
|
|
||||||
import random
|
|
||||||
import csv
|
|
||||||
import sys
|
|
||||||
sys.setrecursionlimit(30000)
|
|
||||||
|
|
||||||
def ll_create_node(name, phone):
|
|
||||||
return {'name': name, 'phone': phone, 'next': None}
|
|
||||||
|
|
||||||
def ll_insert(head, name, phone):
|
|
||||||
if head is None:
|
|
||||||
return ll_create_node(name, phone)
|
|
||||||
|
|
||||||
if head['name'] == name:
|
|
||||||
head['phone'] = phone
|
|
||||||
return head
|
|
||||||
|
|
||||||
current = head
|
|
||||||
while current['next'] is not None:
|
|
||||||
if current['next']['name'] == name:
|
|
||||||
current['next']['phone'] = phone
|
|
||||||
return head
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
current['next'] = ll_create_node(name, phone)
|
|
||||||
return head
|
|
||||||
|
|
||||||
def ll_find(head, name):
|
|
||||||
current = head
|
|
||||||
while current is not None:
|
|
||||||
if current['name'] == name:
|
|
||||||
return current['phone']
|
|
||||||
current = current['next']
|
|
||||||
return None
|
|
||||||
|
|
||||||
def ll_delete(head, name):
|
|
||||||
if head is None:
|
|
||||||
return None
|
|
||||||
|
|
||||||
if head['name'] == name:
|
|
||||||
return head['next']
|
|
||||||
|
|
||||||
current = head
|
|
||||||
while current['next'] is not None:
|
|
||||||
if current['next']['name'] == name:
|
|
||||||
current['next'] = current['next']['next']
|
|
||||||
return head
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
return head
|
|
||||||
|
|
||||||
def ll_list_all(head):
|
|
||||||
records = []
|
|
||||||
current = head
|
|
||||||
while current is not None:
|
|
||||||
records.append((current['name'], current['phone']))
|
|
||||||
current = current['next']
|
|
||||||
records.sort(key=lambda x: x[0])
|
|
||||||
return records
|
|
||||||
|
|
||||||
def hash_function(name, table_size):
|
|
||||||
return sum(ord(c) for c in name) % table_size
|
|
||||||
|
|
||||||
def ht_create_table(size=2000):
|
|
||||||
return [None] * size
|
|
||||||
|
|
||||||
def ht_insert(table, name, phone):
|
|
||||||
index = hash_function(name, len(table))
|
|
||||||
table[index] = ll_insert(table[index], name, phone)
|
|
||||||
|
|
||||||
def ht_find(table, name):
|
|
||||||
index = hash_function(name, len(table))
|
|
||||||
return ll_find(table[index], name)
|
|
||||||
|
|
||||||
def ht_delete(table, name):
|
|
||||||
index = hash_function(name, len(table))
|
|
||||||
table[index] = ll_delete(table[index], name)
|
|
||||||
|
|
||||||
def ht_list_all(table):
|
|
||||||
all_records = []
|
|
||||||
for bucket in table:
|
|
||||||
if bucket is not None:
|
|
||||||
current = bucket
|
|
||||||
while current is not None:
|
|
||||||
all_records.append((current['name'], current['phone']))
|
|
||||||
current = current['next']
|
|
||||||
all_records.sort(key=lambda x: x[0])
|
|
||||||
return all_records
|
|
||||||
|
|
||||||
def bst_create_node(name, phone):
|
|
||||||
return {'name': name, 'phone': phone, 'left': None, 'right': None}
|
|
||||||
|
|
||||||
def bst_insert(root, name, phone):
|
|
||||||
if root is None:
|
|
||||||
return bst_create_node(name, phone)
|
|
||||||
|
|
||||||
current = root
|
|
||||||
while True:
|
|
||||||
if name < current['name']:
|
|
||||||
if current['left'] is None:
|
|
||||||
current['left'] = bst_create_node(name, phone)
|
|
||||||
break
|
|
||||||
else:
|
|
||||||
current = current['left']
|
|
||||||
elif name > current['name']:
|
|
||||||
if current['right'] is None:
|
|
||||||
current['right'] = bst_create_node(name, phone)
|
|
||||||
break
|
|
||||||
else:
|
|
||||||
current = current['right']
|
|
||||||
else:
|
|
||||||
current['phone'] = phone
|
|
||||||
break
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
def bst_find(root, name):
|
|
||||||
current = root
|
|
||||||
while current is not None:
|
|
||||||
if name < current['name']:
|
|
||||||
current = current['left']
|
|
||||||
elif name > current['name']:
|
|
||||||
current = current['right']
|
|
||||||
else:
|
|
||||||
return current['phone']
|
|
||||||
return None
|
|
||||||
|
|
||||||
def bst_find_min(node):
|
|
||||||
current = node
|
|
||||||
while current['left'] is not None:
|
|
||||||
current = current['left']
|
|
||||||
return current
|
|
||||||
|
|
||||||
def bst_delete(root, name):
|
|
||||||
if root is None:
|
|
||||||
return None
|
|
||||||
|
|
||||||
parent = None
|
|
||||||
current = root
|
|
||||||
|
|
||||||
while current is not None and current['name'] != name:
|
|
||||||
parent = current
|
|
||||||
if name < current['name']:
|
|
||||||
current = current['left']
|
|
||||||
else:
|
|
||||||
current = current['right']
|
|
||||||
|
|
||||||
if current is None:
|
|
||||||
return root
|
|
||||||
|
|
||||||
if current['left'] is None or current['right'] is None:
|
|
||||||
if current['left'] is not None:
|
|
||||||
child = current['left']
|
|
||||||
else:
|
|
||||||
child = current['right']
|
|
||||||
|
|
||||||
if parent is None:
|
|
||||||
return child
|
|
||||||
|
|
||||||
if parent['left'] == current:
|
|
||||||
parent['left'] = child
|
|
||||||
else:
|
|
||||||
parent['right'] = child
|
|
||||||
else:
|
|
||||||
successor_parent = current
|
|
||||||
successor = current['right']
|
|
||||||
|
|
||||||
while successor['left'] is not None:
|
|
||||||
successor_parent = successor
|
|
||||||
successor = successor['left']
|
|
||||||
|
|
||||||
current['name'] = successor['name']
|
|
||||||
current['phone'] = successor['phone']
|
|
||||||
|
|
||||||
if successor_parent['left'] == successor:
|
|
||||||
successor_parent['left'] = successor['right']
|
|
||||||
else:
|
|
||||||
successor_parent['right'] = successor['right']
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
def bst_list_all(root):
|
|
||||||
records = []
|
|
||||||
stack = []
|
|
||||||
current = root
|
|
||||||
|
|
||||||
while stack or current is not None:
|
|
||||||
while current is not None:
|
|
||||||
stack.append(current)
|
|
||||||
current = current['left']
|
|
||||||
current = stack.pop()
|
|
||||||
records.append((current['name'], current['phone']))
|
|
||||||
current = current['right']
|
|
||||||
|
|
||||||
return records
|
|
||||||
|
|
||||||
def generate_data(n=10000):
|
|
||||||
records = [(f"User_{i:05d}", f"+7-999-{i:06d}") for i in range(n)]
|
|
||||||
records_shuffled = records.copy()
|
|
||||||
random.shuffle(records_shuffled)
|
|
||||||
records_sorted = sorted(records, key=lambda x: x[0])
|
|
||||||
return records_shuffled, records_sorted
|
|
||||||
|
|
||||||
def run_experiment(structure_name, insert_func, find_func, delete_func,
|
|
||||||
list_all_func, init_func, records, n_find=100):
|
|
||||||
|
|
||||||
data = init_func()
|
|
||||||
names = [r[0] for r in records]
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
for name, phone in records:
|
|
||||||
if structure_name == "HashTable":
|
|
||||||
insert_func(data, name, phone)
|
|
||||||
else:
|
|
||||||
data = insert_func(data, name, phone)
|
|
||||||
insert_time = time.perf_counter() - start
|
|
||||||
|
|
||||||
find_names = random.sample(names, min(n_find, len(names)))
|
|
||||||
missing_names = [f"None_{i}" for i in range(10)]
|
|
||||||
all_find_names = find_names + missing_names
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
for name in all_find_names:
|
|
||||||
if structure_name == "HashTable":
|
|
||||||
find_func(data, name)
|
|
||||||
else:
|
|
||||||
find_func(data, name)
|
|
||||||
find_time = time.perf_counter() - start
|
|
||||||
|
|
||||||
delete_names = random.sample(names, min(50, len(names)))
|
|
||||||
start = time.perf_counter()
|
|
||||||
for name in delete_names:
|
|
||||||
if structure_name == "HashTable":
|
|
||||||
delete_func(data, name)
|
|
||||||
else:
|
|
||||||
data = delete_func(data, name)
|
|
||||||
delete_time = time.perf_counter() - start
|
|
||||||
|
|
||||||
return insert_time, find_time, delete_time
|
|
||||||
|
|
||||||
def main():
|
|
||||||
print("Generating test data...")
|
|
||||||
records_shuffled, records_sorted = generate_data(10000)
|
|
||||||
|
|
||||||
results = []
|
|
||||||
|
|
||||||
structures = [
|
|
||||||
("LinkedList", ll_insert, ll_find, ll_delete, ll_list_all, lambda: None),
|
|
||||||
("HashTable", ht_insert, ht_find, ht_delete, ht_list_all, lambda: ht_create_table(2000)),
|
|
||||||
("BST", bst_insert, bst_find, bst_delete, bst_list_all, lambda: None)
|
|
||||||
]
|
|
||||||
|
|
||||||
for mode_name, records in [("random", records_shuffled), ("sorted", records_sorted)]:
|
|
||||||
print(f"\nMode: {mode_name}")
|
|
||||||
|
|
||||||
for struct_name, insert_f, find_f, delete_f, list_f, init_f in structures:
|
|
||||||
print(f" Testing {struct_name}...")
|
|
||||||
|
|
||||||
times = []
|
|
||||||
for run in range(5):
|
|
||||||
insert_t, find_t, delete_t = run_experiment(
|
|
||||||
struct_name, insert_f, find_f, delete_f, list_f, init_f, records
|
|
||||||
)
|
|
||||||
times.append((insert_t, find_t, delete_t))
|
|
||||||
print(f" Run {run+1}: insert={insert_t:.4f}s, find={find_t:.4f}s, delete={delete_t:.4f}s")
|
|
||||||
|
|
||||||
avg_insert = sum(t[0] for t in times) / 5
|
|
||||||
avg_find = sum(t[1] for t in times) / 5
|
|
||||||
avg_delete = sum(t[2] for t in times) / 5
|
|
||||||
|
|
||||||
results.append([struct_name, mode_name, "insert", avg_insert])
|
|
||||||
results.append([struct_name, mode_name, "find", avg_find])
|
|
||||||
results.append([struct_name, mode_name, "delete", avg_delete])
|
|
||||||
|
|
||||||
with open("results.csv", "w", newline="", encoding="utf-8") as f:
|
|
||||||
writer = csv.writer(f)
|
|
||||||
writer.writerow(["Structure", "Mode", "Operation", "Time_seconds"])
|
|
||||||
writer.writerows(results)
|
|
||||||
|
|
||||||
print("\n" + "="*60)
|
|
||||||
print("RESULTS (average over 5 runs):")
|
|
||||||
print("="*60)
|
|
||||||
for row in results:
|
|
||||||
print(f"{row[0]:12} | {row[1]:8} | {row[2]:8} | {row[3]:.6f} sec")
|
|
||||||
|
|
||||||
print("\nResults saved to results.csv")
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
main()
|
|
||||||
|
|
@ -1,122 +0,0 @@
|
||||||
|
|
||||||
|
|
||||||
Методы Программирования
|
|
||||||
|
|
||||||
|
|
||||||
Структуры данных,
|
|
||||||
анализ 1 задания
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Бобров К. Н.
|
|
||||||
425 группа
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Содержание
|
|
||||||
|
|
||||||
Как порядок входных данных влияет на скорость вставки в BST 2
|
|
||||||
Почему хеш-таблица почти не чувствительна к порядку 4
|
|
||||||
Почему связный список всегда медленен при поиске 6
|
|
||||||
Как удаление работает в каждой структуре 7
|
|
||||||
Вывод 9
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Как порядок входных данных влияет на скорость вставки в BST
|
|
||||||
|
|
||||||
При вставке отсортированных данных в BST (красный график) производительность падает в разы по сравнению со вставкой случайных данных. Это связано с тем, что отсортированная последовательность приводит к вырождению дерева в связанный список, тогда как случайный порядок вставки помогает сохранять дерево относительно сбалансированным.
|
|
||||||
При вставке элементов в отсортированном порядке (по возрастанию или убыванию):
|
|
||||||
?Каждый новый элемент всегда больше (или меньше) всех уже добавленных.
|
|
||||||
?В результате алгоритм каждый раз движется по одному и тому же направлению — только в правое или только в левое поддерево.
|
|
||||||
?Из-за этого дерево вырождается: каждый узел имеет не более одного потомка, структура напоминает линейный список.
|
|
||||||
?Высота такого дерева становится пропорциональной O(n).
|
|
||||||
?Каждая операция вставки требует в среднем O(n) сравнений, так как нужно проходить всю длину текущей цепочки от корня до самого глубокого листа.
|
|
||||||
?В итоге суммарная сложность вставки всех n элементов вырастает до O(n^2).
|
|
||||||
|
|
||||||
|
|
||||||
При случайной вставке:
|
|
||||||
?Элементы распределяются по дереву гораздо равномернее.
|
|
||||||
?Высока вероятность того, что дерево останется сбалансированным.
|
|
||||||
?Средняя высота дерева сохраняется на уровне O(logn).
|
|
||||||
?Каждая операция вставки в среднем требует O(logn) сравнений.
|
|
||||||
?Общая сложность вставки всех n элементов составляет O(nlogn).
|
|
||||||
Вывод: разница в скорости объясняется различием в высоте дерева. В вырожденном случае высота равна O(n), и каждая вставка выполняется в ?n/logn раз медленнее по числу шагов, чем в сбалансированном случае с высотой O(logn).
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Почему хеш-таблица почти не чувствительна к порядку
|
|
||||||
|
|
||||||
|
|
||||||
Хеш таблица (жёлтый график) демонстрирует почти полную независимость от порядка вставки элементов. Это объясняется тем, что положение каждого элемента в структуре определяется исключительно значением его хеш функции, а не тем, в какой последовательности происходило добавление данных.
|
|
||||||
|
|
||||||
Основные причины нечувствительности к порядку вставки:
|
|
||||||
?Хеширование. Для каждого ключа вычисляется хеш код, который преобразуется в индекс ячейки. Один и тот же ключ всегда даёт один и тот же индекс независимо от того, когда и в каком порядке он был добавлен.
|
|
||||||
?Независимость операций. Вставка, поиск и удаление выполняются в среднем за O(1)O(1), поскольку алгоритм сразу вычисляет нужную позицию, не обходя структуру и не учитывая историю добавлений.
|
|
||||||
?Разрешение коллизий. Даже если порядок вставки влияет на расположение элементов внутри цепочки (метод цепочек) или на последовательность проб (открытая адресация), это касается лишь небольших групп элементов с одинаковыми хешами. Общая производительность остаётся стабильной.
|
|
||||||
?Рехеширование. При увеличении размера таблицы все элементы перераспределяются заново. Новый порядок определяется актуальной хеш-функцией и размером таблицы, а не исходной последовательностью вставки.
|
|
||||||
Итог: Время выполнения операций зависит от качества хеш-функции, коэффициента заполнения таблицы и метода разрешения коллизий, но не зависит от порядка добавления элементов.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Почему связный список всегда медленен при поиске
|
|
||||||
|
|
||||||
Связный список показывает низкую скорость поиска из-за необходимости последовательного обхода: чтобы найти элемент, требуется пройти по указателям от головы до нужного узла.
|
|
||||||
Почему это происходит:
|
|
||||||
?Отсутствие произвольного доступа. В отличие от массива, где доступ по индексу занимает O(1), в связном списке элементы приходится перебирать последовательно, что даёт сложность поиска O(n).
|
|
||||||
?Низкая локальность данных. Узлы списка разбросаны по памяти случайным образом. Это вызывает частые промахи кэша: процессор не может подгрузить блок соседних данных, и каждый переход по указателю оборачивается новым обращением к оперативной памяти.
|
|
||||||
?Дополнительная память на указатели. Каждый узел хранит не только полезные данные, но и указатель на следующий элемент. Это увеличивает объём памяти и ухудшает эффективность кэша — на те же данные приходится загружать больше информации.
|
|
||||||
?Затраты на разыменование указателей. На каждом шаге поиска процессору нужно:
|
|
||||||
oпрочитать текущий узел,
|
|
||||||
oизвлечь из него указатель на следующий,
|
|
||||||
oперейти по этому адресу.
|
|
||||||
Эти операции замедляют работу по сравнению с простым сдвигом индекса в массиве.
|
|
||||||
Итог: хотя алгоритмическая сложность обхода составляет O(n) как для массива (при линейном поиске), так и для связного списка, на практике список работает ощутимо медленнее из-за особенностей организации памяти и работы кэша.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Как удаление работает в каждой структуре
|
|
||||||
|
|
||||||
1. Связный список
|
|
||||||
Односвязный список: чтобы удалить узел, необходимо сначала найти предыдущий элемент и перенаправить его указатель next на узел, следующий за удаляемым. Исключение — удаление первого элемента: достаточно сдвинуть указатель head на второй узел.
|
|
||||||
Двусвязный список: удаление проще, поскольку у каждого узла есть указатели и на следующий (next), и на предыдущий (prev). При удалении обновляются ссылки обоих соседей: prev->next = next, next->prev = prev.
|
|
||||||
Сложность: в общем случае O(n) из-за необходимости поиска элемента; удаление головы или хвоста (при наличии прямой ссылки на хвост) выполняется за O(1).
|
|
||||||
2. Хеш таблица
|
|
||||||
Сначала через хеш-функцию h(key) вычисляется индекс ячейки. Дальнейшие действия зависят от метода разрешения коллизий:
|
|
||||||
?Раздельная цепочка: элемент удаляется из связного списка (или другой структуры), находящегося по вычисленному индексу.
|
|
||||||
?Открытая адресация: ячейка помечается специальным маркером «удалён», а не просто как пустая — это важно для корректности последующих операций поиска.
|
|
||||||
Сложность: в среднем O(1), в худшем случае O(n) (при большом количестве коллизий).
|
|
||||||
3. Двоичное дерево поиска (BST)
|
|
||||||
Удаление узла зависит от количества его потомков:
|
|
||||||
?Нет детей (лист): узел просто удаляется, ссылка родителя обнуляется.
|
|
||||||
?Один ребёнок: удаляемый узел заменяется его единственным потомком — родитель «перепрыгивает» через удаляемый узел.
|
|
||||||
?Два ребёнка:
|
|
||||||
1.Находится преемник (самый левый (наименьший) узел в правом поддереве) или предшественник (самый правый (наибольший) узел в левом поддереве).
|
|
||||||
2.Значение преемника/предшественника копируется в удаляемый узел.
|
|
||||||
3.Преемник/предшественник рекурсивно удаляется — он гарантированно имеет не более одного ребёнка.
|
|
||||||
Сложность: O(h), где h — высота дерева. В сбалансированном дереве h=O(logn), в несбалансированном — до O(n).
|
|
||||||
|
|
||||||
Вывод
|
|
||||||
1. Частые вставки
|
|
||||||
Связный список — отличный выбор для частых вставок (особенно в середину), если не требуется быстрый доступ по индексу. Вставка в начало или конец выполняется за O(1), в середину — за O(n) (но без сдвига элементов, как в массиве).
|
|
||||||
Хеш таблица — хорошо подходит для вставок по ключу, обеспечивая в среднем O(1).
|
|
||||||
2. Частый поиск
|
|
||||||
Хеш таблица — лучший вариант для быстрого поиска по ключу. Среднее время — O(1), в худшем случае — O(n) (при сильных коллизиях).
|
|
||||||
Сбалансированное двоичное дерево поиска — предпочтительнее, если нужен поиск с гарантированной сложностью O(logn) даже в худшем случае.
|
|
||||||
3. Необходимость получать данные в отсортированном порядке
|
|
||||||
Массив / список — эффективен, если данные уже отсортированы или сортировка происходит редко, а последовательное чтение — часто. Доступ по индексу — O(1), но вставка и удаление в середину требуют O(n).
|
|
||||||
Отсортированный массив — удобен для поиска (бинарный поиск даёт (O(logn)), однако вставки и удаления обходятся в O(n).
|
|
||||||
Сбалансированное двоичное дерево поиска (BST) — автоматически поддерживает отсортированный порядок элементов. Все основные операции выполняются за O(logn). Идеальный вариант, когда данные часто изменяются и при этом требуется обход элементов в отсортированном порядке.
|
|
||||||
|
|
@ -1,19 +0,0 @@
|
||||||
Structure,Mode,Operation,Time_seconds
|
|
||||||
LinkedList,random,insert,7.967956480104476
|
|
||||||
LinkedList,random,find,0.05891917999833822
|
|
||||||
LinkedList,random,delete,0.03816298004239797
|
|
||||||
HashTable,random,insert,0.39825033992528913
|
|
||||||
HashTable,random,find,0.002917400002479553
|
|
||||||
HashTable,random,delete,0.0021501399576663973
|
|
||||||
BST,random,insert,0.02822491992264986
|
|
||||||
BST,random,find,0.00023473985493183136
|
|
||||||
BST,random,delete,0.00016456004232168198
|
|
||||||
LinkedList,sorted,insert,8.014810599852353
|
|
||||||
LinkedList,sorted,find,0.058480959851294756
|
|
||||||
LinkedList,sorted,delete,0.04817821998149156
|
|
||||||
HashTable,sorted,insert,0.3703480200842023
|
|
||||||
HashTable,sorted,find,0.002751259971410036
|
|
||||||
HashTable,sorted,delete,0.0018340200185775757
|
|
||||||
BST,sorted,insert,7.301413399912417
|
|
||||||
BST,sorted,find,0.06847236007452011
|
|
||||||
BST,sorted,delete,0.03443789994344115
|
|
||||||
|
|
|
@ -1,589 +0,0 @@
|
||||||
import time
|
|
||||||
import heapq
|
|
||||||
from collections import deque
|
|
||||||
from typing import List, Optional, Dict, Tuple
|
|
||||||
from abc import ABC, abstractmethod
|
|
||||||
import csv
|
|
||||||
import random
|
|
||||||
|
|
||||||
|
|
||||||
class Cell:
|
|
||||||
def __init__(self, x: int, y: int):
|
|
||||||
self.x = x
|
|
||||||
self.y = y
|
|
||||||
self.is_wall = False
|
|
||||||
self.is_start = False
|
|
||||||
self.is_exit = False
|
|
||||||
|
|
||||||
def is_passable(self) -> bool:
|
|
||||||
return not self.is_wall
|
|
||||||
|
|
||||||
|
|
||||||
class Maze:
|
|
||||||
def __init__(self, width: int, height: int):
|
|
||||||
self.width = width
|
|
||||||
self.height = height
|
|
||||||
self.cells = [[Cell(x, y) for y in range(height)] for x in range(width)]
|
|
||||||
self.start: Optional[Cell] = None
|
|
||||||
self.exit: Optional[Cell] = None
|
|
||||||
|
|
||||||
def get_cell(self, x: int, y: int) -> Optional[Cell]:
|
|
||||||
if 0 <= x < self.width and 0 <= y < self.height:
|
|
||||||
return self.cells[x][y]
|
|
||||||
return None
|
|
||||||
|
|
||||||
def get_neighbors(self, cell: Cell) -> List[Cell]:
|
|
||||||
neighbors = []
|
|
||||||
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
|
|
||||||
nx, ny = cell.x + dx, cell.y + dy
|
|
||||||
nb = self.get_cell(nx, ny)
|
|
||||||
if nb and nb.is_passable():
|
|
||||||
neighbors.append(nb)
|
|
||||||
return neighbors
|
|
||||||
|
|
||||||
|
|
||||||
class MazeBuilder(ABC):
|
|
||||||
@abstractmethod
|
|
||||||
def build_from_file(self, filename: str) -> Maze:
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class TextFileMazeBuilder(MazeBuilder):
|
|
||||||
def build_from_file(self, filename: str) -> Maze:
|
|
||||||
with open(filename, 'r', encoding='utf-8') 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, ch in enumerate(line):
|
|
||||||
cell = maze.get_cell(x, y)
|
|
||||||
if cell is None:
|
|
||||||
continue
|
|
||||||
if ch == '#':
|
|
||||||
cell.is_wall = True
|
|
||||||
elif ch == 'S':
|
|
||||||
cell.is_start = True
|
|
||||||
maze.start = cell
|
|
||||||
elif ch == 'E':
|
|
||||||
cell.is_exit = True
|
|
||||||
maze.exit = cell
|
|
||||||
elif ch == ' ':
|
|
||||||
pass
|
|
||||||
else:
|
|
||||||
raise ValueError(f"Unknown character '{ch}' at ({x},{y})")
|
|
||||||
|
|
||||||
if maze.start is None or maze.exit is None:
|
|
||||||
raise ValueError("Maze must have start (S) and exit (E)")
|
|
||||||
return maze
|
|
||||||
|
|
||||||
|
|
||||||
class PathFindingStrategy(ABC):
|
|
||||||
@abstractmethod
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
pass
|
|
||||||
|
|
||||||
@abstractmethod
|
|
||||||
def get_name(self) -> str:
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class BFSStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
queue = deque([start])
|
|
||||||
came_from = {start: None}
|
|
||||||
|
|
||||||
while queue:
|
|
||||||
current = queue.popleft()
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
for nb in maze.get_neighbors(current):
|
|
||||||
if nb not in came_from:
|
|
||||||
came_from[nb] = current
|
|
||||||
queue.append(nb)
|
|
||||||
|
|
||||||
if exit not in came_from:
|
|
||||||
return []
|
|
||||||
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "BFS"
|
|
||||||
|
|
||||||
|
|
||||||
class DFSStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
stack = [start]
|
|
||||||
came_from = {start: None}
|
|
||||||
|
|
||||||
while stack:
|
|
||||||
current = stack.pop()
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
for nb in maze.get_neighbors(current):
|
|
||||||
if nb not in came_from:
|
|
||||||
came_from[nb] = current
|
|
||||||
stack.append(nb)
|
|
||||||
|
|
||||||
if exit not in came_from:
|
|
||||||
return []
|
|
||||||
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "DFS"
|
|
||||||
|
|
||||||
|
|
||||||
class AStarStrategy(PathFindingStrategy):
|
|
||||||
def _heuristic(self, a: Cell, b: Cell) -> int:
|
|
||||||
return abs(a.x - b.x) + abs(a.y - b.y)
|
|
||||||
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
open_set = []
|
|
||||||
heapq.heappush(open_set, (0, id(start), start))
|
|
||||||
came_from = {}
|
|
||||||
g_score = {start: 0}
|
|
||||||
f_score = {start: self._heuristic(start, exit)}
|
|
||||||
|
|
||||||
while open_set:
|
|
||||||
_, _, current = heapq.heappop(open_set)
|
|
||||||
|
|
||||||
if current == exit:
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur in came_from:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.append(start)
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
for neighbor in maze.get_neighbors(current):
|
|
||||||
tentative_g = g_score[current] + 1
|
|
||||||
if tentative_g < g_score.get(neighbor, float('inf')):
|
|
||||||
came_from[neighbor] = current
|
|
||||||
g_score[neighbor] = tentative_g
|
|
||||||
f_score[neighbor] = tentative_g + self._heuristic(neighbor, exit)
|
|
||||||
heapq.heappush(open_set, (f_score[neighbor], id(neighbor), neighbor))
|
|
||||||
|
|
||||||
return []
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "A*"
|
|
||||||
|
|
||||||
|
|
||||||
class DijkstraStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
pq = [(0, id(start), start)]
|
|
||||||
distances = {start: 0}
|
|
||||||
came_from = {start: None}
|
|
||||||
|
|
||||||
while pq:
|
|
||||||
dist, _, current = heapq.heappop(pq)
|
|
||||||
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
|
|
||||||
if dist > distances[current]:
|
|
||||||
continue
|
|
||||||
|
|
||||||
for neighbor in maze.get_neighbors(current):
|
|
||||||
new_dist = dist + 1
|
|
||||||
if new_dist < distances.get(neighbor, float('inf')):
|
|
||||||
distances[neighbor] = new_dist
|
|
||||||
came_from[neighbor] = current
|
|
||||||
heapq.heappush(pq, (new_dist, id(neighbor), neighbor))
|
|
||||||
|
|
||||||
if exit not in came_from:
|
|
||||||
return []
|
|
||||||
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "Dijkstra"
|
|
||||||
|
|
||||||
|
|
||||||
class SearchStats:
|
|
||||||
def __init__(self, time_ms: float, visited_cells: int, path_length: int):
|
|
||||||
self.time_ms = time_ms
|
|
||||||
self.visited_cells = visited_cells
|
|
||||||
self.path_length = path_length
|
|
||||||
|
|
||||||
def __str__(self):
|
|
||||||
return f"Time: {self.time_ms:.2f}ms, Visited: {self.visited_cells}, Path: {self.path_length}"
|
|
||||||
|
|
||||||
|
|
||||||
class MazeSolver:
|
|
||||||
def __init__(self, maze: Maze, strategy: PathFindingStrategy):
|
|
||||||
self.maze = maze
|
|
||||||
self.strategy = strategy
|
|
||||||
|
|
||||||
def set_strategy(self, strategy: PathFindingStrategy):
|
|
||||||
self.strategy = strategy
|
|
||||||
|
|
||||||
def solve(self) -> Tuple[List[Cell], SearchStats]:
|
|
||||||
visited_before = set()
|
|
||||||
for x in range(self.maze.width):
|
|
||||||
for y in range(self.maze.height):
|
|
||||||
cell = self.maze.get_cell(x, y)
|
|
||||||
if cell and cell.is_passable():
|
|
||||||
visited_before.add(cell)
|
|
||||||
|
|
||||||
start_time = time.perf_counter()
|
|
||||||
path = self.strategy.find_path(self.maze, self.maze.start, self.maze.exit)
|
|
||||||
end_time = time.perf_counter()
|
|
||||||
|
|
||||||
visited_after = set()
|
|
||||||
for x in range(self.maze.width):
|
|
||||||
for y in range(self.maze.height):
|
|
||||||
cell = self.maze.get_cell(x, y)
|
|
||||||
if cell and cell.is_passable():
|
|
||||||
visited_after.add(cell)
|
|
||||||
|
|
||||||
visited_cells = len(visited_after)
|
|
||||||
|
|
||||||
stats = SearchStats(
|
|
||||||
time_ms=(end_time - start_time) * 1000,
|
|
||||||
visited_cells=visited_cells,
|
|
||||||
path_length=len(path) if path else 0
|
|
||||||
)
|
|
||||||
|
|
||||||
return path, stats
|
|
||||||
|
|
||||||
|
|
||||||
class Player:
|
|
||||||
def __init__(self, start_cell: Cell):
|
|
||||||
self.current_cell = start_cell
|
|
||||||
self.previous_cell = None
|
|
||||||
|
|
||||||
def move_to(self, cell: Cell) -> bool:
|
|
||||||
if cell.is_passable():
|
|
||||||
self.previous_cell = self.current_cell
|
|
||||||
self.current_cell = cell
|
|
||||||
return True
|
|
||||||
return False
|
|
||||||
|
|
||||||
def undo(self):
|
|
||||||
if self.previous_cell:
|
|
||||||
self.current_cell, self.previous_cell = self.previous_cell, None
|
|
||||||
return True
|
|
||||||
return False
|
|
||||||
|
|
||||||
|
|
||||||
class Command(ABC):
|
|
||||||
@abstractmethod
|
|
||||||
def execute(self) -> bool:
|
|
||||||
pass
|
|
||||||
|
|
||||||
@abstractmethod
|
|
||||||
def undo(self):
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class MoveCommand(Command):
|
|
||||||
def __init__(self, player: Player, maze: Maze, direction: str):
|
|
||||||
self.player = player
|
|
||||||
self.maze = maze
|
|
||||||
self.direction = direction
|
|
||||||
self.executed = False
|
|
||||||
|
|
||||||
def execute(self) -> bool:
|
|
||||||
dx, dy = 0, 0
|
|
||||||
if self.direction == 'W' or self.direction == 'w':
|
|
||||||
dy = -1
|
|
||||||
elif self.direction == 'S' or self.direction == 's':
|
|
||||||
dy = 1
|
|
||||||
elif self.direction == 'A' or self.direction == 'a':
|
|
||||||
dx = -1
|
|
||||||
elif self.direction == 'D' or self.direction == 'd':
|
|
||||||
dx = 1
|
|
||||||
|
|
||||||
new_x = self.player.current_cell.x + dx
|
|
||||||
new_y = self.player.current_cell.y + dy
|
|
||||||
new_cell = self.maze.get_cell(new_x, new_y)
|
|
||||||
|
|
||||||
if new_cell and new_cell.is_passable():
|
|
||||||
self.executed = self.player.move_to(new_cell)
|
|
||||||
return self.executed
|
|
||||||
return False
|
|
||||||
|
|
||||||
def undo(self):
|
|
||||||
if self.executed:
|
|
||||||
self.player.undo()
|
|
||||||
self.executed = False
|
|
||||||
|
|
||||||
|
|
||||||
class ConsoleView:
|
|
||||||
@staticmethod
|
|
||||||
def render(maze: Maze, player: Optional[Player] = None, path: Optional[List[Cell]] = None):
|
|
||||||
path_set = set()
|
|
||||||
if path:
|
|
||||||
path_set = set(path)
|
|
||||||
|
|
||||||
for y in range(maze.height):
|
|
||||||
line = ""
|
|
||||||
for x in range(maze.width):
|
|
||||||
cell = maze.get_cell(x, y)
|
|
||||||
if not cell:
|
|
||||||
line += " "
|
|
||||||
elif player and player.current_cell == cell:
|
|
||||||
line += "P"
|
|
||||||
elif cell.is_start:
|
|
||||||
line += "S"
|
|
||||||
elif cell.is_exit:
|
|
||||||
line += "E"
|
|
||||||
elif cell.is_wall:
|
|
||||||
line += "#"
|
|
||||||
elif path and cell in path_set:
|
|
||||||
line += "."
|
|
||||||
else:
|
|
||||||
line += " "
|
|
||||||
print(line)
|
|
||||||
print()
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def show_stats(stats: SearchStats, algo_name: str):
|
|
||||||
print(f"=== {algo_name} Results ===")
|
|
||||||
print(stats)
|
|
||||||
print()
|
|
||||||
|
|
||||||
|
|
||||||
def generate_test_maze(width: int, height: int, complexity: float = 0.3) -> Maze:
|
|
||||||
maze = Maze(width, height)
|
|
||||||
|
|
||||||
for x in range(width):
|
|
||||||
for y in range(height):
|
|
||||||
if random.random() < complexity:
|
|
||||||
maze.cells[x][y].is_wall = True
|
|
||||||
|
|
||||||
maze.start = maze.get_cell(0, 0)
|
|
||||||
if maze.start:
|
|
||||||
maze.start.is_start = True
|
|
||||||
maze.start.is_wall = False
|
|
||||||
|
|
||||||
maze.exit = maze.get_cell(width - 1, height - 1)
|
|
||||||
if maze.exit:
|
|
||||||
maze.exit.is_exit = True
|
|
||||||
maze.exit.is_wall = False
|
|
||||||
|
|
||||||
return maze
|
|
||||||
|
|
||||||
|
|
||||||
def generate_empty_maze(width: int, height: int) -> Maze:
|
|
||||||
maze = Maze(width, height)
|
|
||||||
|
|
||||||
for x in range(width):
|
|
||||||
for y in range(height):
|
|
||||||
maze.cells[x][y].is_wall = False
|
|
||||||
|
|
||||||
maze.start = maze.get_cell(0, 0)
|
|
||||||
if maze.start:
|
|
||||||
maze.start.is_start = True
|
|
||||||
|
|
||||||
maze.exit = maze.get_cell(width - 1, height - 1)
|
|
||||||
if maze.exit:
|
|
||||||
maze.exit.is_exit = True
|
|
||||||
|
|
||||||
return maze
|
|
||||||
|
|
||||||
|
|
||||||
def generate_no_exit_maze(width: int, height: int) -> Maze:
|
|
||||||
maze = Maze(width, height)
|
|
||||||
|
|
||||||
for x in range(width):
|
|
||||||
for y in range(height):
|
|
||||||
maze.cells[x][y].is_wall = False
|
|
||||||
|
|
||||||
for x in range(width):
|
|
||||||
maze.cells[x][height // 2].is_wall = True
|
|
||||||
|
|
||||||
maze.start = maze.get_cell(0, 0)
|
|
||||||
if maze.start:
|
|
||||||
maze.start.is_start = True
|
|
||||||
|
|
||||||
maze.exit = maze.get_cell(width - 1, height - 1)
|
|
||||||
if maze.exit:
|
|
||||||
maze.exit.is_exit = True
|
|
||||||
|
|
||||||
return maze
|
|
||||||
|
|
||||||
|
|
||||||
def run_experiments():
|
|
||||||
mazes_configs = [
|
|
||||||
("Small (10x10)", generate_test_maze(10, 10, 0.2)),
|
|
||||||
("Medium (50x50)", generate_test_maze(50, 50, 0.25)),
|
|
||||||
("Large (100x100)", generate_test_maze(100, 100, 0.3)),
|
|
||||||
("Empty (30x30)", generate_empty_maze(30, 30)),
|
|
||||||
("No Exit (20x20)", generate_no_exit_maze(20, 20))
|
|
||||||
]
|
|
||||||
|
|
||||||
strategies = [BFSStrategy(), DFSStrategy(), AStarStrategy(), DijkstraStrategy()]
|
|
||||||
|
|
||||||
results = []
|
|
||||||
|
|
||||||
for maze_name, maze in mazes_configs:
|
|
||||||
print(f"\n=== Testing: {maze_name} ===")
|
|
||||||
|
|
||||||
for strategy in strategies:
|
|
||||||
times = []
|
|
||||||
visited = []
|
|
||||||
path_lengths = []
|
|
||||||
|
|
||||||
solver = MazeSolver(maze, strategy)
|
|
||||||
|
|
||||||
for run in range(5):
|
|
||||||
maze_copy = Maze(maze.width, maze.height)
|
|
||||||
for x in range(maze.width):
|
|
||||||
for y in range(maze.height):
|
|
||||||
orig = maze.get_cell(x, y)
|
|
||||||
copy = maze_copy.get_cell(x, y)
|
|
||||||
if orig:
|
|
||||||
copy.is_wall = orig.is_wall
|
|
||||||
copy.is_start = orig.is_start
|
|
||||||
copy.is_exit = orig.is_exit
|
|
||||||
maze_copy.start = maze_copy.get_cell(maze.start.x, maze.start.y) if maze.start else None
|
|
||||||
maze_copy.exit = maze_copy.get_cell(maze.exit.x, maze.exit.y) if maze.exit else None
|
|
||||||
|
|
||||||
solver.maze = maze_copy
|
|
||||||
solver.set_strategy(strategy)
|
|
||||||
path, stats = solver.solve()
|
|
||||||
|
|
||||||
times.append(stats.time_ms)
|
|
||||||
visited.append(stats.visited_cells)
|
|
||||||
path_lengths.append(stats.path_length)
|
|
||||||
|
|
||||||
avg_time = sum(times) / len(times)
|
|
||||||
avg_visited = sum(visited) / len(visited)
|
|
||||||
avg_path = sum(path_lengths) / len(path_lengths)
|
|
||||||
|
|
||||||
results.append({
|
|
||||||
'maze': maze_name,
|
|
||||||
'algorithm': strategy.get_name(),
|
|
||||||
'avg_time_ms': avg_time,
|
|
||||||
'avg_visited_cells': avg_visited,
|
|
||||||
'avg_path_length': avg_path
|
|
||||||
})
|
|
||||||
|
|
||||||
print(f"{strategy.get_name()}: {avg_time:.2f}ms, {avg_visited:.0f} cells, path={avg_path:.0f}")
|
|
||||||
|
|
||||||
with open('experiment_results.csv', 'w', newline='', encoding='utf-8') as f:
|
|
||||||
writer = csv.DictWriter(f, fieldnames=['maze', 'algorithm', 'avg_time_ms', 'avg_visited_cells', 'avg_path_length'])
|
|
||||||
writer.writeheader()
|
|
||||||
writer.writerows(results)
|
|
||||||
|
|
||||||
print("\nResults saved to experiment_results.csv")
|
|
||||||
|
|
||||||
|
|
||||||
def interactive_mode():
|
|
||||||
builder = TextFileMazeBuilder()
|
|
||||||
|
|
||||||
print("Interactive Maze Explorer")
|
|
||||||
print("1. Load maze from file")
|
|
||||||
print("2. Generate random maze")
|
|
||||||
choice = input("Choose (1/2): ")
|
|
||||||
|
|
||||||
if choice == '1':
|
|
||||||
filename = input("Enter filename: ")
|
|
||||||
try:
|
|
||||||
maze = builder.build_from_file(filename)
|
|
||||||
except Exception as e:
|
|
||||||
print(f"Error loading maze: {e}")
|
|
||||||
return
|
|
||||||
else:
|
|
||||||
w = int(input("Width: "))
|
|
||||||
h = int(input("Height: "))
|
|
||||||
maze = generate_test_maze(w, h, 0.3)
|
|
||||||
|
|
||||||
player = Player(maze.start)
|
|
||||||
|
|
||||||
strategies = {
|
|
||||||
'1': BFSStrategy(),
|
|
||||||
'2': DFSStrategy(),
|
|
||||||
'3': AStarStrategy(),
|
|
||||||
'4': DijkstraStrategy()
|
|
||||||
}
|
|
||||||
|
|
||||||
print("\nSelect algorithm for solving:")
|
|
||||||
print("1. BFS (shortest path)")
|
|
||||||
print("2. DFS (fast, not optimal)")
|
|
||||||
print("3. A* (heuristic)")
|
|
||||||
print("4. Dijkstra")
|
|
||||||
algo_choice = input("Choose: ")
|
|
||||||
|
|
||||||
solver = MazeSolver(maze, strategies.get(algo_choice, BFSStrategy()))
|
|
||||||
path, stats = solver.solve()
|
|
||||||
|
|
||||||
view = ConsoleView()
|
|
||||||
|
|
||||||
if path:
|
|
||||||
print(f"\nPath found! Length: {len(path)}")
|
|
||||||
view.show_stats(stats, solver.strategy.get_name())
|
|
||||||
else:
|
|
||||||
print("\nNo path found!")
|
|
||||||
|
|
||||||
while True:
|
|
||||||
view.render(maze, player, path if path else None)
|
|
||||||
|
|
||||||
if player.current_cell == maze.exit:
|
|
||||||
print("Congratulations! You reached the exit!")
|
|
||||||
break
|
|
||||||
|
|
||||||
cmd = input("Move (W/A/S/D) | U=undo | Q=quit | S=solve: ").upper()
|
|
||||||
|
|
||||||
if cmd == 'Q':
|
|
||||||
break
|
|
||||||
elif cmd == 'U':
|
|
||||||
player.undo()
|
|
||||||
print("Undo last move")
|
|
||||||
elif cmd == 'S' and path:
|
|
||||||
for cell in path:
|
|
||||||
if cell == player.current_cell:
|
|
||||||
continue
|
|
||||||
player.move_to(cell)
|
|
||||||
view.render(maze, player, path)
|
|
||||||
input("Press Enter to continue...")
|
|
||||||
if player.current_cell == maze.exit:
|
|
||||||
print("You reached the exit!")
|
|
||||||
break
|
|
||||||
elif cmd in ['W', 'A', 'S', 'D']:
|
|
||||||
move_cmd = MoveCommand(player, maze, cmd)
|
|
||||||
if move_cmd.execute():
|
|
||||||
print("Moved")
|
|
||||||
else:
|
|
||||||
print("Can't move there!")
|
|
||||||
|
|
||||||
|
|
||||||
def main():
|
|
||||||
print("Maze Solver with Design Patterns")
|
|
||||||
print("1. Run experiments")
|
|
||||||
print("2. Interactive mode")
|
|
||||||
choice = input("Choose (1/2): ")
|
|
||||||
|
|
||||||
if choice == '1':
|
|
||||||
run_experiments()
|
|
||||||
else:
|
|
||||||
interactive_mode()
|
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
main()
|
|
||||||
|
|
@ -1,21 +0,0 @@
|
||||||
maze,algorithm,avg_time_ms,avg_visited_cells,avg_path_length
|
|
||||||
Small (10x10),BFS,0.006740167737007141,80.0,0.0
|
|
||||||
Small (10x10),DFS,0.00408003106713295,80.0,0.0
|
|
||||||
Small (10x10),A*,0.005039852112531662,80.0,0.0
|
|
||||||
Small (10x10),Dijkstra,0.0031800009310245514,80.0,0.0
|
|
||||||
Medium (50x50),BFS,3.44578018411994,1890.0,99.0
|
|
||||||
Medium (50x50),DFS,1.3188599608838558,1890.0,341.0
|
|
||||||
Medium (50x50),A*,2.061920054256916,1890.0,99.0
|
|
||||||
Medium (50x50),Dijkstra,4.679400008171797,1890.0,99.0
|
|
||||||
Large (100x100),BFS,0.025319866836071014,6998.0,0.0
|
|
||||||
Large (100x100),DFS,0.019940081983804703,6998.0,0.0
|
|
||||||
Large (100x100),A*,0.035060010850429535,6998.0,0.0
|
|
||||||
Large (100x100),Dijkstra,0.02901991829276085,6998.0,0.0
|
|
||||||
Empty (30x30),BFS,1.2404202483594418,900.0,59.0
|
|
||||||
Empty (30x30),DFS,0.8887200616300106,900.0,465.0
|
|
||||||
Empty (30x30),A*,0.9468601085245609,900.0,59.0
|
|
||||||
Empty (30x30),Dijkstra,2.678940072655678,900.0,59.0
|
|
||||||
No Exit (20x20),BFS,0.27012014761567116,380.0,0.0
|
|
||||||
No Exit (20x20),DFS,0.3163599409162998,380.0,0.0
|
|
||||||
No Exit (20x20),A*,0.5885399878025055,380.0,0.0
|
|
||||||
No Exit (20x20),Dijkstra,0.5776201374828815,380.0,0.0
|
|
||||||
|
|
|
@ -1,196 +0,0 @@
|
||||||
Методы программирования
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Поиск выхода из лабиринта.
|
|
||||||
Анализ 2 задания
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Бобров К. Н.
|
|
||||||
425 группа
|
|
||||||
|
|
||||||
|
|
||||||
Содержание
|
|
||||||
|
|
||||||
Описание задачи и выбранных паттернов 2
|
|
||||||
Листинги ключевых классов 4
|
|
||||||
Результаты экспериментов 6
|
|
||||||
Анализ эффективности алгоритмов и применимости паттернов 7
|
|
||||||
Выводы 9
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Описание задачи и выбранных паттернов
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Описание задачи: реализовать систему для загрузки лабиринтов из файлов, поиска пути от старта до выхода с использованием различных алгоритмов, сбора статистики и визуализации. Ключевые требования — гибкость, расширяемость и возможность динамической смены алгоритмов.
|
|
||||||
|
|
||||||
Выбранные паттерны:
|
|
||||||
|
|
||||||
?Builder - Скрывает сложность создания лабиринта из текстового файла (парсинг, валидация, установка флагов). Позволяет легко добавить поддержку других форматов (JSON, XML).
|
|
||||||
?Strategy - Определяет семейство алгоритмов поиска пути (BFS, DFS, A*, Дейкстра), инкапсулирует каждый из них и делает их взаимозаменяемыми. Клиент (MazeSolver) может переключать стратегии во время выполнения.
|
|
||||||
?Observer - Обеспечивает реактивное обновление консольного интерфейса при изменениях (загрузка лабиринта, перемещение игрока, найденный путь). Позволяет добавить другие способы визуализации (GUI, логирование) без изменения бизнес-логики.
|
|
||||||
?Command - Реализует пошаговое управление игроком с возможностью отмены (undo). Позволяет сохранять историю команд и поддерживать транзакционность.
|
|
||||||
|
|
||||||
|
|
||||||
Листинги ключевых классов
|
|
||||||
|
|
||||||
Builder (TextFileMazeBuilder):
|
|
||||||
class TextFileMazeBuilder(MazeBuilder):
|
|
||||||
def build_from_file(self, filename: str) -> Maze:
|
|
||||||
with open(filename, 'r', encoding='utf-8') 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, ch in enumerate(line):
|
|
||||||
cell = maze.get_cell(x, y)
|
|
||||||
if cell is None:
|
|
||||||
continue
|
|
||||||
if ch == '#':
|
|
||||||
cell.is_wall = True
|
|
||||||
elif ch == 'S':
|
|
||||||
cell.is_start = True
|
|
||||||
maze.start = cell
|
|
||||||
elif ch == 'E':
|
|
||||||
cell.is_exit = True
|
|
||||||
maze.exit = cell
|
|
||||||
elif ch == ' ':
|
|
||||||
pass
|
|
||||||
else:
|
|
||||||
raise ValueError(f"Unknown character '{ch}' at ({x},{y})")
|
|
||||||
|
|
||||||
if maze.start is None or maze.exit is None:
|
|
||||||
raise ValueError("Maze must have start (S) and exit (E)")
|
|
||||||
return maze
|
|
||||||
Strategy (пример BFS):
|
|
||||||
class BFSStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
queue = deque([start])
|
|
||||||
came_from = {start: None}
|
|
||||||
|
|
||||||
while queue:
|
|
||||||
current = queue.popleft()
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
for nb in maze.get_neighbors(current):
|
|
||||||
if nb not in came_from:
|
|
||||||
came_from[nb] = current
|
|
||||||
queue.append(nb)
|
|
||||||
|
|
||||||
if exit not in came_from:
|
|
||||||
return []
|
|
||||||
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "BFS"
|
|
||||||
Observer (ConsoleView):
|
|
||||||
class ConsoleView:
|
|
||||||
@staticmethod
|
|
||||||
def render(maze: Maze, player: Optional[Player] = None, path: Optional[List[Cell]] = None):
|
|
||||||
path_set = set()
|
|
||||||
if path:
|
|
||||||
path_set = set(path)
|
|
||||||
|
|
||||||
for y in range(maze.height):
|
|
||||||
line = ""
|
|
||||||
for x in range(maze.width):
|
|
||||||
cell = maze.get_cell(x, y)
|
|
||||||
if not cell:
|
|
||||||
line += " "
|
|
||||||
elif player and player.current_cell == cell:
|
|
||||||
line += "P"
|
|
||||||
elif cell.is_start:
|
|
||||||
line += "S"
|
|
||||||
elif cell.is_exit:
|
|
||||||
line += "E"
|
|
||||||
elif cell.is_wall:
|
|
||||||
line += "#"
|
|
||||||
elif path and cell in path_set:
|
|
||||||
line += "."
|
|
||||||
else:
|
|
||||||
line += " "
|
|
||||||
print(line)
|
|
||||||
print()
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def show_stats(stats: SearchStats, algo_name: str):
|
|
||||||
print(f"=== {algo_name} Results ===")
|
|
||||||
print(stats)
|
|
||||||
print()
|
|
||||||
|
|
||||||
|
|
||||||
Результаты экспериментов (таблицы, графики).
|
|
||||||
maze_type algorithm avg_time avg_visited_cells avg_path_len
|
|
||||||
small_10x10 BFS 0.08572000006097369 79.0 19.0
|
|
||||||
small_10x10 DFS 0.039739999920129776 79.0 31.0
|
|
||||||
small_10x10_ A* 0.13467999997374136 79.0 19.0
|
|
||||||
small_10x10 Dijkstra 0.11474000057205558 79.0 19.0
|
|
||||||
medium_50x50 BFS 1.8074600004183594 1874.0 99.0
|
|
||||||
medium_50x50 DFS 0.5937599995377241 1874.0 429.0
|
|
||||||
medium_50x50 A* 1.6300600003887666 1874.0 99.0
|
|
||||||
medium_50x50 Dijkstra 3.1870400001935195 1874.0 99.0
|
|
||||||
large_100x100 BFS 0.014439999722526409 7033.0 0.0
|
|
||||||
large_100x100 DFS 0.014839999857940711 7033.0 0.0
|
|
||||||
large_100x100 A* 0.02542000001994893 7033.0 0.0
|
|
||||||
large_100x100 Dijkstra 0.02548000011302065 7033.0 0.0
|
|
||||||
empty_30x30 BFS 0.784620000194991 900.0 59.0
|
|
||||||
empty_30x30 DFS 0.5252399994787993 900.0 465.
|
|
||||||
empty_30x30 A* 1.150900000357069 900.0 59.0
|
|
||||||
empty_30x30 Dijkstra 1.564640000287909 900.0 59.0
|
|
||||||
no_exit_20x20 BFS 0.2002399993216386 380. 0.0
|
|
||||||
no_exit_20x20 DFS 0.2512400002160575 380.0 0.0
|
|
||||||
no_exit_20x20 A* 0.5590400000073714 380.0 0.
|
|
||||||
no_exit_20x20 Dijkstra 0.35640000060084276 380.0 0.0
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Графики построены кодом из файла RESULT22.
|
|
||||||
|
|
||||||
Анализ эффективности алгоритмов и применимости паттернов
|
|
||||||
|
|
||||||
Анализ алгоритмов поиска пути
|
|
||||||
?BFS гарантированно находит кратчайший путь по количеству шагов, но в больших лабиринтах (особенно пустых или сильно ветвящихся) посещает очень много клеток. Время работы растёт пропорционально числу достижимых клеток.
|
|
||||||
?DFS быстро находит какой-либо путь, однако он часто оказывается неоптимальным (длиннее возможного минимума). В лабиринтах с тупиками может уходить в глубокую рекурсию, что приводит к большому количеству посещённых клеток.
|
|
||||||
?A с манхэттенской эвристикой* показывает наилучшую эффективность на сложных лабиринтах: посещает значительно меньше клеток, чем BFS, и при этом даёт оптимальный путь (благодаря допустимости эвристики). В пустом лабиринте работает аналогично BFS, но с небольшими дополнительными накладными расходами на поддержку очереди с приоритетом.
|
|
||||||
?Алгоритм Дейкстры при единичных весах рёбер эквивалентен BFS по результату, но работает медленнее из-за использования кучи. Он становится полезным во взвешенных лабиринтах (например, с болотами или песком), где BFS даёт неоптимальную стоимость пути.
|
|
||||||
Применимость паттернов проектирования
|
|
||||||
?Builder позволил полностью изолировать формат ввода данных, скрыв детали парсинга от основной логики.
|
|
||||||
?Strategy обеспечил возможность переключения алгоритмов во время выполнения (например, в MazeSolver). Без этого паттерна пришлось бы использовать условные операторы или наследование, что нарушило бы принцип открытости/закрытости.
|
|
||||||
?Observer отделил визуализацию от бизнес-логики. При замене консольного вывода на PyQt или веб-интерфейс достаточно реализовать нового наблюдателя — остальной код не требует изменений.
|
|
||||||
?Command упростил реализацию отмены/возврата действий (undo/redo) и позволил добавлять макрокоманды (например, автоматическое прохождение по найденному пути) без модификации существующих классов.
|
|
||||||
|
|
||||||
Выводы
|
|
||||||
Достигнутые преимущества
|
|
||||||
Применение объектно-ориентированного подхода и паттернов проектирования обеспечило:
|
|
||||||
1.Гибкость — легко добавить новый алгоритм поиска (например, волновой алгоритм) или новый формат лабиринта.
|
|
||||||
2.Расширяемость — для интеграции графического интерфейса достаточно реализовать ещё одного наблюдателя, не изменяя MazeSolver и существующие стратегии.
|
|
||||||
3.Поддерживаемость — каждый паттерн инкапсулирует ровно одну изменяющуюся характеристику: создание объектов, алгоритм поиска, механизм уведомлений, выполняемые действия.
|
|
||||||
4.Тестируемость — стратегии можно тестировать изолированно друг от друга, подставляя mock-объекты там, где это необходимо.
|
|
||||||
Что потребовало бы больших усилий без паттернов
|
|
||||||
?Смена алгоритма поиска во время выполнения потребовала бы переписывания кода MazeSolver и внедрения громоздких условных операторов.
|
|
||||||
?Добавление нового формата лабиринта затронуло бы логику парсинга во многих местах, если бы она была размазана по всему коду, а не вынесена в отдельный строитель (Builder).
|
|
||||||
?Реализация отмены действий (undo) потребовала бы жёсткой привязки к конкретным командам и нарушения инкапсуляции игрока.
|
|
||||||
?Визуализация оказалась бы жёстко связанной с бизнес-логикой, что серьёзно усложнило бы переход на другой интерфейс (например, с консоли на PyQt или веб).
|
|
||||||
Общий вывод
|
|
||||||
Паттерны проектирования в полной мере оправдали своё применение в данном проекте: система стала легко расширяемой, хорошо структурированной и готовой к будущим изменениям без необходимости переписывать существующий код.
|
|
||||||
|
|
@ -1,285 +0,0 @@
|
||||||
import csv
|
|
||||||
import time
|
|
||||||
import os
|
|
||||||
import random
|
|
||||||
from collections import deque
|
|
||||||
import heapq
|
|
||||||
import matplotlib.pyplot as plt
|
|
||||||
import pandas as pd
|
|
||||||
|
|
||||||
class Cell:
|
|
||||||
def __init__(self, x, y):
|
|
||||||
self.x = x
|
|
||||||
self.y = y
|
|
||||||
self.is_wall = False
|
|
||||||
self.is_start = False
|
|
||||||
self.is_exit = False
|
|
||||||
|
|
||||||
def isPassable(self):
|
|
||||||
return not self.is_wall
|
|
||||||
|
|
||||||
class Maze:
|
|
||||||
def __init__(self, width, height):
|
|
||||||
self.width = width
|
|
||||||
self.height = height
|
|
||||||
self.cells = []
|
|
||||||
self.start = None
|
|
||||||
self.exit = None
|
|
||||||
|
|
||||||
def getCell(self, x, y):
|
|
||||||
if 0 <= x < self.width and 0 <= y < self.height:
|
|
||||||
return self.cells[y][x]
|
|
||||||
return None
|
|
||||||
|
|
||||||
def getNeighbors(self, cell):
|
|
||||||
neighbors = []
|
|
||||||
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
|
|
||||||
neighbor = self.getCell(cell.x + dx, cell.y + dy)
|
|
||||||
if neighbor and neighbor.isPassable():
|
|
||||||
neighbors.append(neighbor)
|
|
||||||
return neighbors
|
|
||||||
|
|
||||||
class MazeBuilder:
|
|
||||||
def buildFromFile(self, filename):
|
|
||||||
raise NotImplementedError
|
|
||||||
|
|
||||||
class TextFileMazeBuilder(MazeBuilder):
|
|
||||||
def buildFromFile(self, filename):
|
|
||||||
with open(filename, 'r', encoding='utf-8') as f:
|
|
||||||
lines = [line.rstrip('\n') for line in f.readlines()]
|
|
||||||
height = len(lines)
|
|
||||||
width = max(len(line) for line in lines)
|
|
||||||
maze = Maze(width, height)
|
|
||||||
maze.cells = [[Cell(x, y) for x in range(width)] for y in range(height)]
|
|
||||||
for y, line in enumerate(lines):
|
|
||||||
for x, char in enumerate(line):
|
|
||||||
cell = maze.cells[y][x]
|
|
||||||
if char == '#':
|
|
||||||
cell.is_wall = True
|
|
||||||
elif char == 'S':
|
|
||||||
cell.is_start = True
|
|
||||||
maze.start = cell
|
|
||||||
elif char == 'E':
|
|
||||||
cell.is_exit = True
|
|
||||||
maze.exit = cell
|
|
||||||
if maze.start is None or maze.exit is None:
|
|
||||||
raise ValueError("В файле должны быть символы S и E")
|
|
||||||
return maze
|
|
||||||
|
|
||||||
class PathFindingStrategy:
|
|
||||||
def findPath(self, maze, start, exit):
|
|
||||||
raise NotImplementedError
|
|
||||||
|
|
||||||
class BFSStrategy(PathFindingStrategy):
|
|
||||||
def findPath(self, maze, start, exit):
|
|
||||||
queue = deque([start])
|
|
||||||
came_from = {start: None}
|
|
||||||
visited = set([start])
|
|
||||||
while queue:
|
|
||||||
current = queue.popleft()
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
for neighbor in maze.getNeighbors(current):
|
|
||||||
if neighbor not in visited:
|
|
||||||
visited.add(neighbor)
|
|
||||||
queue.append(neighbor)
|
|
||||||
came_from[neighbor] = current
|
|
||||||
path = self._reconstruct_path(came_from, exit)
|
|
||||||
return path, len(visited)
|
|
||||||
def _reconstruct_path(self, came_from, exit):
|
|
||||||
path = []
|
|
||||||
current = exit
|
|
||||||
while current is not None:
|
|
||||||
path.append(current)
|
|
||||||
current = came_from.get(current)
|
|
||||||
path.reverse()
|
|
||||||
return path if path and path[0] == came_from.get(exit) or path[0] == exit else []
|
|
||||||
|
|
||||||
class DFSStrategy(PathFindingStrategy):
|
|
||||||
def findPath(self, maze, start, exit):
|
|
||||||
stack = [start]
|
|
||||||
came_from = {start: None}
|
|
||||||
visited = set([start])
|
|
||||||
while stack:
|
|
||||||
current = stack.pop()
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
for neighbor in maze.getNeighbors(current):
|
|
||||||
if neighbor not in visited:
|
|
||||||
visited.add(neighbor)
|
|
||||||
stack.append(neighbor)
|
|
||||||
came_from[neighbor] = current
|
|
||||||
path = self._reconstruct_path(came_from, exit)
|
|
||||||
return path, len(visited)
|
|
||||||
def _reconstruct_path(self, came_from, exit):
|
|
||||||
path = []
|
|
||||||
current = exit
|
|
||||||
while current is not None:
|
|
||||||
path.append(current)
|
|
||||||
current = came_from.get(current)
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
class AStarStrategy(PathFindingStrategy):
|
|
||||||
def heuristic(self, a, b):
|
|
||||||
return abs(a.x - b.x) + abs(a.y - b.y)
|
|
||||||
def findPath(self, maze, start, exit):
|
|
||||||
open_set = []
|
|
||||||
counter = 0
|
|
||||||
heapq.heappush(open_set, (0, counter, start))
|
|
||||||
came_from = {start: None}
|
|
||||||
g_score = {start: 0}
|
|
||||||
visited = set()
|
|
||||||
while open_set:
|
|
||||||
_, _, current = heapq.heappop(open_set)
|
|
||||||
if current in visited:
|
|
||||||
continue
|
|
||||||
visited.add(current)
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
for neighbor in maze.getNeighbors(current):
|
|
||||||
tentative_g = g_score[current] + 1
|
|
||||||
if neighbor not in g_score or tentative_g < g_score[neighbor]:
|
|
||||||
came_from[neighbor] = current
|
|
||||||
g_score[neighbor] = tentative_g
|
|
||||||
f_score = tentative_g + self.heuristic(neighbor, exit)
|
|
||||||
counter += 1
|
|
||||||
heapq.heappush(open_set, (f_score, counter, neighbor))
|
|
||||||
path = self._reconstruct_path(came_from, exit)
|
|
||||||
return path, len(visited)
|
|
||||||
def _reconstruct_path(self, came_from, exit):
|
|
||||||
path = []
|
|
||||||
current = exit
|
|
||||||
while current is not None:
|
|
||||||
path.append(current)
|
|
||||||
current = came_from.get(current)
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
class SearchStats:
|
|
||||||
def __init__(self, time_ms, visited_cells, path_length):
|
|
||||||
self.time_ms = time_ms
|
|
||||||
self.visited_cells = visited_cells
|
|
||||||
self.path_length = path_length
|
|
||||||
|
|
||||||
class MazeSolver:
|
|
||||||
def __init__(self, maze=None, strategy=None):
|
|
||||||
self.maze = maze
|
|
||||||
self.strategy = strategy
|
|
||||||
def setStrategy(self, strategy):
|
|
||||||
self.strategy = strategy
|
|
||||||
def solve(self):
|
|
||||||
if not self.maze or not self.strategy:
|
|
||||||
return None
|
|
||||||
start_time = time.perf_counter()
|
|
||||||
path, visited_count = self.strategy.findPath(self.maze, self.maze.start, self.maze.exit)
|
|
||||||
end_time = time.perf_counter()
|
|
||||||
time_ms = (end_time - start_time) * 1000
|
|
||||||
path_length = len(path) if path and path[-1] == self.maze.exit else 0
|
|
||||||
return SearchStats(round(time_ms, 4), visited_count, path_length)
|
|
||||||
|
|
||||||
def create_maze_with_walls(size, wall_probability=0.3):
|
|
||||||
maze = Maze(size, size)
|
|
||||||
maze.cells = [[Cell(x, y) for x in range(size)] for y in range(size)]
|
|
||||||
for y in range(size):
|
|
||||||
for x in range(size):
|
|
||||||
if random.random() < wall_probability:
|
|
||||||
maze.cells[y][x].is_wall = True
|
|
||||||
maze.start = maze.cells[0][0]
|
|
||||||
maze.exit = maze.cells[size-1][size-1]
|
|
||||||
maze.start.is_start = True
|
|
||||||
maze.exit.is_exit = True
|
|
||||||
maze.start.is_wall = False
|
|
||||||
maze.exit.is_wall = False
|
|
||||||
return maze
|
|
||||||
|
|
||||||
def create_empty_maze(size):
|
|
||||||
maze = Maze(size, size)
|
|
||||||
maze.cells = [[Cell(x, y) for x in range(size)] for y in range(size)]
|
|
||||||
maze.start = maze.cells[0][0]
|
|
||||||
maze.exit = maze.cells[size-1][size-1]
|
|
||||||
maze.start.is_start = True
|
|
||||||
maze.exit.is_exit = True
|
|
||||||
return maze
|
|
||||||
|
|
||||||
def create_no_exit_maze(size, wall_probability=0.3):
|
|
||||||
maze = create_maze_with_walls(size, wall_probability)
|
|
||||||
maze.exit.is_wall = True
|
|
||||||
return maze
|
|
||||||
|
|
||||||
def run_experiment():
|
|
||||||
maze_configs = {
|
|
||||||
"10x10_simple": {"size": 10, "type": "normal", "wall_prob": 0.1},
|
|
||||||
"50x50_with_deadends": {"size": 50, "type": "normal", "wall_prob": 0.3},
|
|
||||||
"100x100_complex": {"size": 100, "type": "normal", "wall_prob": 0.35},
|
|
||||||
"empty": {"size": 30, "type": "empty"},
|
|
||||||
"no_exit": {"size": 30, "type": "no_exit", "wall_prob": 0.3},
|
|
||||||
}
|
|
||||||
strategies = {
|
|
||||||
"BFS": BFSStrategy(),
|
|
||||||
"DFS": DFSStrategy(),
|
|
||||||
"AStar": AStarStrategy()
|
|
||||||
}
|
|
||||||
results = []
|
|
||||||
for maze_name, config in maze_configs.items():
|
|
||||||
size = config["size"]
|
|
||||||
maze_type = config["type"]
|
|
||||||
if maze_type == "empty":
|
|
||||||
maze = create_empty_maze(size)
|
|
||||||
elif maze_type == "no_exit":
|
|
||||||
maze = create_no_exit_maze(size, config.get("wall_prob", 0.3))
|
|
||||||
else:
|
|
||||||
maze = create_maze_with_walls(size, config.get("wall_prob", 0.3))
|
|
||||||
for strat_name, strategy in strategies.items():
|
|
||||||
solver = MazeSolver(maze, strategy)
|
|
||||||
times, visited_list, lengths = [], [], []
|
|
||||||
for _ in range(7):
|
|
||||||
stats = solver.solve()
|
|
||||||
times.append(stats.time_ms)
|
|
||||||
visited_list.append(stats.visited_cells)
|
|
||||||
lengths.append(stats.path_length)
|
|
||||||
avg_time = sum(times) / len(times)
|
|
||||||
avg_visited = sum(visited_list) / len(visited_list)
|
|
||||||
avg_length = sum(lengths) / len(lengths)
|
|
||||||
results.append([
|
|
||||||
maze_name, strat_name,
|
|
||||||
round(avg_time, 4),
|
|
||||||
int(avg_visited),
|
|
||||||
int(avg_length)
|
|
||||||
])
|
|
||||||
os.makedirs("results", exist_ok=True)
|
|
||||||
csv_path = "results/results.csv"
|
|
||||||
with open(csv_path, "w", newline="", encoding="utf-8") as f:
|
|
||||||
writer = csv.writer(f)
|
|
||||||
writer.writerow(["лабиринт", "стратегия", "время_мс", "посещено_клеток", "длина_пути"])
|
|
||||||
writer.writerows(results)
|
|
||||||
df = pd.read_csv(csv_path)
|
|
||||||
plt.figure(figsize=(12, 6))
|
|
||||||
for strat in df["стратегия"].unique():
|
|
||||||
subset = df[df["стратегия"] == strat]
|
|
||||||
plt.plot(subset["лабиринт"], subset["время_мс"], marker='o', label=strat)
|
|
||||||
plt.title("Сравнение времени работы алгоритмов")
|
|
||||||
plt.xlabel("Лабиринт")
|
|
||||||
plt.ylabel("Время (мс)")
|
|
||||||
plt.legend()
|
|
||||||
plt.grid(True)
|
|
||||||
plt.xticks(rotation=45)
|
|
||||||
plt.tight_layout()
|
|
||||||
plt.savefig("results/time_comparison.png")
|
|
||||||
plt.close()
|
|
||||||
plt.figure(figsize=(12, 6))
|
|
||||||
for strat in df["стратегия"].unique():
|
|
||||||
subset = df[df["стратегия"] == strat]
|
|
||||||
plt.plot(subset["лабиринт"], subset["посещено_клеток"], marker='o', label=strat)
|
|
||||||
plt.title("Количество посещённых клеток")
|
|
||||||
plt.xlabel("Лабиринт")
|
|
||||||
plt.ylabel("Посещено клеток")
|
|
||||||
plt.legend()
|
|
||||||
plt.grid(True)
|
|
||||||
plt.xticks(rotation=45)
|
|
||||||
plt.tight_layout()
|
|
||||||
plt.savefig("results/visited_comparison.png")
|
|
||||||
plt.close()
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
run_experiment()
|
|
||||||
|
|
@ -1,35 +0,0 @@
|
||||||
ОТЧЁТ ПО ЗАДАНИЮ 1
|
|
||||||
|
|
||||||
1. Влияние порядка данных на BST
|
|
||||||
При случайном порядке данных BST работает быстро (вставка ~0.005 сек).
|
|
||||||
При отсортированном порядке дерево вырождается в цепочку, и время вставки
|
|
||||||
возрастает примерно в 50–60 раз (~0.31 сек). Сложность деградирует с O(log n) до O(n).
|
|
||||||
|
|
||||||
2. Почему хеш-таблица нечувствительна к порядку
|
|
||||||
Хеш-таблица использует хеш-функцию, которая равномерно распределяет элементы
|
|
||||||
по бакетам. Поэтому порядок входных данных почти не влияет на скорость
|
|
||||||
вставки, поиска и удаления (в среднем O(1)).
|
|
||||||
|
|
||||||
3. Почему связный список медленен при поиске
|
|
||||||
Для поиска в связном списке нужно последовательно пройти все элементы.
|
|
||||||
Поэтому поиск всегда выполняется за O(n), независимо от порядка данных.
|
|
||||||
Это делает его самым медленным при операциях поиска и удаления.
|
|
||||||
|
|
||||||
4. Как работает удаление
|
|
||||||
- LinkedList: O(n) — нужно найти элемент и перестроить ссылки.
|
|
||||||
- HashTable: O(1) в среднем — удаление внутри нужного бакета.
|
|
||||||
- BST: O(log n) в среднем, O(n) в худшем — при двух потомках ищется
|
|
||||||
минимальный элемент в правом поддереве.
|
|
||||||
|
|
||||||
5. Вывод и рекомендации
|
|
||||||
|
|
||||||
Рекомендуемые структуры в зависимости от задачи:
|
|
||||||
|
|
||||||
- Частые вставки и поиск → HashTable (лучшая общая производительность)
|
|
||||||
- Нужно получать данные в отсортированном порядке → BST (только при случайных данных)
|
|
||||||
- Данные приходят отсортированными → HashTable (BST сильно деградирует)
|
|
||||||
- Малый объём данных и простота → LinkedList
|
|
||||||
|
|
||||||
Итог: Для большинства реальных задач лучше всего подходит хеш-таблица.
|
|
||||||
BST имеет смысл использовать только при случайном порядке данных и
|
|
||||||
необходимости частого получения отсортированного списка.
|
|
||||||
|
|
@ -1,169 +0,0 @@
|
||||||
Отчёт ко 2 заданию
|
|
||||||
|
|
||||||
1. Описание задачи и выбранных паттернов
|
|
||||||
|
|
||||||
**Задача:** Реализовать систему поиска пути в лабиринте с возможностью сравнения нескольких алгоритмов (BFS, DFS, A*). Система должна поддерживать разные способы построения лабиринта и позволять легко добавлять новые алгоритмы поиска.
|
|
||||||
|
|
||||||
Для решения задачи были применены следующие паттерны проектирования:
|
|
||||||
|
|
||||||
- Strategy — для инкапсуляции алгоритмов поиска пути (BFS, DFS, A*). Позволяет динамически менять стратегию поиска.
|
|
||||||
- Builder — для построения лабиринта из файла. Отделяет процесс создания лабиринта от его представления.
|
|
||||||
|
|
||||||
Эти паттерны обеспечивают гибкость и расширяемость системы.
|
|
||||||
|
|
||||||
Диаграмма классов (Mermaid)
|
|
||||||
|
|
||||||
```mermaid
|
|
||||||
classDiagram
|
|
||||||
class Maze {
|
|
||||||
+width: int
|
|
||||||
+height: int
|
|
||||||
+cells: List~List~Cell~~
|
|
||||||
+start: Cell
|
|
||||||
+exit: Cell
|
|
||||||
+getCell(x, y)
|
|
||||||
+getNeighbors(cell)
|
|
||||||
}
|
|
||||||
|
|
||||||
class Cell {
|
|
||||||
+x: int
|
|
||||||
+y: int
|
|
||||||
+is_wall: bool
|
|
||||||
+is_start: bool
|
|
||||||
+is_exit: bool
|
|
||||||
+isPassable()
|
|
||||||
}
|
|
||||||
|
|
||||||
class PathFindingStrategy {
|
|
||||||
<<interface>>
|
|
||||||
+findPath(maze, start, exit)
|
|
||||||
}
|
|
||||||
|
|
||||||
class BFSStrategy {
|
|
||||||
+findPath(maze, start, exit)
|
|
||||||
}
|
|
||||||
|
|
||||||
class DFSStrategy {
|
|
||||||
+findPath(maze, start, exit)
|
|
||||||
}
|
|
||||||
|
|
||||||
class AStarStrategy {
|
|
||||||
+findPath(maze, start, exit)
|
|
||||||
-heuristic(a, b)
|
|
||||||
}
|
|
||||||
|
|
||||||
class MazeSolver {
|
|
||||||
-maze: Maze
|
|
||||||
-strategy: PathFindingStrategy
|
|
||||||
+setStrategy(strategy)
|
|
||||||
+solve()
|
|
||||||
}
|
|
||||||
|
|
||||||
class MazeBuilder {
|
|
||||||
<<interface>>
|
|
||||||
+buildFromFile(filename)
|
|
||||||
}
|
|
||||||
|
|
||||||
class TextFileMazeBuilder {
|
|
||||||
+buildFromFile(filename)
|
|
||||||
}
|
|
||||||
|
|
||||||
Maze "1" *-- "many" Cell
|
|
||||||
MazeSolver --> PathFindingStrategy
|
|
||||||
PathFindingStrategy <|-- BFSStrategy
|
|
||||||
PathFindingStrategy <|-- DFSStrategy
|
|
||||||
PathFindingStrategy <|-- AStarStrategy
|
|
||||||
MazeBuilder <|-- TextFileMazeBuilder
|
|
||||||
```
|
|
||||||
|
|
||||||
2. Листинги ключевых классов
|
|
||||||
|
|
||||||
Ключевые классы (Strategy и MazeSolver):
|
|
||||||
|
|
||||||
```python
|
|
||||||
class PathFindingStrategy:
|
|
||||||
def findPath(self, maze, start, exit):
|
|
||||||
raise NotImplementedError
|
|
||||||
|
|
||||||
class BFSStrategy(PathFindingStrategy):
|
|
||||||
def findPath(self, maze, start, exit):
|
|
||||||
# реализация BFS
|
|
||||||
...
|
|
||||||
|
|
||||||
class DFSStrategy(PathFindingStrategy):
|
|
||||||
def findPath(self, maze, start, exit):
|
|
||||||
# реализация DFS
|
|
||||||
...
|
|
||||||
|
|
||||||
class AStarStrategy(PathFindingStrategy):
|
|
||||||
def findPath(self, maze, start, exit):
|
|
||||||
# реализация A*
|
|
||||||
...
|
|
||||||
```
|
|
||||||
|
|
||||||
```python
|
|
||||||
class MazeSolver:
|
|
||||||
def __init__(self, maze=None, strategy=None):
|
|
||||||
self.maze = maze
|
|
||||||
self.strategy = strategy
|
|
||||||
|
|
||||||
def setStrategy(self, strategy):
|
|
||||||
self.strategy = strategy
|
|
||||||
|
|
||||||
def solve(self):
|
|
||||||
if not self.maze or not self.strategy:
|
|
||||||
return None
|
|
||||||
# замер времени и вызов стратегии
|
|
||||||
...
|
|
||||||
```
|
|
||||||
|
|
||||||
Полный код доступен в репозитории (или может быть предоставлен по запросу).
|
|
||||||
|
|
||||||
3. Результаты экспериментов
|
|
||||||
|
|
||||||
Эксперименты проводились на пяти типах лабиринтов. Ниже представлены ключевые результаты.
|
|
||||||
|
|
||||||
Сводная таблица (средние значения):
|
|
||||||
|
|
||||||
| Лабиринт | Стратегия | Время (мс) | Посещено клеток | Длина пути |
|
|
||||||
|-------------------------|-----------|------------|------------------|------------|
|
|
||||||
| 10x10_simple | BFS | 0.07 | 90 | 37 |
|
|
||||||
| 10x10_simple | DFS | 0.03 | 67 | 37 |
|
|
||||||
| 10x10_simple | A* | 0.09 | 76 | 19 |
|
|
||||||
| 50x50_with_deadends | BFS | 1.29 | 1657 | 0 |
|
|
||||||
| 50x50_with_deadends | DFS | 0.64 | 993 | 243 |
|
|
||||||
| 50x50_with_deadends | A* | 0.56 | 440 | 101 |
|
|
||||||
| 100x100_complex | BFS | 4.40 | 5735 | 1 |
|
|
||||||
| 100x100_complex | DFS | 4.33 | 5735 | 1 |
|
|
||||||
| 100x100_complex | A* | 7.03 | 5735 | 1 |
|
|
||||||
| empty | BFS | 0.68 | 900 | 0 |
|
|
||||||
| empty | DFS | 0.39 | 900 | 465 |
|
|
||||||
| empty | A* | 1.04 | 900 | 59 |
|
|
||||||
|
|
||||||
Графики (сохранены в папке `results/`):
|
|
||||||
- `time_comparison.png` — сравнение времени работы алгоритмов
|
|
||||||
- `visited_comparison.png` — сравнение количества посещённых клеток
|
|
||||||
|
|
||||||
4. Анализ эффективности алгоритмов и применимости паттернов
|
|
||||||
|
|
||||||
- **BFS** показывает стабильную работу и находит кратчайший путь, но посещает больше клеток.
|
|
||||||
- **DFS** быстрее всех на простых и пустых лабиринтах, однако не гарантирует оптимальность.
|
|
||||||
- **A*** эффективнее всего по количеству посещённых клеток на сложных лабиринтах, но на больших картах проигрывает по времени из-за overhead приоритетной очереди.
|
|
||||||
|
|
||||||
Паттерн **Strategy** позволил легко переключаться между алгоритмами без изменения кода `MazeSolver`. Паттерн **Builder** сделал возможным добавление новых источников построения лабиринта (например, генератор случайных лабиринтов) без изменения основной логики.
|
|
||||||
|
|
||||||
5. Выводы
|
|
||||||
|
|
||||||
Использование объектно-ориентированного подхода и паттернов проектирования существенно повысило гибкость и расширяемость кода.
|
|
||||||
|
|
||||||
Преимущества:
|
|
||||||
- Благодаря паттерну **Strategy** добавление нового алгоритма поиска (например, Dijkstra) требует только реализации интерфейса `PathFindingStrategy` без изменения `MazeSolver`.
|
|
||||||
- Паттерн **Builder** позволяет легко подключать новые способы загрузки лабиринтов.
|
|
||||||
- Код стал более читаемым и поддерживаемым.
|
|
||||||
|
|
||||||
Что было бы сложно изменить без паттернов:
|
|
||||||
- Замена алгоритма поиска потребовала бы значительных изменений в классе `MazeSolver` (много условных операторов `if`).
|
|
||||||
- Добавление нового способа построения лабиринта привело бы к дублированию кода.
|
|
||||||
- Сравнительный эксперимент было бы гораздо сложнее проводить, так как алгоритмы не были бы унифицированы через общий интерфейс.
|
|
||||||
|
|
||||||
Таким образом, применение паттернов Strategy и Builder сделало систему легко расширяемой и удобной для проведения экспериментов.
|
|
||||||
Binary file not shown.
|
Before Width: | Height: | Size: 66 KiB |
|
|
@ -1,258 +0,0 @@
|
||||||
import time
|
|
||||||
import random
|
|
||||||
import csv
|
|
||||||
import os
|
|
||||||
import matplotlib.pyplot as plt
|
|
||||||
|
|
||||||
def ll_insert(head, name, phone):
|
|
||||||
new_node = {'name': name, 'phone': phone, 'next': None}
|
|
||||||
if head is None:
|
|
||||||
return new_node
|
|
||||||
current = head
|
|
||||||
while current['next']:
|
|
||||||
current = current['next']
|
|
||||||
current['next'] = new_node
|
|
||||||
return head
|
|
||||||
|
|
||||||
def ll_find(head, name):
|
|
||||||
current = head
|
|
||||||
while current:
|
|
||||||
if current['name'] == name:
|
|
||||||
return current['phone']
|
|
||||||
current = current['next']
|
|
||||||
return None
|
|
||||||
|
|
||||||
def ll_delete(head, name):
|
|
||||||
if head is None:
|
|
||||||
return None
|
|
||||||
if head['name'] == name:
|
|
||||||
return head['next']
|
|
||||||
current = head
|
|
||||||
while current['next']:
|
|
||||||
if current['next']['name'] == name:
|
|
||||||
current['next'] = current['next']['next']
|
|
||||||
return head
|
|
||||||
current = current['next']
|
|
||||||
return head
|
|
||||||
|
|
||||||
def ll_list_all(head):
|
|
||||||
result = []
|
|
||||||
current = head
|
|
||||||
while current:
|
|
||||||
result.append((current['name'], current['phone']))
|
|
||||||
current = current['next']
|
|
||||||
return sorted(result)
|
|
||||||
|
|
||||||
def create_hash_table(size=200):
|
|
||||||
return [None] * size
|
|
||||||
|
|
||||||
def ht_insert(buckets, name, phone):
|
|
||||||
index = hash(name) % len(buckets)
|
|
||||||
buckets[index] = ll_insert(buckets[index], name, phone)
|
|
||||||
|
|
||||||
def ht_find(buckets, name):
|
|
||||||
index = hash(name) % len(buckets)
|
|
||||||
return ll_find(buckets[index], name)
|
|
||||||
|
|
||||||
def ht_delete(buckets, name):
|
|
||||||
index = hash(name) % len(buckets)
|
|
||||||
buckets[index] = ll_delete(buckets[index], name)
|
|
||||||
|
|
||||||
def ht_list_all(buckets):
|
|
||||||
result = []
|
|
||||||
for bucket in buckets:
|
|
||||||
current = bucket
|
|
||||||
while current:
|
|
||||||
result.append((current['name'], current['phone']))
|
|
||||||
current = current['next']
|
|
||||||
return sorted(result)
|
|
||||||
|
|
||||||
|
|
||||||
def bst_insert(root, name, phone):
|
|
||||||
new_node = {'name': name, 'phone': phone, 'left': None, 'right': None}
|
|
||||||
|
|
||||||
if root is None:
|
|
||||||
return new_node
|
|
||||||
|
|
||||||
current = root
|
|
||||||
while True:
|
|
||||||
if name < current['name']:
|
|
||||||
if current['left'] is None:
|
|
||||||
current['left'] = new_node
|
|
||||||
return root
|
|
||||||
current = current['left']
|
|
||||||
elif name > current['name']:
|
|
||||||
if current['right'] is None:
|
|
||||||
current['right'] = new_node
|
|
||||||
return root
|
|
||||||
current = current['right']
|
|
||||||
else:
|
|
||||||
current['phone'] = phone
|
|
||||||
return root
|
|
||||||
|
|
||||||
|
|
||||||
def bst_find(root, name):
|
|
||||||
current = root
|
|
||||||
while current:
|
|
||||||
if name == current['name']:
|
|
||||||
return current['phone']
|
|
||||||
elif name < current['name']:
|
|
||||||
current = current['left']
|
|
||||||
else:
|
|
||||||
current = current['right']
|
|
||||||
return None
|
|
||||||
|
|
||||||
|
|
||||||
def bst_delete(root, name):
|
|
||||||
if root is None:
|
|
||||||
return None
|
|
||||||
|
|
||||||
parent = None
|
|
||||||
current = root
|
|
||||||
while current and current['name'] != name:
|
|
||||||
parent = current
|
|
||||||
if name < current['name']:
|
|
||||||
current = current['left']
|
|
||||||
else:
|
|
||||||
current = current['right']
|
|
||||||
|
|
||||||
if current is None:
|
|
||||||
return root
|
|
||||||
|
|
||||||
if current['left'] is None or current['right'] is None:
|
|
||||||
child = current['left'] if current['left'] else current['right']
|
|
||||||
if parent is None:
|
|
||||||
return child
|
|
||||||
if parent['left'] == current:
|
|
||||||
parent['left'] = child
|
|
||||||
else:
|
|
||||||
parent['right'] = child
|
|
||||||
else:
|
|
||||||
parent_min = current
|
|
||||||
min_node = current['right']
|
|
||||||
while min_node['left']:
|
|
||||||
parent_min = min_node
|
|
||||||
min_node = min_node['left']
|
|
||||||
|
|
||||||
current['name'] = min_node['name']
|
|
||||||
current['phone'] = min_node['phone']
|
|
||||||
|
|
||||||
if parent_min['left'] == min_node:
|
|
||||||
parent_min['left'] = min_node['right']
|
|
||||||
else:
|
|
||||||
parent_min['right'] = min_node['right']
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
|
|
||||||
def bst_list_all(root):
|
|
||||||
result = []
|
|
||||||
def inorder(node):
|
|
||||||
if node:
|
|
||||||
inorder(node['left'])
|
|
||||||
result.append((node['name'], node['phone']))
|
|
||||||
inorder(node['right'])
|
|
||||||
inorder(root)
|
|
||||||
return result
|
|
||||||
|
|
||||||
|
|
||||||
def generate_records(n=10000):
|
|
||||||
records = [(f"User_{i:05d}", f"8{random.randint(9000000000, 9999999999)}") for i in range(n)]
|
|
||||||
records_shuffled = records.copy()
|
|
||||||
random.shuffle(records_shuffled)
|
|
||||||
records_sorted = sorted(records, key=lambda x: x[0])
|
|
||||||
return records_shuffled, records_sorted
|
|
||||||
|
|
||||||
|
|
||||||
def run_experiments():
|
|
||||||
random.seed(42)
|
|
||||||
records_shuffled, records_sorted = generate_records(10000)
|
|
||||||
all_results = []
|
|
||||||
|
|
||||||
structures = ["LinkedList", "HashTable", "BST"]
|
|
||||||
modes = [("случайный", records_shuffled), ("отсортированный", records_sorted)]
|
|
||||||
|
|
||||||
for mode_name, records in modes:
|
|
||||||
for struct_name in structures:
|
|
||||||
print(f"Тестируем: {struct_name} | Режим: {mode_name}")
|
|
||||||
|
|
||||||
for run in range(5):
|
|
||||||
if struct_name == "LinkedList":
|
|
||||||
data = None
|
|
||||||
elif struct_name == "HashTable":
|
|
||||||
data = create_hash_table(200)
|
|
||||||
else:
|
|
||||||
data = None
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
for name, phone in records:
|
|
||||||
if struct_name == "LinkedList":
|
|
||||||
data = ll_insert(data, name, phone)
|
|
||||||
elif struct_name == "HashTable":
|
|
||||||
ht_insert(data, name, phone)
|
|
||||||
else:
|
|
||||||
data = bst_insert(data, name, phone)
|
|
||||||
insert_time = time.perf_counter() - start
|
|
||||||
|
|
||||||
test_names = [r[0] for r in random.sample(records, 100)]
|
|
||||||
test_names += [f"None_{i}" for i in range(10)]
|
|
||||||
start = time.perf_counter()
|
|
||||||
for name in test_names:
|
|
||||||
if struct_name == "LinkedList":
|
|
||||||
ll_find(data, name)
|
|
||||||
elif struct_name == "HashTable":
|
|
||||||
ht_find(data, name)
|
|
||||||
else:
|
|
||||||
bst_find(data, name)
|
|
||||||
find_time = time.perf_counter() - start
|
|
||||||
|
|
||||||
delete_names = [r[0] for r in random.sample(records, 50)]
|
|
||||||
start = time.perf_counter()
|
|
||||||
for name in delete_names:
|
|
||||||
if struct_name == "LinkedList":
|
|
||||||
data = ll_delete(data, name)
|
|
||||||
elif struct_name == "HashTable":
|
|
||||||
ht_delete(data, name)
|
|
||||||
else:
|
|
||||||
data = bst_delete(data, name)
|
|
||||||
delete_time = time.perf_counter() - start
|
|
||||||
|
|
||||||
all_results.append([struct_name, mode_name, "вставка", run + 1, insert_time])
|
|
||||||
all_results.append([struct_name, mode_name, "поиск", run + 1, find_time])
|
|
||||||
all_results.append([struct_name, mode_name, "удаление", run + 1, delete_time])
|
|
||||||
|
|
||||||
os.makedirs("docs/data", exist_ok=True)
|
|
||||||
filepath = "docs/data/results.csv"
|
|
||||||
with open(filepath, "w", newline="", encoding="utf-8") as f:
|
|
||||||
writer = csv.writer(f)
|
|
||||||
writer.writerow(["Структура", "Режим", "Операция", "Запуск", "Время (сек)"])
|
|
||||||
writer.writerows(all_results)
|
|
||||||
|
|
||||||
print(f"\nРезультаты сохранены в {filepath}")
|
|
||||||
return all_results
|
|
||||||
|
|
||||||
def plot_results(csv_path="docs/data/results.csv"):
|
|
||||||
import pandas as pd
|
|
||||||
df = pd.read_csv(csv_path)
|
|
||||||
summary = df.groupby(["Структура", "Режим", "Операция"])["Время (сек)"].mean().reset_index()
|
|
||||||
|
|
||||||
for op in ["вставка", "поиск", "удаление"]:
|
|
||||||
op_data = summary[summary["Операция"] == op]
|
|
||||||
plt.figure(figsize=(10, 6))
|
|
||||||
x_labels = []
|
|
||||||
y_values = []
|
|
||||||
for _, row in op_data.iterrows():
|
|
||||||
label = f"{row['Структура']}\n({row['Режим']})"
|
|
||||||
x_labels.append(label)
|
|
||||||
y_values.append(row["Время (сек)"])
|
|
||||||
plt.bar(x_labels, y_values, color=['#4C72B0', '#55A868', '#C44E52'] * 2)
|
|
||||||
plt.title(f"Среднее время операции: {op}")
|
|
||||||
plt.ylabel("Время (сек)")
|
|
||||||
plt.xticks(rotation=45)
|
|
||||||
plt.tight_layout()
|
|
||||||
plt.savefig(f"docs/data/graph_{op}.png")
|
|
||||||
print(f"График сохранён: docs/data/graph_{op}.png")
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
run_experiments()
|
|
||||||
plot_results()
|
|
||||||
Binary file not shown.
|
Before Width: | Height: | Size: 73 KiB |
|
|
@ -1,16 +0,0 @@
|
||||||
лабиринт,стратегия,время_мс,посещено_клеток,длина_пути
|
|
||||||
10x10_simple,BFS,0.0646,82,1
|
|
||||||
10x10_simple,DFS,0.0633,82,1
|
|
||||||
10x10_simple,AStar,0.0929,82,1
|
|
||||||
50x50_with_deadends,BFS,1.3632,1687,0
|
|
||||||
50x50_with_deadends,DFS,0.1943,400,205
|
|
||||||
50x50_with_deadends,AStar,0.6863,562,101
|
|
||||||
100x100_complex,BFS,4.8617,6060,1
|
|
||||||
100x100_complex,DFS,4.6471,6060,1
|
|
||||||
100x100_complex,AStar,7.4691,6060,1
|
|
||||||
empty,BFS,0.6954,900,0
|
|
||||||
empty,DFS,0.4106,900,465
|
|
||||||
empty,AStar,1.0604,900,59
|
|
||||||
no_exit,BFS,0.0017,1,1
|
|
||||||
no_exit,DFS,0.0009,1,1
|
|
||||||
no_exit,AStar,0.001,1,1
|
|
||||||
|
|
|
@ -1,292 +0,0 @@
|
||||||
#!/usr/bin/env python3
|
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
|
|
||||||
import time
|
|
||||||
import random
|
|
||||||
import csv
|
|
||||||
import sys
|
|
||||||
sys.setrecursionlimit(30000)
|
|
||||||
|
|
||||||
def ll_create_node(name, phone):
|
|
||||||
return {'name': name, 'phone': phone, 'next': None}
|
|
||||||
|
|
||||||
def ll_insert(head, name, phone):
|
|
||||||
if head is None:
|
|
||||||
return ll_create_node(name, phone)
|
|
||||||
|
|
||||||
if head['name'] == name:
|
|
||||||
head['phone'] = phone
|
|
||||||
return head
|
|
||||||
|
|
||||||
current = head
|
|
||||||
while current['next'] is not None:
|
|
||||||
if current['next']['name'] == name:
|
|
||||||
current['next']['phone'] = phone
|
|
||||||
return head
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
current['next'] = ll_create_node(name, phone)
|
|
||||||
return head
|
|
||||||
|
|
||||||
def ll_find(head, name):
|
|
||||||
current = head
|
|
||||||
while current is not None:
|
|
||||||
if current['name'] == name:
|
|
||||||
return current['phone']
|
|
||||||
current = current['next']
|
|
||||||
return None
|
|
||||||
|
|
||||||
def ll_delete(head, name):
|
|
||||||
if head is None:
|
|
||||||
return None
|
|
||||||
|
|
||||||
if head['name'] == name:
|
|
||||||
return head['next']
|
|
||||||
|
|
||||||
current = head
|
|
||||||
while current['next'] is not None:
|
|
||||||
if current['next']['name'] == name:
|
|
||||||
current['next'] = current['next']['next']
|
|
||||||
return head
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
return head
|
|
||||||
|
|
||||||
def ll_list_all(head):
|
|
||||||
records = []
|
|
||||||
current = head
|
|
||||||
while current is not None:
|
|
||||||
records.append((current['name'], current['phone']))
|
|
||||||
current = current['next']
|
|
||||||
records.sort(key=lambda x: x[0])
|
|
||||||
return records
|
|
||||||
|
|
||||||
def hash_function(name, table_size):
|
|
||||||
return sum(ord(c) for c in name) % table_size
|
|
||||||
|
|
||||||
def ht_create_table(size=2000):
|
|
||||||
return [None] * size
|
|
||||||
|
|
||||||
def ht_insert(table, name, phone):
|
|
||||||
index = hash_function(name, len(table))
|
|
||||||
table[index] = ll_insert(table[index], name, phone)
|
|
||||||
|
|
||||||
def ht_find(table, name):
|
|
||||||
index = hash_function(name, len(table))
|
|
||||||
return ll_find(table[index], name)
|
|
||||||
|
|
||||||
def ht_delete(table, name):
|
|
||||||
index = hash_function(name, len(table))
|
|
||||||
table[index] = ll_delete(table[index], name)
|
|
||||||
|
|
||||||
def ht_list_all(table):
|
|
||||||
all_records = []
|
|
||||||
for bucket in table:
|
|
||||||
if bucket is not None:
|
|
||||||
current = bucket
|
|
||||||
while current is not None:
|
|
||||||
all_records.append((current['name'], current['phone']))
|
|
||||||
current = current['next']
|
|
||||||
all_records.sort(key=lambda x: x[0])
|
|
||||||
return all_records
|
|
||||||
|
|
||||||
def bst_create_node(name, phone):
|
|
||||||
return {'name': name, 'phone': phone, 'left': None, 'right': None}
|
|
||||||
|
|
||||||
def bst_insert(root, name, phone):
|
|
||||||
if root is None:
|
|
||||||
return bst_create_node(name, phone)
|
|
||||||
|
|
||||||
current = root
|
|
||||||
while True:
|
|
||||||
if name < current['name']:
|
|
||||||
if current['left'] is None:
|
|
||||||
current['left'] = bst_create_node(name, phone)
|
|
||||||
break
|
|
||||||
else:
|
|
||||||
current = current['left']
|
|
||||||
elif name > current['name']:
|
|
||||||
if current['right'] is None:
|
|
||||||
current['right'] = bst_create_node(name, phone)
|
|
||||||
break
|
|
||||||
else:
|
|
||||||
current = current['right']
|
|
||||||
else:
|
|
||||||
current['phone'] = phone
|
|
||||||
break
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
def bst_find(root, name):
|
|
||||||
current = root
|
|
||||||
while current is not None:
|
|
||||||
if name < current['name']:
|
|
||||||
current = current['left']
|
|
||||||
elif name > current['name']:
|
|
||||||
current = current['right']
|
|
||||||
else:
|
|
||||||
return current['phone']
|
|
||||||
return None
|
|
||||||
|
|
||||||
def bst_find_min(node):
|
|
||||||
current = node
|
|
||||||
while current['left'] is not None:
|
|
||||||
current = current['left']
|
|
||||||
return current
|
|
||||||
|
|
||||||
def bst_delete(root, name):
|
|
||||||
if root is None:
|
|
||||||
return None
|
|
||||||
|
|
||||||
parent = None
|
|
||||||
current = root
|
|
||||||
|
|
||||||
while current is not None and current['name'] != name:
|
|
||||||
parent = current
|
|
||||||
if name < current['name']:
|
|
||||||
current = current['left']
|
|
||||||
else:
|
|
||||||
current = current['right']
|
|
||||||
|
|
||||||
if current is None:
|
|
||||||
return root
|
|
||||||
|
|
||||||
if current['left'] is None or current['right'] is None:
|
|
||||||
if current['left'] is not None:
|
|
||||||
child = current['left']
|
|
||||||
else:
|
|
||||||
child = current['right']
|
|
||||||
|
|
||||||
if parent is None:
|
|
||||||
return child
|
|
||||||
|
|
||||||
if parent['left'] == current:
|
|
||||||
parent['left'] = child
|
|
||||||
else:
|
|
||||||
parent['right'] = child
|
|
||||||
else:
|
|
||||||
successor_parent = current
|
|
||||||
successor = current['right']
|
|
||||||
|
|
||||||
while successor['left'] is not None:
|
|
||||||
successor_parent = successor
|
|
||||||
successor = successor['left']
|
|
||||||
|
|
||||||
current['name'] = successor['name']
|
|
||||||
current['phone'] = successor['phone']
|
|
||||||
|
|
||||||
if successor_parent['left'] == successor:
|
|
||||||
successor_parent['left'] = successor['right']
|
|
||||||
else:
|
|
||||||
successor_parent['right'] = successor['right']
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
def bst_list_all(root):
|
|
||||||
records = []
|
|
||||||
stack = []
|
|
||||||
current = root
|
|
||||||
|
|
||||||
while stack or current is not None:
|
|
||||||
while current is not None:
|
|
||||||
stack.append(current)
|
|
||||||
current = current['left']
|
|
||||||
current = stack.pop()
|
|
||||||
records.append((current['name'], current['phone']))
|
|
||||||
current = current['right']
|
|
||||||
|
|
||||||
return records
|
|
||||||
|
|
||||||
def generate_data(n=10000):
|
|
||||||
records = [(f"User_{i:05d}", f"+7-999-{i:06d}") for i in range(n)]
|
|
||||||
records_shuffled = records.copy()
|
|
||||||
random.shuffle(records_shuffled)
|
|
||||||
records_sorted = sorted(records, key=lambda x: x[0])
|
|
||||||
return records_shuffled, records_sorted
|
|
||||||
|
|
||||||
def run_experiment(structure_name, insert_func, find_func, delete_func,
|
|
||||||
list_all_func, init_func, records, n_find=100):
|
|
||||||
|
|
||||||
data = init_func()
|
|
||||||
names = [r[0] for r in records]
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
for name, phone in records:
|
|
||||||
if structure_name == "HashTable":
|
|
||||||
insert_func(data, name, phone)
|
|
||||||
else:
|
|
||||||
data = insert_func(data, name, phone)
|
|
||||||
insert_time = time.perf_counter() - start
|
|
||||||
|
|
||||||
find_names = random.sample(names, min(n_find, len(names)))
|
|
||||||
missing_names = [f"None_{i}" for i in range(10)]
|
|
||||||
all_find_names = find_names + missing_names
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
for name in all_find_names:
|
|
||||||
if structure_name == "HashTable":
|
|
||||||
find_func(data, name)
|
|
||||||
else:
|
|
||||||
find_func(data, name)
|
|
||||||
find_time = time.perf_counter() - start
|
|
||||||
|
|
||||||
delete_names = random.sample(names, min(50, len(names)))
|
|
||||||
start = time.perf_counter()
|
|
||||||
for name in delete_names:
|
|
||||||
if structure_name == "HashTable":
|
|
||||||
delete_func(data, name)
|
|
||||||
else:
|
|
||||||
data = delete_func(data, name)
|
|
||||||
delete_time = time.perf_counter() - start
|
|
||||||
|
|
||||||
return insert_time, find_time, delete_time
|
|
||||||
|
|
||||||
def main():
|
|
||||||
print("Generating test data...")
|
|
||||||
records_shuffled, records_sorted = generate_data(10000)
|
|
||||||
|
|
||||||
results = []
|
|
||||||
|
|
||||||
structures = [
|
|
||||||
("LinkedList", ll_insert, ll_find, ll_delete, ll_list_all, lambda: None),
|
|
||||||
("HashTable", ht_insert, ht_find, ht_delete, ht_list_all, lambda: ht_create_table(2000)),
|
|
||||||
("BST", bst_insert, bst_find, bst_delete, bst_list_all, lambda: None)
|
|
||||||
]
|
|
||||||
|
|
||||||
for mode_name, records in [("random", records_shuffled), ("sorted", records_sorted)]:
|
|
||||||
print(f"\nMode: {mode_name}")
|
|
||||||
|
|
||||||
for struct_name, insert_f, find_f, delete_f, list_f, init_f in structures:
|
|
||||||
print(f" Testing {struct_name}...")
|
|
||||||
|
|
||||||
times = []
|
|
||||||
for run in range(5):
|
|
||||||
insert_t, find_t, delete_t = run_experiment(
|
|
||||||
struct_name, insert_f, find_f, delete_f, list_f, init_f, records
|
|
||||||
)
|
|
||||||
times.append((insert_t, find_t, delete_t))
|
|
||||||
print(f" Run {run+1}: insert={insert_t:.4f}s, find={find_t:.4f}s, delete={delete_t:.4f}s")
|
|
||||||
|
|
||||||
avg_insert = sum(t[0] for t in times) / 5
|
|
||||||
avg_find = sum(t[1] for t in times) / 5
|
|
||||||
avg_delete = sum(t[2] for t in times) / 5
|
|
||||||
|
|
||||||
results.append([struct_name, mode_name, "insert", avg_insert])
|
|
||||||
results.append([struct_name, mode_name, "find", avg_find])
|
|
||||||
results.append([struct_name, mode_name, "delete", avg_delete])
|
|
||||||
|
|
||||||
with open("results.csv", "w", newline="", encoding="utf-8") as f:
|
|
||||||
writer = csv.writer(f)
|
|
||||||
writer.writerow(["Structure", "Mode", "Operation", "Time_seconds"])
|
|
||||||
writer.writerows(results)
|
|
||||||
|
|
||||||
print("\n" + "="*60)
|
|
||||||
print("RESULTS (average over 5 runs):")
|
|
||||||
print("="*60)
|
|
||||||
for row in results:
|
|
||||||
print(f"{row[0]:12} | {row[1]:8} | {row[2]:8} | {row[3]:.6f} sec")
|
|
||||||
|
|
||||||
print("\nResults saved to results.csv")
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
main()
|
|
||||||
|
|
@ -1,122 +0,0 @@
|
||||||
|
|
||||||
|
|
||||||
Методы Программирования
|
|
||||||
|
|
||||||
|
|
||||||
Структуры данных,
|
|
||||||
анализ 1 задания
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Бобров К. Н.
|
|
||||||
425 группа
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Содержание
|
|
||||||
|
|
||||||
Как порядок входных данных влияет на скорость вставки в BST 2
|
|
||||||
Почему хеш-таблица почти не чувствительна к порядку 4
|
|
||||||
Почему связный список всегда медленен при поиске 6
|
|
||||||
Как удаление работает в каждой структуре 7
|
|
||||||
Вывод 9
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Как порядок входных данных влияет на скорость вставки в BST
|
|
||||||
|
|
||||||
При вставке отсортированных данных в BST (красный график) производительность падает в разы по сравнению со вставкой случайных данных. Это связано с тем, что отсортированная последовательность приводит к вырождению дерева в связанный список, тогда как случайный порядок вставки помогает сохранять дерево относительно сбалансированным.
|
|
||||||
При вставке элементов в отсортированном порядке (по возрастанию или убыванию):
|
|
||||||
?Каждый новый элемент всегда больше (или меньше) всех уже добавленных.
|
|
||||||
?В результате алгоритм каждый раз движется по одному и тому же направлению — только в правое или только в левое поддерево.
|
|
||||||
?Из-за этого дерево вырождается: каждый узел имеет не более одного потомка, структура напоминает линейный список.
|
|
||||||
?Высота такого дерева становится пропорциональной O(n).
|
|
||||||
?Каждая операция вставки требует в среднем O(n) сравнений, так как нужно проходить всю длину текущей цепочки от корня до самого глубокого листа.
|
|
||||||
?В итоге суммарная сложность вставки всех n элементов вырастает до O(n^2).
|
|
||||||
|
|
||||||
|
|
||||||
При случайной вставке:
|
|
||||||
?Элементы распределяются по дереву гораздо равномернее.
|
|
||||||
?Высока вероятность того, что дерево останется сбалансированным.
|
|
||||||
?Средняя высота дерева сохраняется на уровне O(logn).
|
|
||||||
?Каждая операция вставки в среднем требует O(logn) сравнений.
|
|
||||||
?Общая сложность вставки всех n элементов составляет O(nlogn).
|
|
||||||
Вывод: разница в скорости объясняется различием в высоте дерева. В вырожденном случае высота равна O(n), и каждая вставка выполняется в ?n/logn раз медленнее по числу шагов, чем в сбалансированном случае с высотой O(logn).
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Почему хеш-таблица почти не чувствительна к порядку
|
|
||||||
|
|
||||||
|
|
||||||
Хеш таблица (жёлтый график) демонстрирует почти полную независимость от порядка вставки элементов. Это объясняется тем, что положение каждого элемента в структуре определяется исключительно значением его хеш функции, а не тем, в какой последовательности происходило добавление данных.
|
|
||||||
|
|
||||||
Основные причины нечувствительности к порядку вставки:
|
|
||||||
?Хеширование. Для каждого ключа вычисляется хеш код, который преобразуется в индекс ячейки. Один и тот же ключ всегда даёт один и тот же индекс независимо от того, когда и в каком порядке он был добавлен.
|
|
||||||
?Независимость операций. Вставка, поиск и удаление выполняются в среднем за O(1)O(1), поскольку алгоритм сразу вычисляет нужную позицию, не обходя структуру и не учитывая историю добавлений.
|
|
||||||
?Разрешение коллизий. Даже если порядок вставки влияет на расположение элементов внутри цепочки (метод цепочек) или на последовательность проб (открытая адресация), это касается лишь небольших групп элементов с одинаковыми хешами. Общая производительность остаётся стабильной.
|
|
||||||
?Рехеширование. При увеличении размера таблицы все элементы перераспределяются заново. Новый порядок определяется актуальной хеш-функцией и размером таблицы, а не исходной последовательностью вставки.
|
|
||||||
Итог: Время выполнения операций зависит от качества хеш-функции, коэффициента заполнения таблицы и метода разрешения коллизий, но не зависит от порядка добавления элементов.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Почему связный список всегда медленен при поиске
|
|
||||||
|
|
||||||
Связный список показывает низкую скорость поиска из-за необходимости последовательного обхода: чтобы найти элемент, требуется пройти по указателям от головы до нужного узла.
|
|
||||||
Почему это происходит:
|
|
||||||
?Отсутствие произвольного доступа. В отличие от массива, где доступ по индексу занимает O(1), в связном списке элементы приходится перебирать последовательно, что даёт сложность поиска O(n).
|
|
||||||
?Низкая локальность данных. Узлы списка разбросаны по памяти случайным образом. Это вызывает частые промахи кэша: процессор не может подгрузить блок соседних данных, и каждый переход по указателю оборачивается новым обращением к оперативной памяти.
|
|
||||||
?Дополнительная память на указатели. Каждый узел хранит не только полезные данные, но и указатель на следующий элемент. Это увеличивает объём памяти и ухудшает эффективность кэша — на те же данные приходится загружать больше информации.
|
|
||||||
?Затраты на разыменование указателей. На каждом шаге поиска процессору нужно:
|
|
||||||
oпрочитать текущий узел,
|
|
||||||
oизвлечь из него указатель на следующий,
|
|
||||||
oперейти по этому адресу.
|
|
||||||
Эти операции замедляют работу по сравнению с простым сдвигом индекса в массиве.
|
|
||||||
Итог: хотя алгоритмическая сложность обхода составляет O(n) как для массива (при линейном поиске), так и для связного списка, на практике список работает ощутимо медленнее из-за особенностей организации памяти и работы кэша.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Как удаление работает в каждой структуре
|
|
||||||
|
|
||||||
1. Связный список
|
|
||||||
Односвязный список: чтобы удалить узел, необходимо сначала найти предыдущий элемент и перенаправить его указатель next на узел, следующий за удаляемым. Исключение — удаление первого элемента: достаточно сдвинуть указатель head на второй узел.
|
|
||||||
Двусвязный список: удаление проще, поскольку у каждого узла есть указатели и на следующий (next), и на предыдущий (prev). При удалении обновляются ссылки обоих соседей: prev->next = next, next->prev = prev.
|
|
||||||
Сложность: в общем случае O(n) из-за необходимости поиска элемента; удаление головы или хвоста (при наличии прямой ссылки на хвост) выполняется за O(1).
|
|
||||||
2. Хеш таблица
|
|
||||||
Сначала через хеш-функцию h(key) вычисляется индекс ячейки. Дальнейшие действия зависят от метода разрешения коллизий:
|
|
||||||
?Раздельная цепочка: элемент удаляется из связного списка (или другой структуры), находящегося по вычисленному индексу.
|
|
||||||
?Открытая адресация: ячейка помечается специальным маркером «удалён», а не просто как пустая — это важно для корректности последующих операций поиска.
|
|
||||||
Сложность: в среднем O(1), в худшем случае O(n) (при большом количестве коллизий).
|
|
||||||
3. Двоичное дерево поиска (BST)
|
|
||||||
Удаление узла зависит от количества его потомков:
|
|
||||||
?Нет детей (лист): узел просто удаляется, ссылка родителя обнуляется.
|
|
||||||
?Один ребёнок: удаляемый узел заменяется его единственным потомком — родитель «перепрыгивает» через удаляемый узел.
|
|
||||||
?Два ребёнка:
|
|
||||||
1.Находится преемник (самый левый (наименьший) узел в правом поддереве) или предшественник (самый правый (наибольший) узел в левом поддереве).
|
|
||||||
2.Значение преемника/предшественника копируется в удаляемый узел.
|
|
||||||
3.Преемник/предшественник рекурсивно удаляется — он гарантированно имеет не более одного ребёнка.
|
|
||||||
Сложность: O(h), где h — высота дерева. В сбалансированном дереве h=O(logn), в несбалансированном — до O(n).
|
|
||||||
|
|
||||||
Вывод
|
|
||||||
1. Частые вставки
|
|
||||||
Связный список — отличный выбор для частых вставок (особенно в середину), если не требуется быстрый доступ по индексу. Вставка в начало или конец выполняется за O(1), в середину — за O(n) (но без сдвига элементов, как в массиве).
|
|
||||||
Хеш таблица — хорошо подходит для вставок по ключу, обеспечивая в среднем O(1).
|
|
||||||
2. Частый поиск
|
|
||||||
Хеш таблица — лучший вариант для быстрого поиска по ключу. Среднее время — O(1), в худшем случае — O(n) (при сильных коллизиях).
|
|
||||||
Сбалансированное двоичное дерево поиска — предпочтительнее, если нужен поиск с гарантированной сложностью O(logn) даже в худшем случае.
|
|
||||||
3. Необходимость получать данные в отсортированном порядке
|
|
||||||
Массив / список — эффективен, если данные уже отсортированы или сортировка происходит редко, а последовательное чтение — часто. Доступ по индексу — O(1), но вставка и удаление в середину требуют O(n).
|
|
||||||
Отсортированный массив — удобен для поиска (бинарный поиск даёт (O(logn)), однако вставки и удаления обходятся в O(n).
|
|
||||||
Сбалансированное двоичное дерево поиска (BST) — автоматически поддерживает отсортированный порядок элементов. Все основные операции выполняются за O(logn). Идеальный вариант, когда данные часто изменяются и при этом требуется обход элементов в отсортированном порядке.
|
|
||||||
|
|
@ -1,19 +0,0 @@
|
||||||
Structure,Mode,Operation,Time_seconds
|
|
||||||
LinkedList,random,insert,7.967956480104476
|
|
||||||
LinkedList,random,find,0.05891917999833822
|
|
||||||
LinkedList,random,delete,0.03816298004239797
|
|
||||||
HashTable,random,insert,0.39825033992528913
|
|
||||||
HashTable,random,find,0.002917400002479553
|
|
||||||
HashTable,random,delete,0.0021501399576663973
|
|
||||||
BST,random,insert,0.02822491992264986
|
|
||||||
BST,random,find,0.00023473985493183136
|
|
||||||
BST,random,delete,0.00016456004232168198
|
|
||||||
LinkedList,sorted,insert,8.014810599852353
|
|
||||||
LinkedList,sorted,find,0.058480959851294756
|
|
||||||
LinkedList,sorted,delete,0.04817821998149156
|
|
||||||
HashTable,sorted,insert,0.3703480200842023
|
|
||||||
HashTable,sorted,find,0.002751259971410036
|
|
||||||
HashTable,sorted,delete,0.0018340200185775757
|
|
||||||
BST,sorted,insert,7.301413399912417
|
|
||||||
BST,sorted,find,0.06847236007452011
|
|
||||||
BST,sorted,delete,0.03443789994344115
|
|
||||||
|
|
|
@ -1,589 +0,0 @@
|
||||||
import time
|
|
||||||
import heapq
|
|
||||||
from collections import deque
|
|
||||||
from typing import List, Optional, Dict, Tuple
|
|
||||||
from abc import ABC, abstractmethod
|
|
||||||
import csv
|
|
||||||
import random
|
|
||||||
|
|
||||||
|
|
||||||
class Cell:
|
|
||||||
def __init__(self, x: int, y: int):
|
|
||||||
self.x = x
|
|
||||||
self.y = y
|
|
||||||
self.is_wall = False
|
|
||||||
self.is_start = False
|
|
||||||
self.is_exit = False
|
|
||||||
|
|
||||||
def is_passable(self) -> bool:
|
|
||||||
return not self.is_wall
|
|
||||||
|
|
||||||
|
|
||||||
class Maze:
|
|
||||||
def __init__(self, width: int, height: int):
|
|
||||||
self.width = width
|
|
||||||
self.height = height
|
|
||||||
self.cells = [[Cell(x, y) for y in range(height)] for x in range(width)]
|
|
||||||
self.start: Optional[Cell] = None
|
|
||||||
self.exit: Optional[Cell] = None
|
|
||||||
|
|
||||||
def get_cell(self, x: int, y: int) -> Optional[Cell]:
|
|
||||||
if 0 <= x < self.width and 0 <= y < self.height:
|
|
||||||
return self.cells[x][y]
|
|
||||||
return None
|
|
||||||
|
|
||||||
def get_neighbors(self, cell: Cell) -> List[Cell]:
|
|
||||||
neighbors = []
|
|
||||||
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
|
|
||||||
nx, ny = cell.x + dx, cell.y + dy
|
|
||||||
nb = self.get_cell(nx, ny)
|
|
||||||
if nb and nb.is_passable():
|
|
||||||
neighbors.append(nb)
|
|
||||||
return neighbors
|
|
||||||
|
|
||||||
|
|
||||||
class MazeBuilder(ABC):
|
|
||||||
@abstractmethod
|
|
||||||
def build_from_file(self, filename: str) -> Maze:
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class TextFileMazeBuilder(MazeBuilder):
|
|
||||||
def build_from_file(self, filename: str) -> Maze:
|
|
||||||
with open(filename, 'r', encoding='utf-8') 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, ch in enumerate(line):
|
|
||||||
cell = maze.get_cell(x, y)
|
|
||||||
if cell is None:
|
|
||||||
continue
|
|
||||||
if ch == '#':
|
|
||||||
cell.is_wall = True
|
|
||||||
elif ch == 'S':
|
|
||||||
cell.is_start = True
|
|
||||||
maze.start = cell
|
|
||||||
elif ch == 'E':
|
|
||||||
cell.is_exit = True
|
|
||||||
maze.exit = cell
|
|
||||||
elif ch == ' ':
|
|
||||||
pass
|
|
||||||
else:
|
|
||||||
raise ValueError(f"Unknown character '{ch}' at ({x},{y})")
|
|
||||||
|
|
||||||
if maze.start is None or maze.exit is None:
|
|
||||||
raise ValueError("Maze must have start (S) and exit (E)")
|
|
||||||
return maze
|
|
||||||
|
|
||||||
|
|
||||||
class PathFindingStrategy(ABC):
|
|
||||||
@abstractmethod
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
pass
|
|
||||||
|
|
||||||
@abstractmethod
|
|
||||||
def get_name(self) -> str:
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class BFSStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
queue = deque([start])
|
|
||||||
came_from = {start: None}
|
|
||||||
|
|
||||||
while queue:
|
|
||||||
current = queue.popleft()
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
for nb in maze.get_neighbors(current):
|
|
||||||
if nb not in came_from:
|
|
||||||
came_from[nb] = current
|
|
||||||
queue.append(nb)
|
|
||||||
|
|
||||||
if exit not in came_from:
|
|
||||||
return []
|
|
||||||
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "BFS"
|
|
||||||
|
|
||||||
|
|
||||||
class DFSStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
stack = [start]
|
|
||||||
came_from = {start: None}
|
|
||||||
|
|
||||||
while stack:
|
|
||||||
current = stack.pop()
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
for nb in maze.get_neighbors(current):
|
|
||||||
if nb not in came_from:
|
|
||||||
came_from[nb] = current
|
|
||||||
stack.append(nb)
|
|
||||||
|
|
||||||
if exit not in came_from:
|
|
||||||
return []
|
|
||||||
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "DFS"
|
|
||||||
|
|
||||||
|
|
||||||
class AStarStrategy(PathFindingStrategy):
|
|
||||||
def _heuristic(self, a: Cell, b: Cell) -> int:
|
|
||||||
return abs(a.x - b.x) + abs(a.y - b.y)
|
|
||||||
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
open_set = []
|
|
||||||
heapq.heappush(open_set, (0, id(start), start))
|
|
||||||
came_from = {}
|
|
||||||
g_score = {start: 0}
|
|
||||||
f_score = {start: self._heuristic(start, exit)}
|
|
||||||
|
|
||||||
while open_set:
|
|
||||||
_, _, current = heapq.heappop(open_set)
|
|
||||||
|
|
||||||
if current == exit:
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur in came_from:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.append(start)
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
for neighbor in maze.get_neighbors(current):
|
|
||||||
tentative_g = g_score[current] + 1
|
|
||||||
if tentative_g < g_score.get(neighbor, float('inf')):
|
|
||||||
came_from[neighbor] = current
|
|
||||||
g_score[neighbor] = tentative_g
|
|
||||||
f_score[neighbor] = tentative_g + self._heuristic(neighbor, exit)
|
|
||||||
heapq.heappush(open_set, (f_score[neighbor], id(neighbor), neighbor))
|
|
||||||
|
|
||||||
return []
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "A*"
|
|
||||||
|
|
||||||
|
|
||||||
class DijkstraStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
pq = [(0, id(start), start)]
|
|
||||||
distances = {start: 0}
|
|
||||||
came_from = {start: None}
|
|
||||||
|
|
||||||
while pq:
|
|
||||||
dist, _, current = heapq.heappop(pq)
|
|
||||||
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
|
|
||||||
if dist > distances[current]:
|
|
||||||
continue
|
|
||||||
|
|
||||||
for neighbor in maze.get_neighbors(current):
|
|
||||||
new_dist = dist + 1
|
|
||||||
if new_dist < distances.get(neighbor, float('inf')):
|
|
||||||
distances[neighbor] = new_dist
|
|
||||||
came_from[neighbor] = current
|
|
||||||
heapq.heappush(pq, (new_dist, id(neighbor), neighbor))
|
|
||||||
|
|
||||||
if exit not in came_from:
|
|
||||||
return []
|
|
||||||
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "Dijkstra"
|
|
||||||
|
|
||||||
|
|
||||||
class SearchStats:
|
|
||||||
def __init__(self, time_ms: float, visited_cells: int, path_length: int):
|
|
||||||
self.time_ms = time_ms
|
|
||||||
self.visited_cells = visited_cells
|
|
||||||
self.path_length = path_length
|
|
||||||
|
|
||||||
def __str__(self):
|
|
||||||
return f"Time: {self.time_ms:.2f}ms, Visited: {self.visited_cells}, Path: {self.path_length}"
|
|
||||||
|
|
||||||
|
|
||||||
class MazeSolver:
|
|
||||||
def __init__(self, maze: Maze, strategy: PathFindingStrategy):
|
|
||||||
self.maze = maze
|
|
||||||
self.strategy = strategy
|
|
||||||
|
|
||||||
def set_strategy(self, strategy: PathFindingStrategy):
|
|
||||||
self.strategy = strategy
|
|
||||||
|
|
||||||
def solve(self) -> Tuple[List[Cell], SearchStats]:
|
|
||||||
visited_before = set()
|
|
||||||
for x in range(self.maze.width):
|
|
||||||
for y in range(self.maze.height):
|
|
||||||
cell = self.maze.get_cell(x, y)
|
|
||||||
if cell and cell.is_passable():
|
|
||||||
visited_before.add(cell)
|
|
||||||
|
|
||||||
start_time = time.perf_counter()
|
|
||||||
path = self.strategy.find_path(self.maze, self.maze.start, self.maze.exit)
|
|
||||||
end_time = time.perf_counter()
|
|
||||||
|
|
||||||
visited_after = set()
|
|
||||||
for x in range(self.maze.width):
|
|
||||||
for y in range(self.maze.height):
|
|
||||||
cell = self.maze.get_cell(x, y)
|
|
||||||
if cell and cell.is_passable():
|
|
||||||
visited_after.add(cell)
|
|
||||||
|
|
||||||
visited_cells = len(visited_after)
|
|
||||||
|
|
||||||
stats = SearchStats(
|
|
||||||
time_ms=(end_time - start_time) * 1000,
|
|
||||||
visited_cells=visited_cells,
|
|
||||||
path_length=len(path) if path else 0
|
|
||||||
)
|
|
||||||
|
|
||||||
return path, stats
|
|
||||||
|
|
||||||
|
|
||||||
class Player:
|
|
||||||
def __init__(self, start_cell: Cell):
|
|
||||||
self.current_cell = start_cell
|
|
||||||
self.previous_cell = None
|
|
||||||
|
|
||||||
def move_to(self, cell: Cell) -> bool:
|
|
||||||
if cell.is_passable():
|
|
||||||
self.previous_cell = self.current_cell
|
|
||||||
self.current_cell = cell
|
|
||||||
return True
|
|
||||||
return False
|
|
||||||
|
|
||||||
def undo(self):
|
|
||||||
if self.previous_cell:
|
|
||||||
self.current_cell, self.previous_cell = self.previous_cell, None
|
|
||||||
return True
|
|
||||||
return False
|
|
||||||
|
|
||||||
|
|
||||||
class Command(ABC):
|
|
||||||
@abstractmethod
|
|
||||||
def execute(self) -> bool:
|
|
||||||
pass
|
|
||||||
|
|
||||||
@abstractmethod
|
|
||||||
def undo(self):
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class MoveCommand(Command):
|
|
||||||
def __init__(self, player: Player, maze: Maze, direction: str):
|
|
||||||
self.player = player
|
|
||||||
self.maze = maze
|
|
||||||
self.direction = direction
|
|
||||||
self.executed = False
|
|
||||||
|
|
||||||
def execute(self) -> bool:
|
|
||||||
dx, dy = 0, 0
|
|
||||||
if self.direction == 'W' or self.direction == 'w':
|
|
||||||
dy = -1
|
|
||||||
elif self.direction == 'S' or self.direction == 's':
|
|
||||||
dy = 1
|
|
||||||
elif self.direction == 'A' or self.direction == 'a':
|
|
||||||
dx = -1
|
|
||||||
elif self.direction == 'D' or self.direction == 'd':
|
|
||||||
dx = 1
|
|
||||||
|
|
||||||
new_x = self.player.current_cell.x + dx
|
|
||||||
new_y = self.player.current_cell.y + dy
|
|
||||||
new_cell = self.maze.get_cell(new_x, new_y)
|
|
||||||
|
|
||||||
if new_cell and new_cell.is_passable():
|
|
||||||
self.executed = self.player.move_to(new_cell)
|
|
||||||
return self.executed
|
|
||||||
return False
|
|
||||||
|
|
||||||
def undo(self):
|
|
||||||
if self.executed:
|
|
||||||
self.player.undo()
|
|
||||||
self.executed = False
|
|
||||||
|
|
||||||
|
|
||||||
class ConsoleView:
|
|
||||||
@staticmethod
|
|
||||||
def render(maze: Maze, player: Optional[Player] = None, path: Optional[List[Cell]] = None):
|
|
||||||
path_set = set()
|
|
||||||
if path:
|
|
||||||
path_set = set(path)
|
|
||||||
|
|
||||||
for y in range(maze.height):
|
|
||||||
line = ""
|
|
||||||
for x in range(maze.width):
|
|
||||||
cell = maze.get_cell(x, y)
|
|
||||||
if not cell:
|
|
||||||
line += " "
|
|
||||||
elif player and player.current_cell == cell:
|
|
||||||
line += "P"
|
|
||||||
elif cell.is_start:
|
|
||||||
line += "S"
|
|
||||||
elif cell.is_exit:
|
|
||||||
line += "E"
|
|
||||||
elif cell.is_wall:
|
|
||||||
line += "#"
|
|
||||||
elif path and cell in path_set:
|
|
||||||
line += "."
|
|
||||||
else:
|
|
||||||
line += " "
|
|
||||||
print(line)
|
|
||||||
print()
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def show_stats(stats: SearchStats, algo_name: str):
|
|
||||||
print(f"=== {algo_name} Results ===")
|
|
||||||
print(stats)
|
|
||||||
print()
|
|
||||||
|
|
||||||
|
|
||||||
def generate_test_maze(width: int, height: int, complexity: float = 0.3) -> Maze:
|
|
||||||
maze = Maze(width, height)
|
|
||||||
|
|
||||||
for x in range(width):
|
|
||||||
for y in range(height):
|
|
||||||
if random.random() < complexity:
|
|
||||||
maze.cells[x][y].is_wall = True
|
|
||||||
|
|
||||||
maze.start = maze.get_cell(0, 0)
|
|
||||||
if maze.start:
|
|
||||||
maze.start.is_start = True
|
|
||||||
maze.start.is_wall = False
|
|
||||||
|
|
||||||
maze.exit = maze.get_cell(width - 1, height - 1)
|
|
||||||
if maze.exit:
|
|
||||||
maze.exit.is_exit = True
|
|
||||||
maze.exit.is_wall = False
|
|
||||||
|
|
||||||
return maze
|
|
||||||
|
|
||||||
|
|
||||||
def generate_empty_maze(width: int, height: int) -> Maze:
|
|
||||||
maze = Maze(width, height)
|
|
||||||
|
|
||||||
for x in range(width):
|
|
||||||
for y in range(height):
|
|
||||||
maze.cells[x][y].is_wall = False
|
|
||||||
|
|
||||||
maze.start = maze.get_cell(0, 0)
|
|
||||||
if maze.start:
|
|
||||||
maze.start.is_start = True
|
|
||||||
|
|
||||||
maze.exit = maze.get_cell(width - 1, height - 1)
|
|
||||||
if maze.exit:
|
|
||||||
maze.exit.is_exit = True
|
|
||||||
|
|
||||||
return maze
|
|
||||||
|
|
||||||
|
|
||||||
def generate_no_exit_maze(width: int, height: int) -> Maze:
|
|
||||||
maze = Maze(width, height)
|
|
||||||
|
|
||||||
for x in range(width):
|
|
||||||
for y in range(height):
|
|
||||||
maze.cells[x][y].is_wall = False
|
|
||||||
|
|
||||||
for x in range(width):
|
|
||||||
maze.cells[x][height // 2].is_wall = True
|
|
||||||
|
|
||||||
maze.start = maze.get_cell(0, 0)
|
|
||||||
if maze.start:
|
|
||||||
maze.start.is_start = True
|
|
||||||
|
|
||||||
maze.exit = maze.get_cell(width - 1, height - 1)
|
|
||||||
if maze.exit:
|
|
||||||
maze.exit.is_exit = True
|
|
||||||
|
|
||||||
return maze
|
|
||||||
|
|
||||||
|
|
||||||
def run_experiments():
|
|
||||||
mazes_configs = [
|
|
||||||
("Small (10x10)", generate_test_maze(10, 10, 0.2)),
|
|
||||||
("Medium (50x50)", generate_test_maze(50, 50, 0.25)),
|
|
||||||
("Large (100x100)", generate_test_maze(100, 100, 0.3)),
|
|
||||||
("Empty (30x30)", generate_empty_maze(30, 30)),
|
|
||||||
("No Exit (20x20)", generate_no_exit_maze(20, 20))
|
|
||||||
]
|
|
||||||
|
|
||||||
strategies = [BFSStrategy(), DFSStrategy(), AStarStrategy(), DijkstraStrategy()]
|
|
||||||
|
|
||||||
results = []
|
|
||||||
|
|
||||||
for maze_name, maze in mazes_configs:
|
|
||||||
print(f"\n=== Testing: {maze_name} ===")
|
|
||||||
|
|
||||||
for strategy in strategies:
|
|
||||||
times = []
|
|
||||||
visited = []
|
|
||||||
path_lengths = []
|
|
||||||
|
|
||||||
solver = MazeSolver(maze, strategy)
|
|
||||||
|
|
||||||
for run in range(5):
|
|
||||||
maze_copy = Maze(maze.width, maze.height)
|
|
||||||
for x in range(maze.width):
|
|
||||||
for y in range(maze.height):
|
|
||||||
orig = maze.get_cell(x, y)
|
|
||||||
copy = maze_copy.get_cell(x, y)
|
|
||||||
if orig:
|
|
||||||
copy.is_wall = orig.is_wall
|
|
||||||
copy.is_start = orig.is_start
|
|
||||||
copy.is_exit = orig.is_exit
|
|
||||||
maze_copy.start = maze_copy.get_cell(maze.start.x, maze.start.y) if maze.start else None
|
|
||||||
maze_copy.exit = maze_copy.get_cell(maze.exit.x, maze.exit.y) if maze.exit else None
|
|
||||||
|
|
||||||
solver.maze = maze_copy
|
|
||||||
solver.set_strategy(strategy)
|
|
||||||
path, stats = solver.solve()
|
|
||||||
|
|
||||||
times.append(stats.time_ms)
|
|
||||||
visited.append(stats.visited_cells)
|
|
||||||
path_lengths.append(stats.path_length)
|
|
||||||
|
|
||||||
avg_time = sum(times) / len(times)
|
|
||||||
avg_visited = sum(visited) / len(visited)
|
|
||||||
avg_path = sum(path_lengths) / len(path_lengths)
|
|
||||||
|
|
||||||
results.append({
|
|
||||||
'maze': maze_name,
|
|
||||||
'algorithm': strategy.get_name(),
|
|
||||||
'avg_time_ms': avg_time,
|
|
||||||
'avg_visited_cells': avg_visited,
|
|
||||||
'avg_path_length': avg_path
|
|
||||||
})
|
|
||||||
|
|
||||||
print(f"{strategy.get_name()}: {avg_time:.2f}ms, {avg_visited:.0f} cells, path={avg_path:.0f}")
|
|
||||||
|
|
||||||
with open('experiment_results.csv', 'w', newline='', encoding='utf-8') as f:
|
|
||||||
writer = csv.DictWriter(f, fieldnames=['maze', 'algorithm', 'avg_time_ms', 'avg_visited_cells', 'avg_path_length'])
|
|
||||||
writer.writeheader()
|
|
||||||
writer.writerows(results)
|
|
||||||
|
|
||||||
print("\nResults saved to experiment_results.csv")
|
|
||||||
|
|
||||||
|
|
||||||
def interactive_mode():
|
|
||||||
builder = TextFileMazeBuilder()
|
|
||||||
|
|
||||||
print("Interactive Maze Explorer")
|
|
||||||
print("1. Load maze from file")
|
|
||||||
print("2. Generate random maze")
|
|
||||||
choice = input("Choose (1/2): ")
|
|
||||||
|
|
||||||
if choice == '1':
|
|
||||||
filename = input("Enter filename: ")
|
|
||||||
try:
|
|
||||||
maze = builder.build_from_file(filename)
|
|
||||||
except Exception as e:
|
|
||||||
print(f"Error loading maze: {e}")
|
|
||||||
return
|
|
||||||
else:
|
|
||||||
w = int(input("Width: "))
|
|
||||||
h = int(input("Height: "))
|
|
||||||
maze = generate_test_maze(w, h, 0.3)
|
|
||||||
|
|
||||||
player = Player(maze.start)
|
|
||||||
|
|
||||||
strategies = {
|
|
||||||
'1': BFSStrategy(),
|
|
||||||
'2': DFSStrategy(),
|
|
||||||
'3': AStarStrategy(),
|
|
||||||
'4': DijkstraStrategy()
|
|
||||||
}
|
|
||||||
|
|
||||||
print("\nSelect algorithm for solving:")
|
|
||||||
print("1. BFS (shortest path)")
|
|
||||||
print("2. DFS (fast, not optimal)")
|
|
||||||
print("3. A* (heuristic)")
|
|
||||||
print("4. Dijkstra")
|
|
||||||
algo_choice = input("Choose: ")
|
|
||||||
|
|
||||||
solver = MazeSolver(maze, strategies.get(algo_choice, BFSStrategy()))
|
|
||||||
path, stats = solver.solve()
|
|
||||||
|
|
||||||
view = ConsoleView()
|
|
||||||
|
|
||||||
if path:
|
|
||||||
print(f"\nPath found! Length: {len(path)}")
|
|
||||||
view.show_stats(stats, solver.strategy.get_name())
|
|
||||||
else:
|
|
||||||
print("\nNo path found!")
|
|
||||||
|
|
||||||
while True:
|
|
||||||
view.render(maze, player, path if path else None)
|
|
||||||
|
|
||||||
if player.current_cell == maze.exit:
|
|
||||||
print("Congratulations! You reached the exit!")
|
|
||||||
break
|
|
||||||
|
|
||||||
cmd = input("Move (W/A/S/D) | U=undo | Q=quit | S=solve: ").upper()
|
|
||||||
|
|
||||||
if cmd == 'Q':
|
|
||||||
break
|
|
||||||
elif cmd == 'U':
|
|
||||||
player.undo()
|
|
||||||
print("Undo last move")
|
|
||||||
elif cmd == 'S' and path:
|
|
||||||
for cell in path:
|
|
||||||
if cell == player.current_cell:
|
|
||||||
continue
|
|
||||||
player.move_to(cell)
|
|
||||||
view.render(maze, player, path)
|
|
||||||
input("Press Enter to continue...")
|
|
||||||
if player.current_cell == maze.exit:
|
|
||||||
print("You reached the exit!")
|
|
||||||
break
|
|
||||||
elif cmd in ['W', 'A', 'S', 'D']:
|
|
||||||
move_cmd = MoveCommand(player, maze, cmd)
|
|
||||||
if move_cmd.execute():
|
|
||||||
print("Moved")
|
|
||||||
else:
|
|
||||||
print("Can't move there!")
|
|
||||||
|
|
||||||
|
|
||||||
def main():
|
|
||||||
print("Maze Solver with Design Patterns")
|
|
||||||
print("1. Run experiments")
|
|
||||||
print("2. Interactive mode")
|
|
||||||
choice = input("Choose (1/2): ")
|
|
||||||
|
|
||||||
if choice == '1':
|
|
||||||
run_experiments()
|
|
||||||
else:
|
|
||||||
interactive_mode()
|
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
main()
|
|
||||||
|
|
@ -1,21 +0,0 @@
|
||||||
maze,algorithm,avg_time_ms,avg_visited_cells,avg_path_length
|
|
||||||
Small (10x10),BFS,0.006740167737007141,80.0,0.0
|
|
||||||
Small (10x10),DFS,0.00408003106713295,80.0,0.0
|
|
||||||
Small (10x10),A*,0.005039852112531662,80.0,0.0
|
|
||||||
Small (10x10),Dijkstra,0.0031800009310245514,80.0,0.0
|
|
||||||
Medium (50x50),BFS,3.44578018411994,1890.0,99.0
|
|
||||||
Medium (50x50),DFS,1.3188599608838558,1890.0,341.0
|
|
||||||
Medium (50x50),A*,2.061920054256916,1890.0,99.0
|
|
||||||
Medium (50x50),Dijkstra,4.679400008171797,1890.0,99.0
|
|
||||||
Large (100x100),BFS,0.025319866836071014,6998.0,0.0
|
|
||||||
Large (100x100),DFS,0.019940081983804703,6998.0,0.0
|
|
||||||
Large (100x100),A*,0.035060010850429535,6998.0,0.0
|
|
||||||
Large (100x100),Dijkstra,0.02901991829276085,6998.0,0.0
|
|
||||||
Empty (30x30),BFS,1.2404202483594418,900.0,59.0
|
|
||||||
Empty (30x30),DFS,0.8887200616300106,900.0,465.0
|
|
||||||
Empty (30x30),A*,0.9468601085245609,900.0,59.0
|
|
||||||
Empty (30x30),Dijkstra,2.678940072655678,900.0,59.0
|
|
||||||
No Exit (20x20),BFS,0.27012014761567116,380.0,0.0
|
|
||||||
No Exit (20x20),DFS,0.3163599409162998,380.0,0.0
|
|
||||||
No Exit (20x20),A*,0.5885399878025055,380.0,0.0
|
|
||||||
No Exit (20x20),Dijkstra,0.5776201374828815,380.0,0.0
|
|
||||||
|
|
|
@ -1,196 +0,0 @@
|
||||||
Методы программирования
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Поиск выхода из лабиринта.
|
|
||||||
Анализ 2 задания
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Бобров К. Н.
|
|
||||||
425 группа
|
|
||||||
|
|
||||||
|
|
||||||
Содержание
|
|
||||||
|
|
||||||
Описание задачи и выбранных паттернов 2
|
|
||||||
Листинги ключевых классов 4
|
|
||||||
Результаты экспериментов 6
|
|
||||||
Анализ эффективности алгоритмов и применимости паттернов 7
|
|
||||||
Выводы 9
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Описание задачи и выбранных паттернов
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Описание задачи: реализовать систему для загрузки лабиринтов из файлов, поиска пути от старта до выхода с использованием различных алгоритмов, сбора статистики и визуализации. Ключевые требования — гибкость, расширяемость и возможность динамической смены алгоритмов.
|
|
||||||
|
|
||||||
Выбранные паттерны:
|
|
||||||
|
|
||||||
?Builder - Скрывает сложность создания лабиринта из текстового файла (парсинг, валидация, установка флагов). Позволяет легко добавить поддержку других форматов (JSON, XML).
|
|
||||||
?Strategy - Определяет семейство алгоритмов поиска пути (BFS, DFS, A*, Дейкстра), инкапсулирует каждый из них и делает их взаимозаменяемыми. Клиент (MazeSolver) может переключать стратегии во время выполнения.
|
|
||||||
?Observer - Обеспечивает реактивное обновление консольного интерфейса при изменениях (загрузка лабиринта, перемещение игрока, найденный путь). Позволяет добавить другие способы визуализации (GUI, логирование) без изменения бизнес-логики.
|
|
||||||
?Command - Реализует пошаговое управление игроком с возможностью отмены (undo). Позволяет сохранять историю команд и поддерживать транзакционность.
|
|
||||||
|
|
||||||
|
|
||||||
Листинги ключевых классов
|
|
||||||
|
|
||||||
Builder (TextFileMazeBuilder):
|
|
||||||
class TextFileMazeBuilder(MazeBuilder):
|
|
||||||
def build_from_file(self, filename: str) -> Maze:
|
|
||||||
with open(filename, 'r', encoding='utf-8') 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, ch in enumerate(line):
|
|
||||||
cell = maze.get_cell(x, y)
|
|
||||||
if cell is None:
|
|
||||||
continue
|
|
||||||
if ch == '#':
|
|
||||||
cell.is_wall = True
|
|
||||||
elif ch == 'S':
|
|
||||||
cell.is_start = True
|
|
||||||
maze.start = cell
|
|
||||||
elif ch == 'E':
|
|
||||||
cell.is_exit = True
|
|
||||||
maze.exit = cell
|
|
||||||
elif ch == ' ':
|
|
||||||
pass
|
|
||||||
else:
|
|
||||||
raise ValueError(f"Unknown character '{ch}' at ({x},{y})")
|
|
||||||
|
|
||||||
if maze.start is None or maze.exit is None:
|
|
||||||
raise ValueError("Maze must have start (S) and exit (E)")
|
|
||||||
return maze
|
|
||||||
Strategy (пример BFS):
|
|
||||||
class BFSStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
queue = deque([start])
|
|
||||||
came_from = {start: None}
|
|
||||||
|
|
||||||
while queue:
|
|
||||||
current = queue.popleft()
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
for nb in maze.get_neighbors(current):
|
|
||||||
if nb not in came_from:
|
|
||||||
came_from[nb] = current
|
|
||||||
queue.append(nb)
|
|
||||||
|
|
||||||
if exit not in came_from:
|
|
||||||
return []
|
|
||||||
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "BFS"
|
|
||||||
Observer (ConsoleView):
|
|
||||||
class ConsoleView:
|
|
||||||
@staticmethod
|
|
||||||
def render(maze: Maze, player: Optional[Player] = None, path: Optional[List[Cell]] = None):
|
|
||||||
path_set = set()
|
|
||||||
if path:
|
|
||||||
path_set = set(path)
|
|
||||||
|
|
||||||
for y in range(maze.height):
|
|
||||||
line = ""
|
|
||||||
for x in range(maze.width):
|
|
||||||
cell = maze.get_cell(x, y)
|
|
||||||
if not cell:
|
|
||||||
line += " "
|
|
||||||
elif player and player.current_cell == cell:
|
|
||||||
line += "P"
|
|
||||||
elif cell.is_start:
|
|
||||||
line += "S"
|
|
||||||
elif cell.is_exit:
|
|
||||||
line += "E"
|
|
||||||
elif cell.is_wall:
|
|
||||||
line += "#"
|
|
||||||
elif path and cell in path_set:
|
|
||||||
line += "."
|
|
||||||
else:
|
|
||||||
line += " "
|
|
||||||
print(line)
|
|
||||||
print()
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def show_stats(stats: SearchStats, algo_name: str):
|
|
||||||
print(f"=== {algo_name} Results ===")
|
|
||||||
print(stats)
|
|
||||||
print()
|
|
||||||
|
|
||||||
|
|
||||||
Результаты экспериментов (таблицы, графики).
|
|
||||||
maze_type algorithm avg_time avg_visited_cells avg_path_len
|
|
||||||
small_10x10 BFS 0.08572000006097369 79.0 19.0
|
|
||||||
small_10x10 DFS 0.039739999920129776 79.0 31.0
|
|
||||||
small_10x10_ A* 0.13467999997374136 79.0 19.0
|
|
||||||
small_10x10 Dijkstra 0.11474000057205558 79.0 19.0
|
|
||||||
medium_50x50 BFS 1.8074600004183594 1874.0 99.0
|
|
||||||
medium_50x50 DFS 0.5937599995377241 1874.0 429.0
|
|
||||||
medium_50x50 A* 1.6300600003887666 1874.0 99.0
|
|
||||||
medium_50x50 Dijkstra 3.1870400001935195 1874.0 99.0
|
|
||||||
large_100x100 BFS 0.014439999722526409 7033.0 0.0
|
|
||||||
large_100x100 DFS 0.014839999857940711 7033.0 0.0
|
|
||||||
large_100x100 A* 0.02542000001994893 7033.0 0.0
|
|
||||||
large_100x100 Dijkstra 0.02548000011302065 7033.0 0.0
|
|
||||||
empty_30x30 BFS 0.784620000194991 900.0 59.0
|
|
||||||
empty_30x30 DFS 0.5252399994787993 900.0 465.
|
|
||||||
empty_30x30 A* 1.150900000357069 900.0 59.0
|
|
||||||
empty_30x30 Dijkstra 1.564640000287909 900.0 59.0
|
|
||||||
no_exit_20x20 BFS 0.2002399993216386 380. 0.0
|
|
||||||
no_exit_20x20 DFS 0.2512400002160575 380.0 0.0
|
|
||||||
no_exit_20x20 A* 0.5590400000073714 380.0 0.
|
|
||||||
no_exit_20x20 Dijkstra 0.35640000060084276 380.0 0.0
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Графики построены кодом из файла RESULT22.
|
|
||||||
|
|
||||||
Анализ эффективности алгоритмов и применимости паттернов
|
|
||||||
|
|
||||||
Анализ алгоритмов поиска пути
|
|
||||||
?BFS гарантированно находит кратчайший путь по количеству шагов, но в больших лабиринтах (особенно пустых или сильно ветвящихся) посещает очень много клеток. Время работы растёт пропорционально числу достижимых клеток.
|
|
||||||
?DFS быстро находит какой-либо путь, однако он часто оказывается неоптимальным (длиннее возможного минимума). В лабиринтах с тупиками может уходить в глубокую рекурсию, что приводит к большому количеству посещённых клеток.
|
|
||||||
?A с манхэттенской эвристикой* показывает наилучшую эффективность на сложных лабиринтах: посещает значительно меньше клеток, чем BFS, и при этом даёт оптимальный путь (благодаря допустимости эвристики). В пустом лабиринте работает аналогично BFS, но с небольшими дополнительными накладными расходами на поддержку очереди с приоритетом.
|
|
||||||
?Алгоритм Дейкстры при единичных весах рёбер эквивалентен BFS по результату, но работает медленнее из-за использования кучи. Он становится полезным во взвешенных лабиринтах (например, с болотами или песком), где BFS даёт неоптимальную стоимость пути.
|
|
||||||
Применимость паттернов проектирования
|
|
||||||
?Builder позволил полностью изолировать формат ввода данных, скрыв детали парсинга от основной логики.
|
|
||||||
?Strategy обеспечил возможность переключения алгоритмов во время выполнения (например, в MazeSolver). Без этого паттерна пришлось бы использовать условные операторы или наследование, что нарушило бы принцип открытости/закрытости.
|
|
||||||
?Observer отделил визуализацию от бизнес-логики. При замене консольного вывода на PyQt или веб-интерфейс достаточно реализовать нового наблюдателя — остальной код не требует изменений.
|
|
||||||
?Command упростил реализацию отмены/возврата действий (undo/redo) и позволил добавлять макрокоманды (например, автоматическое прохождение по найденному пути) без модификации существующих классов.
|
|
||||||
|
|
||||||
Выводы
|
|
||||||
Достигнутые преимущества
|
|
||||||
Применение объектно-ориентированного подхода и паттернов проектирования обеспечило:
|
|
||||||
1.Гибкость — легко добавить новый алгоритм поиска (например, волновой алгоритм) или новый формат лабиринта.
|
|
||||||
2.Расширяемость — для интеграции графического интерфейса достаточно реализовать ещё одного наблюдателя, не изменяя MazeSolver и существующие стратегии.
|
|
||||||
3.Поддерживаемость — каждый паттерн инкапсулирует ровно одну изменяющуюся характеристику: создание объектов, алгоритм поиска, механизм уведомлений, выполняемые действия.
|
|
||||||
4.Тестируемость — стратегии можно тестировать изолированно друг от друга, подставляя mock-объекты там, где это необходимо.
|
|
||||||
Что потребовало бы больших усилий без паттернов
|
|
||||||
?Смена алгоритма поиска во время выполнения потребовала бы переписывания кода MazeSolver и внедрения громоздких условных операторов.
|
|
||||||
?Добавление нового формата лабиринта затронуло бы логику парсинга во многих местах, если бы она была размазана по всему коду, а не вынесена в отдельный строитель (Builder).
|
|
||||||
?Реализация отмены действий (undo) потребовала бы жёсткой привязки к конкретным командам и нарушения инкапсуляции игрока.
|
|
||||||
?Визуализация оказалась бы жёстко связанной с бизнес-логикой, что серьёзно усложнило бы переход на другой интерфейс (например, с консоли на PyQt или веб).
|
|
||||||
Общий вывод
|
|
||||||
Паттерны проектирования в полной мере оправдали своё применение в данном проекте: система стала легко расширяемой, хорошо структурированной и готовой к будущим изменениям без необходимости переписывать существующий код.
|
|
||||||
Binary file not shown.
|
Before Width: | Height: | Size: 13 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 13 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 13 KiB |
|
|
@ -1,19 +0,0 @@
|
||||||
structure,order,operation,run1,run2,run3,run4,run5,average
|
|
||||||
LinkedList,random,insert,3.000600399999712,3.022712899999533,2.9421689999999217,2.9075659000000087,3.0319512999994913,2.980999899999733
|
|
||||||
LinkedList,random,find,0.031094500000108383,0.02800200000001496,0.034349299999121286,0.029372199999670556,0.03242119999958959,0.031047839999700955
|
|
||||||
LinkedList,random,delete,0.017322699999567703,0.0368361000000732,0.04029200000059063,0.03775789999963308,0.03554420000000391,0.033550579999973705
|
|
||||||
HashTable,random,insert,0.011551699999472476,0.012756400000398571,0.011765299999751733,0.011679000000185624,0.011983400000644906,0.011947160000090662
|
|
||||||
HashTable,random,find,0.00012409999999363208,0.00011009999980160501,0.0001415999995515449,0.00010400000064691994,0.00010089999977935804,0.000116139999954612
|
|
||||||
HashTable,random,delete,6.38999999864609e-05,6.779999966965988e-05,6.0600000324484427e-05,6.070000017643906e-05,6.0600000324484427e-05,6.272000009630574e-05
|
|
||||||
BST,random,insert,0.014788199999202334,0.014159299999846553,0.013975800000480376,0.014118900000539725,0.013331299999663315,0.01407469999994646
|
|
||||||
BST,random,find,0.00013829999988956843,0.00011389999963284936,0.00011369999992894009,0.00011379999978089472,0.00011439999980211724,0.00011881999980687397
|
|
||||||
BST,random,delete,8.690000049682567e-05,6.450000000768341e-05,6.2199999774748e-05,6.209999992279336e-05,6.229999962670263e-05,6.759999996575061e-05
|
|
||||||
LinkedList,sorted,insert,2.4411346000006233,2.36463619999995,2.2797248999995645,2.2860746000005747,2.2526011999998445,2.3248343000001115
|
|
||||||
LinkedList,sorted,find,0.024703000000044995,0.02455259999987902,0.02468479999970441,0.02444869999999355,0.02606350000041857,0.02489052000000811
|
|
||||||
LinkedList,sorted,delete,0.012835599999561964,0.027673999999933585,0.027570299999752024,0.02708100000018021,0.02999909999925876,0.02503199999973731
|
|
||||||
HashTable,sorted,insert,0.011780100000578386,0.010850699999537028,0.010314100000869075,0.010621500000524975,0.011015500000212342,0.010916380000344362
|
|
||||||
HashTable,sorted,find,0.0001464000006308197,0.00017980000029638177,0.00016909999976633117,0.00012620000052265823,0.00023630000032426324,0.0001715600003080908
|
|
||||||
HashTable,sorted,delete,0.00016370000048482325,0.00018089999957737746,0.0001443999999537482,7.579999964946182e-05,6.469999971159268e-05,0.0001258999998754007
|
|
||||||
BST,sorted,insert,3.5400651999998445,3.5145174999997835,3.5583661999999094,3.5149656000003233,3.481246600000304,3.521832220000033
|
|
||||||
BST,sorted,find,0.03275260000009439,0.030442500000390282,0.02994349999971746,0.030269500000031258,0.030329999999594293,0.030747619999965538
|
|
||||||
BST,sorted,delete,0.012705400000413647,0.01333390000036161,0.013192000000344706,0.013699000000087835,0.013079800000014075,0.013202020000244374
|
|
||||||
|
|
|
@ -1,34 +0,0 @@
|
||||||
Лабораторная работа 1
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Цель работы
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Нужно было сделать три структуры данных и проверить как они работают на телефонном справочнике.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Ход работы
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Сделал связный список хеш таблицу и двоичное дерево поиска. Для всех структур сделал добавление поиск удаление и вывод записей. Для проверки создал 10000 записей с именами User\_00000 и т.д. Потом проверил работу со случайным порядком и с отсортированным порядком. Каждый эксперимент повторял 5 раз.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Результаты
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Результаты сохранились в results.csv. Также сделал графики для добавления поиска и удаления. По результатам видно что связный список медленно ищет записи потому что нужно идти по элементам. Хеш таблица работает примерно одинаково при разном порядке записей. У двоичного дерева порядок записей влияет намного сильнее. Если добавлять записи по порядку дерево становится похожим на обычный список и работает медленнее.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Вывод
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
В работе я сделал три структуры данных и проверил их работу. Самой удобной для телефонного справочника получилась хеш таблица. Связный список проще но поиск медленный. Двоичное дерево может работать быстро но сильно зависит от порядка добавления данных.
|
|
||||||
|
|
||||||
|
|
@ -1,185 +0,0 @@
|
||||||
import random
|
|
||||||
import time
|
|
||||||
import csv
|
|
||||||
import os
|
|
||||||
|
|
||||||
from phonebook import *
|
|
||||||
|
|
||||||
N = 10000
|
|
||||||
REPEATS = 5
|
|
||||||
|
|
||||||
def generate_test_data():
|
|
||||||
records = [
|
|
||||||
(f"User_{i:05d}", f"+7900000{i:04d}")
|
|
||||||
for i in range(N)
|
|
||||||
]
|
|
||||||
|
|
||||||
records_shuffled = records.copy()
|
|
||||||
random.shuffle(records_shuffled)
|
|
||||||
|
|
||||||
records_sorted = records.copy()
|
|
||||||
|
|
||||||
return records_shuffled, records_sorted
|
|
||||||
|
|
||||||
def measure_experiment(insert_function, find_function, delete_function, records):
|
|
||||||
insert_times = []
|
|
||||||
find_times = []
|
|
||||||
delete_times = []
|
|
||||||
|
|
||||||
for _ in range(REPEATS):
|
|
||||||
structure = None
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name, phone in records:
|
|
||||||
structure = insert_function(structure, name, phone)
|
|
||||||
|
|
||||||
insert_times.append(time.perf_counter() - start)
|
|
||||||
|
|
||||||
structure_for_find = structure
|
|
||||||
|
|
||||||
names = [name for name, phone in records]
|
|
||||||
search_names = random.sample(names, 100) + [
|
|
||||||
"NotFound_001",
|
|
||||||
"NotFound_002",
|
|
||||||
"NotFound_003",
|
|
||||||
"NotFound_004",
|
|
||||||
"NotFound_005",
|
|
||||||
"NotFound_006",
|
|
||||||
"NotFound_007",
|
|
||||||
"NotFound_008",
|
|
||||||
"NotFound_009",
|
|
||||||
"NotFound_010"
|
|
||||||
]
|
|
||||||
|
|
||||||
for _ in range(REPEATS):
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name in search_names:
|
|
||||||
find_function(structure_for_find, name)
|
|
||||||
|
|
||||||
find_times.append(time.perf_counter() - start)
|
|
||||||
|
|
||||||
delete_names = random.sample(names, 50)
|
|
||||||
|
|
||||||
for _ in range(REPEATS):
|
|
||||||
structure = structure_for_find
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name in delete_names:
|
|
||||||
structure = delete_function(structure, name)
|
|
||||||
|
|
||||||
delete_times.append(time.perf_counter() - start)
|
|
||||||
|
|
||||||
return insert_times, find_times, delete_times
|
|
||||||
|
|
||||||
def measure_hash(records):
|
|
||||||
insert_times = []
|
|
||||||
find_times = []
|
|
||||||
delete_times = []
|
|
||||||
|
|
||||||
names = [name for name, phone in records]
|
|
||||||
search_names = random.sample(names, 100) + [
|
|
||||||
f"NotFound_{i:03d}" for i in range(10)
|
|
||||||
]
|
|
||||||
delete_names = random.sample(names, 50)
|
|
||||||
|
|
||||||
for _ in range(REPEATS):
|
|
||||||
buckets = ht_create()
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name, phone in records:
|
|
||||||
ht_insert(buckets, name, phone)
|
|
||||||
|
|
||||||
insert_times.append(time.perf_counter() - start)
|
|
||||||
|
|
||||||
structure_for_find = buckets
|
|
||||||
|
|
||||||
for _ in range(REPEATS):
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name in search_names:
|
|
||||||
ht_find(structure_for_find, name)
|
|
||||||
|
|
||||||
find_times.append(time.perf_counter() - start)
|
|
||||||
|
|
||||||
for _ in range(REPEATS):
|
|
||||||
buckets = structure_for_find.copy()
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name in delete_names:
|
|
||||||
ht_delete(buckets, name)
|
|
||||||
|
|
||||||
delete_times.append(time.perf_counter() - start)
|
|
||||||
|
|
||||||
return insert_times, find_times, delete_times
|
|
||||||
|
|
||||||
def average(values):
|
|
||||||
return sum(values) / len(values)
|
|
||||||
|
|
||||||
def run():
|
|
||||||
records_shuffled, records_sorted = generate_test_data()
|
|
||||||
|
|
||||||
results = []
|
|
||||||
|
|
||||||
for order_name, records in [
|
|
||||||
("random", records_shuffled),
|
|
||||||
("sorted", records_sorted)
|
|
||||||
]:
|
|
||||||
print("Order:", order_name)
|
|
||||||
|
|
||||||
ll = measure_experiment(
|
|
||||||
ll_insert,
|
|
||||||
ll_find,
|
|
||||||
ll_delete,
|
|
||||||
records
|
|
||||||
)
|
|
||||||
|
|
||||||
results.append(["LinkedList", order_name, "insert", *ll[0]])
|
|
||||||
results.append(["LinkedList", order_name, "find", *ll[1]])
|
|
||||||
results.append(["LinkedList", order_name, "delete", *ll[2]])
|
|
||||||
|
|
||||||
ht = measure_hash(records)
|
|
||||||
|
|
||||||
results.append(["HashTable", order_name, "insert", *ht[0]])
|
|
||||||
results.append(["HashTable", order_name, "find", *ht[1]])
|
|
||||||
results.append(["HashTable", order_name, "delete", *ht[2]])
|
|
||||||
|
|
||||||
bst = measure_experiment(
|
|
||||||
bst_insert,
|
|
||||||
bst_find,
|
|
||||||
bst_delete,
|
|
||||||
records
|
|
||||||
)
|
|
||||||
|
|
||||||
results.append(["BST", order_name, "insert", *bst[0]])
|
|
||||||
results.append(["BST", order_name, "find", *bst[1]])
|
|
||||||
results.append(["BST", order_name, "delete", *bst[2]])
|
|
||||||
|
|
||||||
os.makedirs("docs/data", exist_ok=True)
|
|
||||||
|
|
||||||
with open("docs/data/results.csv", "w", newline="", encoding="utf-8") as file:
|
|
||||||
writer = csv.writer(file)
|
|
||||||
|
|
||||||
writer.writerow([
|
|
||||||
"structure",
|
|
||||||
"order",
|
|
||||||
"operation",
|
|
||||||
"run1",
|
|
||||||
"run2",
|
|
||||||
"run3",
|
|
||||||
"run4",
|
|
||||||
"run5",
|
|
||||||
"average"
|
|
||||||
])
|
|
||||||
|
|
||||||
for row in results:
|
|
||||||
writer.writerow(row + [average(row[3:])])
|
|
||||||
|
|
||||||
print("Results saved to docs/data/results.csv")
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
run()
|
|
||||||
|
|
@ -1,56 +0,0 @@
|
||||||
import csv
|
|
||||||
import os
|
|
||||||
import matplotlib.pyplot as plt
|
|
||||||
|
|
||||||
data = []
|
|
||||||
|
|
||||||
with open("docs/data/results.csv", "r", encoding="utf-8") as file:
|
|
||||||
reader = csv.DictReader(file)
|
|
||||||
|
|
||||||
for row in reader:
|
|
||||||
data.append(row)
|
|
||||||
|
|
||||||
def get_average(structure, order, operation):
|
|
||||||
for row in data:
|
|
||||||
if (
|
|
||||||
row["structure"] == structure
|
|
||||||
and row["order"] == order
|
|
||||||
and row["operation"] == operation
|
|
||||||
):
|
|
||||||
return float(row["average"])
|
|
||||||
|
|
||||||
return 0
|
|
||||||
|
|
||||||
structures = ["LinkedList", "HashTable", "BST"]
|
|
||||||
orders = ["random", "sorted"]
|
|
||||||
|
|
||||||
os.makedirs("docs/data", exist_ok=True)
|
|
||||||
|
|
||||||
for operation in ["insert", "find", "delete"]:
|
|
||||||
random_values = [
|
|
||||||
get_average(s, "random", operation)
|
|
||||||
for s in structures
|
|
||||||
]
|
|
||||||
|
|
||||||
sorted_values = [
|
|
||||||
get_average(s, "sorted", operation)
|
|
||||||
for s in structures
|
|
||||||
]
|
|
||||||
|
|
||||||
x = range(len(structures))
|
|
||||||
|
|
||||||
plt.figure()
|
|
||||||
plt.bar([i - 0.2 for i in x], random_values, width=0.4, label="random")
|
|
||||||
plt.bar([i + 0.2 for i in x], sorted_values, width=0.4, label="sorted")
|
|
||||||
|
|
||||||
plt.xticks(list(x), structures)
|
|
||||||
plt.ylabel("Time, seconds")
|
|
||||||
plt.title(operation.capitalize() + " time")
|
|
||||||
plt.yscale("log")
|
|
||||||
plt.legend()
|
|
||||||
plt.tight_layout()
|
|
||||||
|
|
||||||
plt.savefig("docs/data/graph_" + operation + ".png")
|
|
||||||
plt.close()
|
|
||||||
|
|
||||||
print("Graphs saved to docs/data/")
|
|
||||||
|
|
@ -1,211 +0,0 @@
|
||||||
def ll_insert(head, name, phone):
|
|
||||||
new_node = {
|
|
||||||
'name': name,
|
|
||||||
'phone': phone,
|
|
||||||
'next': None
|
|
||||||
}
|
|
||||||
|
|
||||||
if head is None:
|
|
||||||
return new_node
|
|
||||||
|
|
||||||
current = head
|
|
||||||
|
|
||||||
while current['next'] is not None:
|
|
||||||
if current['name'] == name:
|
|
||||||
current['phone'] = phone
|
|
||||||
return head
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
if current['name'] == name:
|
|
||||||
current['phone'] = phone
|
|
||||||
else:
|
|
||||||
current['next'] = new_node
|
|
||||||
|
|
||||||
return head
|
|
||||||
|
|
||||||
def ll_find(head, name):
|
|
||||||
current = head
|
|
||||||
|
|
||||||
while current is not None:
|
|
||||||
if current['name'] == name:
|
|
||||||
return current['phone']
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
return None
|
|
||||||
|
|
||||||
def ll_delete(head, name):
|
|
||||||
if head is None:
|
|
||||||
return None
|
|
||||||
|
|
||||||
if head['name'] == name:
|
|
||||||
return head['next']
|
|
||||||
|
|
||||||
current = head
|
|
||||||
|
|
||||||
while current['next'] is not None:
|
|
||||||
if current['next']['name'] == name:
|
|
||||||
current['next'] = current['next']['next']
|
|
||||||
return head
|
|
||||||
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
return head
|
|
||||||
|
|
||||||
def ll_list_all(head):
|
|
||||||
records = []
|
|
||||||
current = head
|
|
||||||
|
|
||||||
while current is not None:
|
|
||||||
records.append((current['name'], current['phone']))
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
records.sort(key=lambda x: x[0])
|
|
||||||
return records
|
|
||||||
|
|
||||||
def hash_function(name, table_size):
|
|
||||||
total = 0
|
|
||||||
|
|
||||||
for ch in name:
|
|
||||||
total = (total * 31 + ord(ch)) % table_size
|
|
||||||
|
|
||||||
return total
|
|
||||||
|
|
||||||
def ht_create(size=1000):
|
|
||||||
return [None] * size
|
|
||||||
|
|
||||||
def ht_insert(buckets, name, phone):
|
|
||||||
index = hash_function(name, len(buckets))
|
|
||||||
buckets[index] = ll_insert(buckets[index], name, phone)
|
|
||||||
return buckets
|
|
||||||
|
|
||||||
def ht_find(buckets, name):
|
|
||||||
index = hash_function(name, len(buckets))
|
|
||||||
return ll_find(buckets[index], name)
|
|
||||||
|
|
||||||
def ht_delete(buckets, name):
|
|
||||||
index = hash_function(name, len(buckets))
|
|
||||||
buckets[index] = ll_delete(buckets[index], name)
|
|
||||||
return buckets
|
|
||||||
|
|
||||||
def ht_list_all(buckets):
|
|
||||||
records = []
|
|
||||||
|
|
||||||
for bucket in buckets:
|
|
||||||
current = bucket
|
|
||||||
|
|
||||||
while current is not None:
|
|
||||||
records.append((current['name'], current['phone']))
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
records.sort(key=lambda x: x[0])
|
|
||||||
return records
|
|
||||||
|
|
||||||
def bst_insert(root, name, phone):
|
|
||||||
new_node = {
|
|
||||||
'name': name,
|
|
||||||
'phone': phone,
|
|
||||||
'left': None,
|
|
||||||
'right': None
|
|
||||||
}
|
|
||||||
|
|
||||||
if root is None:
|
|
||||||
return new_node
|
|
||||||
|
|
||||||
current = root
|
|
||||||
|
|
||||||
while True:
|
|
||||||
if name < current['name']:
|
|
||||||
if current['left'] is None:
|
|
||||||
current['left'] = new_node
|
|
||||||
break
|
|
||||||
current = current['left']
|
|
||||||
|
|
||||||
elif name > current['name']:
|
|
||||||
if current['right'] is None:
|
|
||||||
current['right'] = new_node
|
|
||||||
break
|
|
||||||
current = current['right']
|
|
||||||
|
|
||||||
else:
|
|
||||||
current['phone'] = phone
|
|
||||||
break
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
def bst_find(root, name):
|
|
||||||
current = root
|
|
||||||
|
|
||||||
while current is not None:
|
|
||||||
if name == current['name']:
|
|
||||||
return current['phone']
|
|
||||||
|
|
||||||
if name < current['name']:
|
|
||||||
current = current['left']
|
|
||||||
else:
|
|
||||||
current = current['right']
|
|
||||||
|
|
||||||
return None
|
|
||||||
|
|
||||||
def bst_delete(root, name):
|
|
||||||
parent = None
|
|
||||||
current = root
|
|
||||||
|
|
||||||
while current is not None and current['name'] != name:
|
|
||||||
parent = current
|
|
||||||
|
|
||||||
if name < current['name']:
|
|
||||||
current = current['left']
|
|
||||||
else:
|
|
||||||
current = current['right']
|
|
||||||
|
|
||||||
if current is None:
|
|
||||||
return root
|
|
||||||
|
|
||||||
if current['left'] is None:
|
|
||||||
child = current['right']
|
|
||||||
|
|
||||||
elif current['right'] is None:
|
|
||||||
child = current['left']
|
|
||||||
|
|
||||||
else:
|
|
||||||
successor_parent = current
|
|
||||||
successor = current['right']
|
|
||||||
|
|
||||||
while successor['left'] is not None:
|
|
||||||
successor_parent = successor
|
|
||||||
successor = successor['left']
|
|
||||||
|
|
||||||
current['name'] = successor['name']
|
|
||||||
current['phone'] = successor['phone']
|
|
||||||
|
|
||||||
if successor_parent['left'] == successor:
|
|
||||||
successor_parent['left'] = successor['right']
|
|
||||||
else:
|
|
||||||
successor_parent['right'] = successor['right']
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
if parent is None:
|
|
||||||
return child
|
|
||||||
|
|
||||||
if parent['left'] == current:
|
|
||||||
parent['left'] = child
|
|
||||||
else:
|
|
||||||
parent['right'] = child
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
def bst_list_all(root):
|
|
||||||
records = []
|
|
||||||
|
|
||||||
def inorder(node):
|
|
||||||
if node is None:
|
|
||||||
return
|
|
||||||
|
|
||||||
inorder(node['left'])
|
|
||||||
records.append((node['name'], node['phone']))
|
|
||||||
inorder(node['right'])
|
|
||||||
|
|
||||||
inorder(root)
|
|
||||||
|
|
||||||
return records
|
|
||||||
Binary file not shown.
|
Before Width: | Height: | Size: 15 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 12 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 15 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB |
|
|
@ -1,16 +0,0 @@
|
||||||
maze,strategy,time_ms,visited_cells,path_length
|
|
||||||
simple.txt,BFS,0.01464000015403144,11.0,6.0
|
|
||||||
simple.txt,DFS,0.010180000390391797,9.0,8.0
|
|
||||||
simple.txt,A*,0.017740000475896522,9.0,6.0
|
|
||||||
dead.txt,BFS,0.3642999996372964,307.0,35.0
|
|
||||||
dead.txt,DFS,0.23493999906349927,279.0,151.0
|
|
||||||
dead.txt,A*,0.38374000068870373,235.0,35.0
|
|
||||||
large.txt,BFS,23.894459999428364,6812.0,2329.0
|
|
||||||
large.txt,DFS,84.77875999960816,6796.0,4537.0
|
|
||||||
large.txt,A*,28.69542000044021,6791.0,2329.0
|
|
||||||
empty.txt,BFS,1.2770400004228577,1176.0,48.0
|
|
||||||
empty.txt,DFS,7.602279999264283,2304.0,1176.0
|
|
||||||
empty.txt,A*,0.10093999881064519,48.0,48.0
|
|
||||||
noexit.txt,BFS,0.003699999797390774,1.0,0.0
|
|
||||||
noexit.txt,DFS,0.0032000003557186574,1.0,0.0
|
|
||||||
noexit.txt,A*,0.004120000085094944,1.0,0.0
|
|
||||||
|
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB |
|
|
@ -1,212 +0,0 @@
|
||||||
Лабораторная работа 2
|
|
||||||
|
|
||||||
Поиск выхода из лабиринта
|
|
||||||
|
|
||||||
Цель работы
|
|
||||||
-----------
|
|
||||||
Цель работы состоит в реализации программы для поиска выхода из лабиринта с использованием объектно ориентированного подхода и паттернов проектирования
|
|
||||||
|
|
||||||
В программе реализована загрузка лабиринта из файла несколько алгоритмов поиска и сравнение их работы
|
|
||||||
|
|
||||||
Структура программы
|
|
||||||
-------------------
|
|
||||||
В программе используются классы Cell для отдельной клетки лабиринта и Maze для самого лабиринта
|
|
||||||
|
|
||||||
Для загрузки используется MazeBuilder и его реализация TextFileMazeBuilder
|
|
||||||
|
|
||||||
Для поиска пути используется общий класс PathFindingStrategy и три алгоритма BFSStrategy DFSStrategy и AStarStrategy
|
|
||||||
|
|
||||||
За хранение результатов отвечает SearchStats а запуск поиска выполняет MazeSolver
|
|
||||||
|
|
||||||
Для вывода информации используются Observer и ConsoleView
|
|
||||||
|
|
||||||
Использованные паттерны
|
|
||||||
-----------------------
|
|
||||||
В работе использованы три паттерна Builder Strategy и Observer
|
|
||||||
|
|
||||||
Builder используется для загрузки лабиринта из текстового файла
|
|
||||||
|
|
||||||
TextFileMazeBuilder читает файл и создаёт объект Maze
|
|
||||||
|
|
||||||
В файле символ # обозначает стену пробел обозначает свободную клетку S является началом а E выходом
|
|
||||||
|
|
||||||
Использование Builder позволяет отдельно реализовать загрузку лабиринта и сам класс лабиринта
|
|
||||||
|
|
||||||
Strategy используется для выбора алгоритма поиска
|
|
||||||
|
|
||||||
В программе реализованы BFS DFS и A*
|
|
||||||
|
|
||||||
Все алгоритмы имеют общий интерфейс PathFindingStrategy поэтому в MazeSolver можно менять алгоритм без изменения самого решателя
|
|
||||||
|
|
||||||
Observer используется для вывода информации о поиске
|
|
||||||
|
|
||||||
MazeSolver отправляет события а ConsoleView получает их и выводит информацию в консоль
|
|
||||||
|
|
||||||
Таким образом вывод отделён от основной логики поиска
|
|
||||||
|
|
||||||
Алгоритмы поиска
|
|
||||||
----------------
|
|
||||||
BFS использует очередь и при обычных условиях находит кратчайший путь в лабиринте без весов
|
|
||||||
|
|
||||||
DFS использует стек и может найти путь быстрее но найденный путь не обязательно будет кратчайшим
|
|
||||||
|
|
||||||
A* использует очередь с приоритетом и манхэттенскую эвристику поэтому старается в первую очередь проверять клетки которые находятся ближе к выходу
|
|
||||||
|
|
||||||
Схема классов
|
|
||||||
-------------
|
|
||||||
classDiagram
|
|
||||||
|
|
||||||
class Cell {
|
|
||||||
x
|
|
||||||
y
|
|
||||||
is_wall
|
|
||||||
is_start
|
|
||||||
is_exit
|
|
||||||
is_passable()
|
|
||||||
}
|
|
||||||
|
|
||||||
class Maze {
|
|
||||||
width
|
|
||||||
height
|
|
||||||
cells
|
|
||||||
start
|
|
||||||
exit
|
|
||||||
get_cell()
|
|
||||||
get_neighbors()
|
|
||||||
}
|
|
||||||
|
|
||||||
class MazeBuilder {
|
|
||||||
build_from_file()
|
|
||||||
}
|
|
||||||
|
|
||||||
class TextFileMazeBuilder {
|
|
||||||
build_from_file()
|
|
||||||
}
|
|
||||||
|
|
||||||
class PathFindingStrategy {
|
|
||||||
find_path()
|
|
||||||
}
|
|
||||||
|
|
||||||
class BFSStrategy {
|
|
||||||
find_path()
|
|
||||||
}
|
|
||||||
|
|
||||||
class DFSStrategy {
|
|
||||||
find_path()
|
|
||||||
}
|
|
||||||
|
|
||||||
class AStarStrategy {
|
|
||||||
find_path()
|
|
||||||
}
|
|
||||||
|
|
||||||
class SearchStats {
|
|
||||||
path
|
|
||||||
time_ms
|
|
||||||
visited_count
|
|
||||||
path_length
|
|
||||||
}
|
|
||||||
|
|
||||||
class MazeSolver {
|
|
||||||
maze
|
|
||||||
strategy
|
|
||||||
set_strategy()
|
|
||||||
solve()
|
|
||||||
}
|
|
||||||
|
|
||||||
class Observer {
|
|
||||||
update()
|
|
||||||
}
|
|
||||||
|
|
||||||
class ConsoleView {
|
|
||||||
update()
|
|
||||||
}
|
|
||||||
|
|
||||||
MazeBuilder <|-- TextFileMazeBuilder
|
|
||||||
PathFindingStrategy <|-- BFSStrategy
|
|
||||||
PathFindingStrategy <|-- DFSStrategy
|
|
||||||
PathFindingStrategy <|-- AStarStrategy
|
|
||||||
Observer <|-- ConsoleView
|
|
||||||
MazeSolver --> Maze
|
|
||||||
MazeSolver --> PathFindingStrategy
|
|
||||||
MazeSolver --> Observer
|
|
||||||
Maze --> Cell
|
|
||||||
Тестирование
|
|
||||||
------------
|
|
||||||
Для проверки использовалось пять разных лабиринтов
|
|
||||||
|
|
||||||
simple.txt представляет простой лабиринт dead.txt содержит тупики large.txt является большим запутанным лабиринтом empty.txt не содержит стен а в noexit.txt выход недостижим
|
|
||||||
|
|
||||||
Каждый алгоритм запускался пять раз
|
|
||||||
|
|
||||||
Во время эксперимента измерялось время поиска количество посещённых клеток и длина найденного пути
|
|
||||||
|
|
||||||
Результаты сохранялись в файл results.csv
|
|
||||||
|
|
||||||
Результаты
|
|
||||||
----------
|
|
||||||
simple.txt
|
|
||||||
Алгоритм Время мс Посещено Путь
|
|
||||||
BFS 0.01464 11 6
|
|
||||||
DFS 0.01018 9 8
|
|
||||||
A* 0.01774 9 6
|
|
||||||
|
|
||||||
Все алгоритмы работают быстро
|
|
||||||
|
|
||||||
BFS и A* нашли более короткий путь чем DFS
|
|
||||||
|
|
||||||
dead.txt
|
|
||||||
Алгоритм Время мс Посещено Путь
|
|
||||||
BFS 0.36430 307 35
|
|
||||||
DFS 0.23494 279 151
|
|
||||||
A* 0.38374 235 35
|
|
||||||
|
|
||||||
DFS работал немного быстрее но нашёл более длинный путь
|
|
||||||
|
|
||||||
BFS и A* нашли короткий путь
|
|
||||||
|
|
||||||
large.txt
|
|
||||||
Алгоритм Время мс Посещено Путь
|
|
||||||
BFS 23.89446 6812 2329
|
|
||||||
DFS 84.77876 6796 4537
|
|
||||||
A* 28.69542 6791 2329
|
|
||||||
|
|
||||||
На большом лабиринте DFS показал худшее время и самый длинный путь
|
|
||||||
|
|
||||||
BFS и A* нашли одинаковый путь
|
|
||||||
|
|
||||||
empty.txt
|
|
||||||
Алгоритм Время мс Посещено Путь
|
|
||||||
BFS 1.277
|
|
||||||
|
|
||||||
|
|
||||||
04 1176 48
|
|
||||||
DFS 7.60228 2304 1176
|
|
||||||
A* 0.10094 48 48
|
|
||||||
|
|
||||||
В лабиринте без стен лучше всего показал себя A*
|
|
||||||
|
|
||||||
Он посетил меньше всего клеток и работал быстрее
|
|
||||||
|
|
||||||
noexit.txt
|
|
||||||
Алгоритм Время мс Посещено Путь
|
|
||||||
BFS 0.00370 1 0
|
|
||||||
DFS 0.00320 1 0
|
|
||||||
A* 0.00412 1 0
|
|
||||||
|
|
||||||
В этом лабиринте выход недостижим поэтому все алгоритмы быстро закончили поиск
|
|
||||||
|
|
||||||
Графики
|
|
||||||
-------
|
|
||||||
Для сравнения времени работы были построены графики для каждого лабиринта
|
|
||||||
|
|
||||||
Графики находятся в папке docs/data
|
|
||||||
|
|
||||||
simple_time.png dead_time.png large_time.png empty_time.png и noexit_time.png
|
|
||||||
|
|
||||||
Вывод
|
|
||||||
-----
|
|
||||||
В работе была создана программа для поиска выхода из лабиринта
|
|
||||||
|
|
||||||
Были реализованы BFS DFS и A* а также использованы паттерны Builder Strategy и Observer
|
|
||||||
|
|
||||||
По результатам эксперимента BFS хорошо подходит для поиска кратчайшего пути DFS может найти путь быстрее но он не всегда получается коротким A* хорошо показывает себя на больших и открытых лабиринтах
|
|
||||||
|
|
@ -1,93 +0,0 @@
|
||||||
import csv
|
|
||||||
import os
|
|
||||||
|
|
||||||
from maze_solver import (
|
|
||||||
TextFileMazeBuilder,
|
|
||||||
MazeSolver,
|
|
||||||
BFSStrategy,
|
|
||||||
DFSStrategy,
|
|
||||||
AStarStrategy
|
|
||||||
)
|
|
||||||
|
|
||||||
REPEATS = 5
|
|
||||||
|
|
||||||
MAZES = [
|
|
||||||
"simple.txt",
|
|
||||||
"dead.txt",
|
|
||||||
"large.txt",
|
|
||||||
"empty.txt",
|
|
||||||
"noexit.txt"
|
|
||||||
]
|
|
||||||
|
|
||||||
STRATEGIES = [
|
|
||||||
("BFS", BFSStrategy()),
|
|
||||||
("DFS", DFSStrategy()),
|
|
||||||
("A*", AStarStrategy())
|
|
||||||
]
|
|
||||||
|
|
||||||
def average(values):
|
|
||||||
return sum(values) / len(values)
|
|
||||||
|
|
||||||
def run():
|
|
||||||
builder = TextFileMazeBuilder()
|
|
||||||
results = []
|
|
||||||
|
|
||||||
for maze_name in MAZES:
|
|
||||||
filename = os.path.join("lab2", "mazes", maze_name)
|
|
||||||
|
|
||||||
print("Maze:", maze_name)
|
|
||||||
|
|
||||||
for strategy_name, strategy in STRATEGIES:
|
|
||||||
times = []
|
|
||||||
visited = []
|
|
||||||
path_lengths = []
|
|
||||||
|
|
||||||
for _ in range(REPEATS):
|
|
||||||
maze = builder.build_from_file(filename)
|
|
||||||
|
|
||||||
solver = MazeSolver(maze, strategy)
|
|
||||||
stats = solver.solve()
|
|
||||||
|
|
||||||
times.append(stats.time_ms)
|
|
||||||
visited.append(stats.visited_count)
|
|
||||||
path_lengths.append(stats.path_length)
|
|
||||||
|
|
||||||
results.append([
|
|
||||||
maze_name,
|
|
||||||
strategy_name,
|
|
||||||
average(times),
|
|
||||||
average(visited),
|
|
||||||
average(path_lengths)
|
|
||||||
])
|
|
||||||
|
|
||||||
print(
|
|
||||||
strategy_name,
|
|
||||||
"time =", average(times),
|
|
||||||
"visited =", average(visited),
|
|
||||||
"path =", average(path_lengths)
|
|
||||||
)
|
|
||||||
|
|
||||||
os.makedirs("lab2/docs/data", exist_ok=True)
|
|
||||||
|
|
||||||
with open(
|
|
||||||
"lab2/docs/data/results.csv",
|
|
||||||
"w",
|
|
||||||
newline="",
|
|
||||||
encoding="utf-8"
|
|
||||||
) as file:
|
|
||||||
writer = csv.writer(file)
|
|
||||||
|
|
||||||
writer.writerow([
|
|
||||||
"maze",
|
|
||||||
"strategy",
|
|
||||||
"time_ms",
|
|
||||||
"visited_cells",
|
|
||||||
"path_length"
|
|
||||||
])
|
|
||||||
|
|
||||||
writer.writerows(results)
|
|
||||||
|
|
||||||
print("Results saved to lab2/docs/data/results.csv")
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
run()
|
|
||||||
|
|
@ -1,23 +0,0 @@
|
||||||
import csv
|
|
||||||
import matplotlib.pyplot as plt
|
|
||||||
|
|
||||||
with open("lab2/docs/data/results.csv", encoding="utf-8") as file:
|
|
||||||
rows = list(csv.DictReader(file))
|
|
||||||
|
|
||||||
mazes = ["simple.txt", "dead.txt", "large.txt", "empty.txt", "noexit.txt"]
|
|
||||||
strategies = ["BFS", "DFS", "A*"]
|
|
||||||
|
|
||||||
for maze in mazes:
|
|
||||||
values = []
|
|
||||||
|
|
||||||
for strategy in strategies:
|
|
||||||
for row in rows:
|
|
||||||
if row["maze"] == maze and row["strategy"] == strategy:
|
|
||||||
values.append(float(row["time_ms"]))
|
|
||||||
|
|
||||||
plt.bar(strategies, values)
|
|
||||||
plt.title("Время поиска: " + maze)
|
|
||||||
plt.xlabel("Стратегия")
|
|
||||||
plt.ylabel("Время, мс")
|
|
||||||
plt.savefig("lab2/docs/data/" + maze.replace(".txt", "_time.png"))
|
|
||||||
plt.close()
|
|
||||||
|
|
@ -1,26 +0,0 @@
|
||||||
lines = []
|
|
||||||
|
|
||||||
for y in range(100):
|
|
||||||
row = [" "] * 100
|
|
||||||
|
|
||||||
if y == 0 or y == 99:
|
|
||||||
row = ["#"] * 100
|
|
||||||
else:
|
|
||||||
row[0] = "#"
|
|
||||||
row[99] = "#"
|
|
||||||
|
|
||||||
lines.append(row)
|
|
||||||
|
|
||||||
lines[1][1] = "S"
|
|
||||||
lines[98][98] = "E"
|
|
||||||
|
|
||||||
for x in range(4, 96, 4):
|
|
||||||
gap = 1 if (x // 4) % 2 == 0 else 98
|
|
||||||
|
|
||||||
for y in range(1, 99):
|
|
||||||
if y != gap:
|
|
||||||
lines[y][x] = "#"
|
|
||||||
|
|
||||||
with open("lab2/mazes/large.txt", "w", encoding="utf-8") as file:
|
|
||||||
for row in lines:
|
|
||||||
file.write("".join(row) + "\n")
|
|
||||||
|
|
@ -1,284 +0,0 @@
|
||||||
from abc import ABC, abstractmethod
|
|
||||||
from collections import deque
|
|
||||||
import heapq
|
|
||||||
import time
|
|
||||||
|
|
||||||
class Cell:
|
|
||||||
def __init__(self, x, y):
|
|
||||||
self.x = x
|
|
||||||
self.y = y
|
|
||||||
self.is_wall = False
|
|
||||||
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.cells = []
|
|
||||||
self.start = None
|
|
||||||
self.exit = None
|
|
||||||
|
|
||||||
for y in range(height):
|
|
||||||
row = []
|
|
||||||
|
|
||||||
for x in range(width):
|
|
||||||
row.append(Cell(x, y))
|
|
||||||
|
|
||||||
self.cells.append(row)
|
|
||||||
|
|
||||||
def get_cell(self, x, y):
|
|
||||||
if 0 <= x < self.width and 0 <= y < self.height:
|
|
||||||
return self.cells[y][x]
|
|
||||||
|
|
||||||
return None
|
|
||||||
|
|
||||||
def get_neighbors(self, cell):
|
|
||||||
neighbors = []
|
|
||||||
|
|
||||||
directions = [
|
|
||||||
(0, -1),
|
|
||||||
(0, 1),
|
|
||||||
(-1, 0),
|
|
||||||
(1, 0)
|
|
||||||
]
|
|
||||||
|
|
||||||
for dx, dy in directions:
|
|
||||||
neighbor = self.get_cell(
|
|
||||||
cell.x + dx,
|
|
||||||
cell.y + dy
|
|
||||||
)
|
|
||||||
|
|
||||||
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", encoding="utf-8") as file:
|
|
||||||
lines = [line.rstrip("\n") for line in file]
|
|
||||||
|
|
||||||
if not lines:
|
|
||||||
raise ValueError("Файл лабиринта пустой")
|
|
||||||
|
|
||||||
width = len(lines[0])
|
|
||||||
|
|
||||||
for line in lines:
|
|
||||||
if len(line) != width:
|
|
||||||
raise ValueError("Строки лабиринта имеют разную длину")
|
|
||||||
|
|
||||||
maze = Maze(width, len(lines))
|
|
||||||
|
|
||||||
for y, line in enumerate(lines):
|
|
||||||
for x, symbol in enumerate(line):
|
|
||||||
cell = maze.get_cell(x, y)
|
|
||||||
|
|
||||||
if symbol == "#":
|
|
||||||
cell.is_wall = True
|
|
||||||
|
|
||||||
elif symbol == "S":
|
|
||||||
if maze.start is not None:
|
|
||||||
raise ValueError("В лабиринте несколько стартов")
|
|
||||||
|
|
||||||
maze.start = cell
|
|
||||||
cell.is_start = True
|
|
||||||
|
|
||||||
elif symbol == "E":
|
|
||||||
if maze.exit is not None:
|
|
||||||
raise ValueError("В лабиринте несколько выходов")
|
|
||||||
|
|
||||||
maze.exit = cell
|
|
||||||
cell.is_exit = True
|
|
||||||
|
|
||||||
elif symbol == " ":
|
|
||||||
pass
|
|
||||||
|
|
||||||
else:
|
|
||||||
raise ValueError("Неизвестный символ в лабиринте")
|
|
||||||
|
|
||||||
if maze.start is None:
|
|
||||||
raise ValueError("В лабиринте нет старта")
|
|
||||||
|
|
||||||
if maze.exit is None:
|
|
||||||
raise ValueError("В лабиринте нет выхода")
|
|
||||||
|
|
||||||
return maze
|
|
||||||
|
|
||||||
class PathFindingStrategy(ABC):
|
|
||||||
@abstractmethod
|
|
||||||
def find_path(self, maze, start, exit):
|
|
||||||
pass
|
|
||||||
|
|
||||||
class BFSStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze, start, exit):
|
|
||||||
if start is None or exit is None:
|
|
||||||
return [], 0
|
|
||||||
|
|
||||||
queue = deque([(start, [start])])
|
|
||||||
visited = {start}
|
|
||||||
|
|
||||||
while queue:
|
|
||||||
current, path = queue.popleft()
|
|
||||||
|
|
||||||
if current == exit:
|
|
||||||
return path, len(visited)
|
|
||||||
|
|
||||||
for neighbor in maze.get_neighbors(current):
|
|
||||||
if neighbor not in visited:
|
|
||||||
visited.add(neighbor)
|
|
||||||
queue.append((neighbor, path + [neighbor]))
|
|
||||||
|
|
||||||
return [], len(visited)
|
|
||||||
|
|
||||||
class DFSStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze, start, exit):
|
|
||||||
if start is None or exit is None:
|
|
||||||
return [], 0
|
|
||||||
|
|
||||||
stack = [(start, [start])]
|
|
||||||
visited = {start}
|
|
||||||
|
|
||||||
while stack:
|
|
||||||
current, path = stack.pop()
|
|
||||||
|
|
||||||
if current == exit:
|
|
||||||
return path, len(visited)
|
|
||||||
|
|
||||||
for neighbor in maze.get_neighbors(current):
|
|
||||||
if neighbor not in visited:
|
|
||||||
visited.add(neighbor)
|
|
||||||
stack.append((neighbor, path + [neighbor]))
|
|
||||||
|
|
||||||
return [], len(visited)
|
|
||||||
|
|
||||||
class AStarStrategy(PathFindingStrategy):
|
|
||||||
def heuristic(self, a, b):
|
|
||||||
return abs(a.x - b.x) + abs(a.y - b.y)
|
|
||||||
|
|
||||||
def find_path(self, maze, start, exit):
|
|
||||||
if start is None or exit is None:
|
|
||||||
return [], 0
|
|
||||||
|
|
||||||
heap = []
|
|
||||||
counter = 0
|
|
||||||
|
|
||||||
heapq.heappush(
|
|
||||||
heap,
|
|
||||||
(self.heuristic(start, exit), counter, start, [start])
|
|
||||||
)
|
|
||||||
|
|
||||||
g_score = {start: 0}
|
|
||||||
visited = set()
|
|
||||||
|
|
||||||
while heap:
|
|
||||||
_, _, current, path = heapq.heappop(heap)
|
|
||||||
|
|
||||||
if current in visited:
|
|
||||||
continue
|
|
||||||
|
|
||||||
visited.add(current)
|
|
||||||
|
|
||||||
if current == exit:
|
|
||||||
return path, len(visited)
|
|
||||||
|
|
||||||
for neighbor in maze.get_neighbors(current):
|
|
||||||
new_cost = g_score[current] + 1
|
|
||||||
|
|
||||||
if neighbor not in g_score or new_cost < g_score[neighbor]:
|
|
||||||
g_score[neighbor] = new_cost
|
|
||||||
counter += 1
|
|
||||||
|
|
||||||
priority = new_cost + self.heuristic(
|
|
||||||
neighbor,
|
|
||||||
exit
|
|
||||||
)
|
|
||||||
|
|
||||||
heapq.heappush(
|
|
||||||
heap,
|
|
||||||
(
|
|
||||||
priority,
|
|
||||||
counter,
|
|
||||||
neighbor,
|
|
||||||
path + [neighbor]
|
|
||||||
)
|
|
||||||
)
|
|
||||||
|
|
||||||
return [], len(visited)
|
|
||||||
|
|
||||||
class SearchStats:
|
|
||||||
def __init__(self, path, time_ms, visited_count):
|
|
||||||
self.path = path
|
|
||||||
self.time_ms = time_ms
|
|
||||||
self.visited_count = visited_count
|
|
||||||
self.path_length = len(path) if path else 0
|
|
||||||
|
|
||||||
class MazeSolver:
|
|
||||||
def __init__(self, maze, strategy=None):
|
|
||||||
self.maze = maze
|
|
||||||
self.strategy = strategy
|
|
||||||
self.observers = []
|
|
||||||
|
|
||||||
def attach(self, observer):
|
|
||||||
self.observers.append(observer)
|
|
||||||
|
|
||||||
def detach(self, observer):
|
|
||||||
self.observers.remove(observer)
|
|
||||||
|
|
||||||
def notify(self, event, data=None):
|
|
||||||
for observer in self.observers:
|
|
||||||
observer.update(event, data)
|
|
||||||
|
|
||||||
def set_strategy(self, strategy):
|
|
||||||
self.strategy = strategy
|
|
||||||
|
|
||||||
def solve(self):
|
|
||||||
if self.strategy is None:
|
|
||||||
raise ValueError("Стратегия не установлена")
|
|
||||||
|
|
||||||
self.notify("search_started")
|
|
||||||
|
|
||||||
start_time = time.perf_counter()
|
|
||||||
|
|
||||||
path, visited_count = self.strategy.find_path(
|
|
||||||
self.maze,
|
|
||||||
self.maze.start,
|
|
||||||
self.maze.exit
|
|
||||||
)
|
|
||||||
|
|
||||||
end_time = time.perf_counter()
|
|
||||||
|
|
||||||
time_ms = (end_time - start_time) * 1000
|
|
||||||
|
|
||||||
self.notify("search_finished", time_ms)
|
|
||||||
self.notify("path_found", path)
|
|
||||||
|
|
||||||
return SearchStats(
|
|
||||||
path,
|
|
||||||
time_ms,
|
|
||||||
visited_count
|
|
||||||
)
|
|
||||||
|
|
||||||
class Observer(ABC):
|
|
||||||
@abstractmethod
|
|
||||||
def update(self, event, data=None):
|
|
||||||
pass
|
|
||||||
|
|
||||||
class ConsoleView(Observer):
|
|
||||||
def update(self, event, data=None):
|
|
||||||
if event == "search_started":
|
|
||||||
print("Поиск начат")
|
|
||||||
|
|
||||||
elif event == "search_finished":
|
|
||||||
print(f"Поиск завершен за {data:.3f} мс")
|
|
||||||
|
|
||||||
elif event == "path_found":
|
|
||||||
print(f"Длина пути: {len(data)}")
|
|
||||||
|
|
@ -1,20 +0,0 @@
|
||||||
####################
|
|
||||||
#S #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# ######### #
|
|
||||||
# # #
|
|
||||||
# # #
|
|
||||||
# # #
|
|
||||||
# # #
|
|
||||||
# # #
|
|
||||||
# # #
|
|
||||||
# # #
|
|
||||||
# # #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# E#
|
|
||||||
####################
|
|
||||||
|
|
@ -1,50 +0,0 @@
|
||||||
##################################################
|
|
||||||
#S #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
#E #
|
|
||||||
##################################################
|
|
||||||
|
|
@ -1,100 +0,0 @@
|
||||||
####################################################################################################
|
|
||||||
#S # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # E#
|
|
||||||
####################################################################################################
|
|
||||||
|
|
@ -1,10 +0,0 @@
|
||||||
##########
|
|
||||||
#S########
|
|
||||||
##########
|
|
||||||
##########
|
|
||||||
##########
|
|
||||||
##########
|
|
||||||
##########
|
|
||||||
##########
|
|
||||||
########E#
|
|
||||||
##########
|
|
||||||
|
|
@ -1,5 +0,0 @@
|
||||||
#######
|
|
||||||
#S #
|
|
||||||
# ### #
|
|
||||||
# E #
|
|
||||||
#######
|
|
||||||
|
|
@ -1,292 +0,0 @@
|
||||||
#!/usr/bin/env python3
|
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
|
|
||||||
import time
|
|
||||||
import random
|
|
||||||
import csv
|
|
||||||
import sys
|
|
||||||
sys.setrecursionlimit(30000)
|
|
||||||
|
|
||||||
def ll_create_node(name, phone):
|
|
||||||
return {'name': name, 'phone': phone, 'next': None}
|
|
||||||
|
|
||||||
def ll_insert(head, name, phone):
|
|
||||||
if head is None:
|
|
||||||
return ll_create_node(name, phone)
|
|
||||||
|
|
||||||
if head['name'] == name:
|
|
||||||
head['phone'] = phone
|
|
||||||
return head
|
|
||||||
|
|
||||||
current = head
|
|
||||||
while current['next'] is not None:
|
|
||||||
if current['next']['name'] == name:
|
|
||||||
current['next']['phone'] = phone
|
|
||||||
return head
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
current['next'] = ll_create_node(name, phone)
|
|
||||||
return head
|
|
||||||
|
|
||||||
def ll_find(head, name):
|
|
||||||
current = head
|
|
||||||
while current is not None:
|
|
||||||
if current['name'] == name:
|
|
||||||
return current['phone']
|
|
||||||
current = current['next']
|
|
||||||
return None
|
|
||||||
|
|
||||||
def ll_delete(head, name):
|
|
||||||
if head is None:
|
|
||||||
return None
|
|
||||||
|
|
||||||
if head['name'] == name:
|
|
||||||
return head['next']
|
|
||||||
|
|
||||||
current = head
|
|
||||||
while current['next'] is not None:
|
|
||||||
if current['next']['name'] == name:
|
|
||||||
current['next'] = current['next']['next']
|
|
||||||
return head
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
return head
|
|
||||||
|
|
||||||
def ll_list_all(head):
|
|
||||||
records = []
|
|
||||||
current = head
|
|
||||||
while current is not None:
|
|
||||||
records.append((current['name'], current['phone']))
|
|
||||||
current = current['next']
|
|
||||||
records.sort(key=lambda x: x[0])
|
|
||||||
return records
|
|
||||||
|
|
||||||
def hash_function(name, table_size):
|
|
||||||
return sum(ord(c) for c in name) % table_size
|
|
||||||
|
|
||||||
def ht_create_table(size=2000):
|
|
||||||
return [None] * size
|
|
||||||
|
|
||||||
def ht_insert(table, name, phone):
|
|
||||||
index = hash_function(name, len(table))
|
|
||||||
table[index] = ll_insert(table[index], name, phone)
|
|
||||||
|
|
||||||
def ht_find(table, name):
|
|
||||||
index = hash_function(name, len(table))
|
|
||||||
return ll_find(table[index], name)
|
|
||||||
|
|
||||||
def ht_delete(table, name):
|
|
||||||
index = hash_function(name, len(table))
|
|
||||||
table[index] = ll_delete(table[index], name)
|
|
||||||
|
|
||||||
def ht_list_all(table):
|
|
||||||
all_records = []
|
|
||||||
for bucket in table:
|
|
||||||
if bucket is not None:
|
|
||||||
current = bucket
|
|
||||||
while current is not None:
|
|
||||||
all_records.append((current['name'], current['phone']))
|
|
||||||
current = current['next']
|
|
||||||
all_records.sort(key=lambda x: x[0])
|
|
||||||
return all_records
|
|
||||||
|
|
||||||
def bst_create_node(name, phone):
|
|
||||||
return {'name': name, 'phone': phone, 'left': None, 'right': None}
|
|
||||||
|
|
||||||
def bst_insert(root, name, phone):
|
|
||||||
if root is None:
|
|
||||||
return bst_create_node(name, phone)
|
|
||||||
|
|
||||||
current = root
|
|
||||||
while True:
|
|
||||||
if name < current['name']:
|
|
||||||
if current['left'] is None:
|
|
||||||
current['left'] = bst_create_node(name, phone)
|
|
||||||
break
|
|
||||||
else:
|
|
||||||
current = current['left']
|
|
||||||
elif name > current['name']:
|
|
||||||
if current['right'] is None:
|
|
||||||
current['right'] = bst_create_node(name, phone)
|
|
||||||
break
|
|
||||||
else:
|
|
||||||
current = current['right']
|
|
||||||
else:
|
|
||||||
current['phone'] = phone
|
|
||||||
break
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
def bst_find(root, name):
|
|
||||||
current = root
|
|
||||||
while current is not None:
|
|
||||||
if name < current['name']:
|
|
||||||
current = current['left']
|
|
||||||
elif name > current['name']:
|
|
||||||
current = current['right']
|
|
||||||
else:
|
|
||||||
return current['phone']
|
|
||||||
return None
|
|
||||||
|
|
||||||
def bst_find_min(node):
|
|
||||||
current = node
|
|
||||||
while current['left'] is not None:
|
|
||||||
current = current['left']
|
|
||||||
return current
|
|
||||||
|
|
||||||
def bst_delete(root, name):
|
|
||||||
if root is None:
|
|
||||||
return None
|
|
||||||
|
|
||||||
parent = None
|
|
||||||
current = root
|
|
||||||
|
|
||||||
while current is not None and current['name'] != name:
|
|
||||||
parent = current
|
|
||||||
if name < current['name']:
|
|
||||||
current = current['left']
|
|
||||||
else:
|
|
||||||
current = current['right']
|
|
||||||
|
|
||||||
if current is None:
|
|
||||||
return root
|
|
||||||
|
|
||||||
if current['left'] is None or current['right'] is None:
|
|
||||||
if current['left'] is not None:
|
|
||||||
child = current['left']
|
|
||||||
else:
|
|
||||||
child = current['right']
|
|
||||||
|
|
||||||
if parent is None:
|
|
||||||
return child
|
|
||||||
|
|
||||||
if parent['left'] == current:
|
|
||||||
parent['left'] = child
|
|
||||||
else:
|
|
||||||
parent['right'] = child
|
|
||||||
else:
|
|
||||||
successor_parent = current
|
|
||||||
successor = current['right']
|
|
||||||
|
|
||||||
while successor['left'] is not None:
|
|
||||||
successor_parent = successor
|
|
||||||
successor = successor['left']
|
|
||||||
|
|
||||||
current['name'] = successor['name']
|
|
||||||
current['phone'] = successor['phone']
|
|
||||||
|
|
||||||
if successor_parent['left'] == successor:
|
|
||||||
successor_parent['left'] = successor['right']
|
|
||||||
else:
|
|
||||||
successor_parent['right'] = successor['right']
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
def bst_list_all(root):
|
|
||||||
records = []
|
|
||||||
stack = []
|
|
||||||
current = root
|
|
||||||
|
|
||||||
while stack or current is not None:
|
|
||||||
while current is not None:
|
|
||||||
stack.append(current)
|
|
||||||
current = current['left']
|
|
||||||
current = stack.pop()
|
|
||||||
records.append((current['name'], current['phone']))
|
|
||||||
current = current['right']
|
|
||||||
|
|
||||||
return records
|
|
||||||
|
|
||||||
def generate_data(n=10000):
|
|
||||||
records = [(f"User_{i:05d}", f"+7-999-{i:06d}") for i in range(n)]
|
|
||||||
records_shuffled = records.copy()
|
|
||||||
random.shuffle(records_shuffled)
|
|
||||||
records_sorted = sorted(records, key=lambda x: x[0])
|
|
||||||
return records_shuffled, records_sorted
|
|
||||||
|
|
||||||
def run_experiment(structure_name, insert_func, find_func, delete_func,
|
|
||||||
list_all_func, init_func, records, n_find=100):
|
|
||||||
|
|
||||||
data = init_func()
|
|
||||||
names = [r[0] for r in records]
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
for name, phone in records:
|
|
||||||
if structure_name == "HashTable":
|
|
||||||
insert_func(data, name, phone)
|
|
||||||
else:
|
|
||||||
data = insert_func(data, name, phone)
|
|
||||||
insert_time = time.perf_counter() - start
|
|
||||||
|
|
||||||
find_names = random.sample(names, min(n_find, len(names)))
|
|
||||||
missing_names = [f"None_{i}" for i in range(10)]
|
|
||||||
all_find_names = find_names + missing_names
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
for name in all_find_names:
|
|
||||||
if structure_name == "HashTable":
|
|
||||||
find_func(data, name)
|
|
||||||
else:
|
|
||||||
find_func(data, name)
|
|
||||||
find_time = time.perf_counter() - start
|
|
||||||
|
|
||||||
delete_names = random.sample(names, min(50, len(names)))
|
|
||||||
start = time.perf_counter()
|
|
||||||
for name in delete_names:
|
|
||||||
if structure_name == "HashTable":
|
|
||||||
delete_func(data, name)
|
|
||||||
else:
|
|
||||||
data = delete_func(data, name)
|
|
||||||
delete_time = time.perf_counter() - start
|
|
||||||
|
|
||||||
return insert_time, find_time, delete_time
|
|
||||||
|
|
||||||
def main():
|
|
||||||
print("Generating test data...")
|
|
||||||
records_shuffled, records_sorted = generate_data(10000)
|
|
||||||
|
|
||||||
results = []
|
|
||||||
|
|
||||||
structures = [
|
|
||||||
("LinkedList", ll_insert, ll_find, ll_delete, ll_list_all, lambda: None),
|
|
||||||
("HashTable", ht_insert, ht_find, ht_delete, ht_list_all, lambda: ht_create_table(2000)),
|
|
||||||
("BST", bst_insert, bst_find, bst_delete, bst_list_all, lambda: None)
|
|
||||||
]
|
|
||||||
|
|
||||||
for mode_name, records in [("random", records_shuffled), ("sorted", records_sorted)]:
|
|
||||||
print(f"\nMode: {mode_name}")
|
|
||||||
|
|
||||||
for struct_name, insert_f, find_f, delete_f, list_f, init_f in structures:
|
|
||||||
print(f" Testing {struct_name}...")
|
|
||||||
|
|
||||||
times = []
|
|
||||||
for run in range(5):
|
|
||||||
insert_t, find_t, delete_t = run_experiment(
|
|
||||||
struct_name, insert_f, find_f, delete_f, list_f, init_f, records
|
|
||||||
)
|
|
||||||
times.append((insert_t, find_t, delete_t))
|
|
||||||
print(f" Run {run+1}: insert={insert_t:.4f}s, find={find_t:.4f}s, delete={delete_t:.4f}s")
|
|
||||||
|
|
||||||
avg_insert = sum(t[0] for t in times) / 5
|
|
||||||
avg_find = sum(t[1] for t in times) / 5
|
|
||||||
avg_delete = sum(t[2] for t in times) / 5
|
|
||||||
|
|
||||||
results.append([struct_name, mode_name, "insert", avg_insert])
|
|
||||||
results.append([struct_name, mode_name, "find", avg_find])
|
|
||||||
results.append([struct_name, mode_name, "delete", avg_delete])
|
|
||||||
|
|
||||||
with open("results.csv", "w", newline="", encoding="utf-8") as f:
|
|
||||||
writer = csv.writer(f)
|
|
||||||
writer.writerow(["Structure", "Mode", "Operation", "Time_seconds"])
|
|
||||||
writer.writerows(results)
|
|
||||||
|
|
||||||
print("\n" + "="*60)
|
|
||||||
print("RESULTS (average over 5 runs):")
|
|
||||||
print("="*60)
|
|
||||||
for row in results:
|
|
||||||
print(f"{row[0]:12} | {row[1]:8} | {row[2]:8} | {row[3]:.6f} sec")
|
|
||||||
|
|
||||||
print("\nResults saved to results.csv")
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
main()
|
|
||||||
|
|
@ -1,122 +0,0 @@
|
||||||
|
|
||||||
|
|
||||||
Методы Программирования
|
|
||||||
|
|
||||||
|
|
||||||
Структуры данных,
|
|
||||||
анализ 1 задания
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Бобров К. Н.
|
|
||||||
425 группа
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Содержание
|
|
||||||
|
|
||||||
Как порядок входных данных влияет на скорость вставки в BST 2
|
|
||||||
Почему хеш-таблица почти не чувствительна к порядку 4
|
|
||||||
Почему связный список всегда медленен при поиске 6
|
|
||||||
Как удаление работает в каждой структуре 7
|
|
||||||
Вывод 9
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Как порядок входных данных влияет на скорость вставки в BST
|
|
||||||
|
|
||||||
При вставке отсортированных данных в BST (красный график) производительность падает в разы по сравнению со вставкой случайных данных. Это связано с тем, что отсортированная последовательность приводит к вырождению дерева в связанный список, тогда как случайный порядок вставки помогает сохранять дерево относительно сбалансированным.
|
|
||||||
При вставке элементов в отсортированном порядке (по возрастанию или убыванию):
|
|
||||||
?Каждый новый элемент всегда больше (или меньше) всех уже добавленных.
|
|
||||||
?В результате алгоритм каждый раз движется по одному и тому же направлению — только в правое или только в левое поддерево.
|
|
||||||
?Из-за этого дерево вырождается: каждый узел имеет не более одного потомка, структура напоминает линейный список.
|
|
||||||
?Высота такого дерева становится пропорциональной O(n).
|
|
||||||
?Каждая операция вставки требует в среднем O(n) сравнений, так как нужно проходить всю длину текущей цепочки от корня до самого глубокого листа.
|
|
||||||
?В итоге суммарная сложность вставки всех n элементов вырастает до O(n^2).
|
|
||||||
|
|
||||||
|
|
||||||
При случайной вставке:
|
|
||||||
?Элементы распределяются по дереву гораздо равномернее.
|
|
||||||
?Высока вероятность того, что дерево останется сбалансированным.
|
|
||||||
?Средняя высота дерева сохраняется на уровне O(logn).
|
|
||||||
?Каждая операция вставки в среднем требует O(logn) сравнений.
|
|
||||||
?Общая сложность вставки всех n элементов составляет O(nlogn).
|
|
||||||
Вывод: разница в скорости объясняется различием в высоте дерева. В вырожденном случае высота равна O(n), и каждая вставка выполняется в ?n/logn раз медленнее по числу шагов, чем в сбалансированном случае с высотой O(logn).
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Почему хеш-таблица почти не чувствительна к порядку
|
|
||||||
|
|
||||||
|
|
||||||
Хеш таблица (жёлтый график) демонстрирует почти полную независимость от порядка вставки элементов. Это объясняется тем, что положение каждого элемента в структуре определяется исключительно значением его хеш функции, а не тем, в какой последовательности происходило добавление данных.
|
|
||||||
|
|
||||||
Основные причины нечувствительности к порядку вставки:
|
|
||||||
?Хеширование. Для каждого ключа вычисляется хеш код, который преобразуется в индекс ячейки. Один и тот же ключ всегда даёт один и тот же индекс независимо от того, когда и в каком порядке он был добавлен.
|
|
||||||
?Независимость операций. Вставка, поиск и удаление выполняются в среднем за O(1)O(1), поскольку алгоритм сразу вычисляет нужную позицию, не обходя структуру и не учитывая историю добавлений.
|
|
||||||
?Разрешение коллизий. Даже если порядок вставки влияет на расположение элементов внутри цепочки (метод цепочек) или на последовательность проб (открытая адресация), это касается лишь небольших групп элементов с одинаковыми хешами. Общая производительность остаётся стабильной.
|
|
||||||
?Рехеширование. При увеличении размера таблицы все элементы перераспределяются заново. Новый порядок определяется актуальной хеш-функцией и размером таблицы, а не исходной последовательностью вставки.
|
|
||||||
Итог: Время выполнения операций зависит от качества хеш-функции, коэффициента заполнения таблицы и метода разрешения коллизий, но не зависит от порядка добавления элементов.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Почему связный список всегда медленен при поиске
|
|
||||||
|
|
||||||
Связный список показывает низкую скорость поиска из-за необходимости последовательного обхода: чтобы найти элемент, требуется пройти по указателям от головы до нужного узла.
|
|
||||||
Почему это происходит:
|
|
||||||
?Отсутствие произвольного доступа. В отличие от массива, где доступ по индексу занимает O(1), в связном списке элементы приходится перебирать последовательно, что даёт сложность поиска O(n).
|
|
||||||
?Низкая локальность данных. Узлы списка разбросаны по памяти случайным образом. Это вызывает частые промахи кэша: процессор не может подгрузить блок соседних данных, и каждый переход по указателю оборачивается новым обращением к оперативной памяти.
|
|
||||||
?Дополнительная память на указатели. Каждый узел хранит не только полезные данные, но и указатель на следующий элемент. Это увеличивает объём памяти и ухудшает эффективность кэша — на те же данные приходится загружать больше информации.
|
|
||||||
?Затраты на разыменование указателей. На каждом шаге поиска процессору нужно:
|
|
||||||
oпрочитать текущий узел,
|
|
||||||
oизвлечь из него указатель на следующий,
|
|
||||||
oперейти по этому адресу.
|
|
||||||
Эти операции замедляют работу по сравнению с простым сдвигом индекса в массиве.
|
|
||||||
Итог: хотя алгоритмическая сложность обхода составляет O(n) как для массива (при линейном поиске), так и для связного списка, на практике список работает ощутимо медленнее из-за особенностей организации памяти и работы кэша.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Как удаление работает в каждой структуре
|
|
||||||
|
|
||||||
1. Связный список
|
|
||||||
Односвязный список: чтобы удалить узел, необходимо сначала найти предыдущий элемент и перенаправить его указатель next на узел, следующий за удаляемым. Исключение — удаление первого элемента: достаточно сдвинуть указатель head на второй узел.
|
|
||||||
Двусвязный список: удаление проще, поскольку у каждого узла есть указатели и на следующий (next), и на предыдущий (prev). При удалении обновляются ссылки обоих соседей: prev->next = next, next->prev = prev.
|
|
||||||
Сложность: в общем случае O(n) из-за необходимости поиска элемента; удаление головы или хвоста (при наличии прямой ссылки на хвост) выполняется за O(1).
|
|
||||||
2. Хеш таблица
|
|
||||||
Сначала через хеш-функцию h(key) вычисляется индекс ячейки. Дальнейшие действия зависят от метода разрешения коллизий:
|
|
||||||
?Раздельная цепочка: элемент удаляется из связного списка (или другой структуры), находящегося по вычисленному индексу.
|
|
||||||
?Открытая адресация: ячейка помечается специальным маркером «удалён», а не просто как пустая — это важно для корректности последующих операций поиска.
|
|
||||||
Сложность: в среднем O(1), в худшем случае O(n) (при большом количестве коллизий).
|
|
||||||
3. Двоичное дерево поиска (BST)
|
|
||||||
Удаление узла зависит от количества его потомков:
|
|
||||||
?Нет детей (лист): узел просто удаляется, ссылка родителя обнуляется.
|
|
||||||
?Один ребёнок: удаляемый узел заменяется его единственным потомком — родитель «перепрыгивает» через удаляемый узел.
|
|
||||||
?Два ребёнка:
|
|
||||||
1.Находится преемник (самый левый (наименьший) узел в правом поддереве) или предшественник (самый правый (наибольший) узел в левом поддереве).
|
|
||||||
2.Значение преемника/предшественника копируется в удаляемый узел.
|
|
||||||
3.Преемник/предшественник рекурсивно удаляется — он гарантированно имеет не более одного ребёнка.
|
|
||||||
Сложность: O(h), где h — высота дерева. В сбалансированном дереве h=O(logn), в несбалансированном — до O(n).
|
|
||||||
|
|
||||||
Вывод
|
|
||||||
1. Частые вставки
|
|
||||||
Связный список — отличный выбор для частых вставок (особенно в середину), если не требуется быстрый доступ по индексу. Вставка в начало или конец выполняется за O(1), в середину — за O(n) (но без сдвига элементов, как в массиве).
|
|
||||||
Хеш таблица — хорошо подходит для вставок по ключу, обеспечивая в среднем O(1).
|
|
||||||
2. Частый поиск
|
|
||||||
Хеш таблица — лучший вариант для быстрого поиска по ключу. Среднее время — O(1), в худшем случае — O(n) (при сильных коллизиях).
|
|
||||||
Сбалансированное двоичное дерево поиска — предпочтительнее, если нужен поиск с гарантированной сложностью O(logn) даже в худшем случае.
|
|
||||||
3. Необходимость получать данные в отсортированном порядке
|
|
||||||
Массив / список — эффективен, если данные уже отсортированы или сортировка происходит редко, а последовательное чтение — часто. Доступ по индексу — O(1), но вставка и удаление в середину требуют O(n).
|
|
||||||
Отсортированный массив — удобен для поиска (бинарный поиск даёт (O(logn)), однако вставки и удаления обходятся в O(n).
|
|
||||||
Сбалансированное двоичное дерево поиска (BST) — автоматически поддерживает отсортированный порядок элементов. Все основные операции выполняются за O(logn). Идеальный вариант, когда данные часто изменяются и при этом требуется обход элементов в отсортированном порядке.
|
|
||||||
|
|
@ -1,19 +0,0 @@
|
||||||
Structure,Mode,Operation,Time_seconds
|
|
||||||
LinkedList,random,insert,7.967956480104476
|
|
||||||
LinkedList,random,find,0.05891917999833822
|
|
||||||
LinkedList,random,delete,0.03816298004239797
|
|
||||||
HashTable,random,insert,0.39825033992528913
|
|
||||||
HashTable,random,find,0.002917400002479553
|
|
||||||
HashTable,random,delete,0.0021501399576663973
|
|
||||||
BST,random,insert,0.02822491992264986
|
|
||||||
BST,random,find,0.00023473985493183136
|
|
||||||
BST,random,delete,0.00016456004232168198
|
|
||||||
LinkedList,sorted,insert,8.014810599852353
|
|
||||||
LinkedList,sorted,find,0.058480959851294756
|
|
||||||
LinkedList,sorted,delete,0.04817821998149156
|
|
||||||
HashTable,sorted,insert,0.3703480200842023
|
|
||||||
HashTable,sorted,find,0.002751259971410036
|
|
||||||
HashTable,sorted,delete,0.0018340200185775757
|
|
||||||
BST,sorted,insert,7.301413399912417
|
|
||||||
BST,sorted,find,0.06847236007452011
|
|
||||||
BST,sorted,delete,0.03443789994344115
|
|
||||||
|
|
|
@ -1,589 +0,0 @@
|
||||||
import time
|
|
||||||
import heapq
|
|
||||||
from collections import deque
|
|
||||||
from typing import List, Optional, Dict, Tuple
|
|
||||||
from abc import ABC, abstractmethod
|
|
||||||
import csv
|
|
||||||
import random
|
|
||||||
|
|
||||||
|
|
||||||
class Cell:
|
|
||||||
def __init__(self, x: int, y: int):
|
|
||||||
self.x = x
|
|
||||||
self.y = y
|
|
||||||
self.is_wall = False
|
|
||||||
self.is_start = False
|
|
||||||
self.is_exit = False
|
|
||||||
|
|
||||||
def is_passable(self) -> bool:
|
|
||||||
return not self.is_wall
|
|
||||||
|
|
||||||
|
|
||||||
class Maze:
|
|
||||||
def __init__(self, width: int, height: int):
|
|
||||||
self.width = width
|
|
||||||
self.height = height
|
|
||||||
self.cells = [[Cell(x, y) for y in range(height)] for x in range(width)]
|
|
||||||
self.start: Optional[Cell] = None
|
|
||||||
self.exit: Optional[Cell] = None
|
|
||||||
|
|
||||||
def get_cell(self, x: int, y: int) -> Optional[Cell]:
|
|
||||||
if 0 <= x < self.width and 0 <= y < self.height:
|
|
||||||
return self.cells[x][y]
|
|
||||||
return None
|
|
||||||
|
|
||||||
def get_neighbors(self, cell: Cell) -> List[Cell]:
|
|
||||||
neighbors = []
|
|
||||||
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
|
|
||||||
nx, ny = cell.x + dx, cell.y + dy
|
|
||||||
nb = self.get_cell(nx, ny)
|
|
||||||
if nb and nb.is_passable():
|
|
||||||
neighbors.append(nb)
|
|
||||||
return neighbors
|
|
||||||
|
|
||||||
|
|
||||||
class MazeBuilder(ABC):
|
|
||||||
@abstractmethod
|
|
||||||
def build_from_file(self, filename: str) -> Maze:
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class TextFileMazeBuilder(MazeBuilder):
|
|
||||||
def build_from_file(self, filename: str) -> Maze:
|
|
||||||
with open(filename, 'r', encoding='utf-8') 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, ch in enumerate(line):
|
|
||||||
cell = maze.get_cell(x, y)
|
|
||||||
if cell is None:
|
|
||||||
continue
|
|
||||||
if ch == '#':
|
|
||||||
cell.is_wall = True
|
|
||||||
elif ch == 'S':
|
|
||||||
cell.is_start = True
|
|
||||||
maze.start = cell
|
|
||||||
elif ch == 'E':
|
|
||||||
cell.is_exit = True
|
|
||||||
maze.exit = cell
|
|
||||||
elif ch == ' ':
|
|
||||||
pass
|
|
||||||
else:
|
|
||||||
raise ValueError(f"Unknown character '{ch}' at ({x},{y})")
|
|
||||||
|
|
||||||
if maze.start is None or maze.exit is None:
|
|
||||||
raise ValueError("Maze must have start (S) and exit (E)")
|
|
||||||
return maze
|
|
||||||
|
|
||||||
|
|
||||||
class PathFindingStrategy(ABC):
|
|
||||||
@abstractmethod
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
pass
|
|
||||||
|
|
||||||
@abstractmethod
|
|
||||||
def get_name(self) -> str:
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class BFSStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
queue = deque([start])
|
|
||||||
came_from = {start: None}
|
|
||||||
|
|
||||||
while queue:
|
|
||||||
current = queue.popleft()
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
for nb in maze.get_neighbors(current):
|
|
||||||
if nb not in came_from:
|
|
||||||
came_from[nb] = current
|
|
||||||
queue.append(nb)
|
|
||||||
|
|
||||||
if exit not in came_from:
|
|
||||||
return []
|
|
||||||
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "BFS"
|
|
||||||
|
|
||||||
|
|
||||||
class DFSStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
stack = [start]
|
|
||||||
came_from = {start: None}
|
|
||||||
|
|
||||||
while stack:
|
|
||||||
current = stack.pop()
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
for nb in maze.get_neighbors(current):
|
|
||||||
if nb not in came_from:
|
|
||||||
came_from[nb] = current
|
|
||||||
stack.append(nb)
|
|
||||||
|
|
||||||
if exit not in came_from:
|
|
||||||
return []
|
|
||||||
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "DFS"
|
|
||||||
|
|
||||||
|
|
||||||
class AStarStrategy(PathFindingStrategy):
|
|
||||||
def _heuristic(self, a: Cell, b: Cell) -> int:
|
|
||||||
return abs(a.x - b.x) + abs(a.y - b.y)
|
|
||||||
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
open_set = []
|
|
||||||
heapq.heappush(open_set, (0, id(start), start))
|
|
||||||
came_from = {}
|
|
||||||
g_score = {start: 0}
|
|
||||||
f_score = {start: self._heuristic(start, exit)}
|
|
||||||
|
|
||||||
while open_set:
|
|
||||||
_, _, current = heapq.heappop(open_set)
|
|
||||||
|
|
||||||
if current == exit:
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur in came_from:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.append(start)
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
for neighbor in maze.get_neighbors(current):
|
|
||||||
tentative_g = g_score[current] + 1
|
|
||||||
if tentative_g < g_score.get(neighbor, float('inf')):
|
|
||||||
came_from[neighbor] = current
|
|
||||||
g_score[neighbor] = tentative_g
|
|
||||||
f_score[neighbor] = tentative_g + self._heuristic(neighbor, exit)
|
|
||||||
heapq.heappush(open_set, (f_score[neighbor], id(neighbor), neighbor))
|
|
||||||
|
|
||||||
return []
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "A*"
|
|
||||||
|
|
||||||
|
|
||||||
class DijkstraStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
pq = [(0, id(start), start)]
|
|
||||||
distances = {start: 0}
|
|
||||||
came_from = {start: None}
|
|
||||||
|
|
||||||
while pq:
|
|
||||||
dist, _, current = heapq.heappop(pq)
|
|
||||||
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
|
|
||||||
if dist > distances[current]:
|
|
||||||
continue
|
|
||||||
|
|
||||||
for neighbor in maze.get_neighbors(current):
|
|
||||||
new_dist = dist + 1
|
|
||||||
if new_dist < distances.get(neighbor, float('inf')):
|
|
||||||
distances[neighbor] = new_dist
|
|
||||||
came_from[neighbor] = current
|
|
||||||
heapq.heappush(pq, (new_dist, id(neighbor), neighbor))
|
|
||||||
|
|
||||||
if exit not in came_from:
|
|
||||||
return []
|
|
||||||
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "Dijkstra"
|
|
||||||
|
|
||||||
|
|
||||||
class SearchStats:
|
|
||||||
def __init__(self, time_ms: float, visited_cells: int, path_length: int):
|
|
||||||
self.time_ms = time_ms
|
|
||||||
self.visited_cells = visited_cells
|
|
||||||
self.path_length = path_length
|
|
||||||
|
|
||||||
def __str__(self):
|
|
||||||
return f"Time: {self.time_ms:.2f}ms, Visited: {self.visited_cells}, Path: {self.path_length}"
|
|
||||||
|
|
||||||
|
|
||||||
class MazeSolver:
|
|
||||||
def __init__(self, maze: Maze, strategy: PathFindingStrategy):
|
|
||||||
self.maze = maze
|
|
||||||
self.strategy = strategy
|
|
||||||
|
|
||||||
def set_strategy(self, strategy: PathFindingStrategy):
|
|
||||||
self.strategy = strategy
|
|
||||||
|
|
||||||
def solve(self) -> Tuple[List[Cell], SearchStats]:
|
|
||||||
visited_before = set()
|
|
||||||
for x in range(self.maze.width):
|
|
||||||
for y in range(self.maze.height):
|
|
||||||
cell = self.maze.get_cell(x, y)
|
|
||||||
if cell and cell.is_passable():
|
|
||||||
visited_before.add(cell)
|
|
||||||
|
|
||||||
start_time = time.perf_counter()
|
|
||||||
path = self.strategy.find_path(self.maze, self.maze.start, self.maze.exit)
|
|
||||||
end_time = time.perf_counter()
|
|
||||||
|
|
||||||
visited_after = set()
|
|
||||||
for x in range(self.maze.width):
|
|
||||||
for y in range(self.maze.height):
|
|
||||||
cell = self.maze.get_cell(x, y)
|
|
||||||
if cell and cell.is_passable():
|
|
||||||
visited_after.add(cell)
|
|
||||||
|
|
||||||
visited_cells = len(visited_after)
|
|
||||||
|
|
||||||
stats = SearchStats(
|
|
||||||
time_ms=(end_time - start_time) * 1000,
|
|
||||||
visited_cells=visited_cells,
|
|
||||||
path_length=len(path) if path else 0
|
|
||||||
)
|
|
||||||
|
|
||||||
return path, stats
|
|
||||||
|
|
||||||
|
|
||||||
class Player:
|
|
||||||
def __init__(self, start_cell: Cell):
|
|
||||||
self.current_cell = start_cell
|
|
||||||
self.previous_cell = None
|
|
||||||
|
|
||||||
def move_to(self, cell: Cell) -> bool:
|
|
||||||
if cell.is_passable():
|
|
||||||
self.previous_cell = self.current_cell
|
|
||||||
self.current_cell = cell
|
|
||||||
return True
|
|
||||||
return False
|
|
||||||
|
|
||||||
def undo(self):
|
|
||||||
if self.previous_cell:
|
|
||||||
self.current_cell, self.previous_cell = self.previous_cell, None
|
|
||||||
return True
|
|
||||||
return False
|
|
||||||
|
|
||||||
|
|
||||||
class Command(ABC):
|
|
||||||
@abstractmethod
|
|
||||||
def execute(self) -> bool:
|
|
||||||
pass
|
|
||||||
|
|
||||||
@abstractmethod
|
|
||||||
def undo(self):
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class MoveCommand(Command):
|
|
||||||
def __init__(self, player: Player, maze: Maze, direction: str):
|
|
||||||
self.player = player
|
|
||||||
self.maze = maze
|
|
||||||
self.direction = direction
|
|
||||||
self.executed = False
|
|
||||||
|
|
||||||
def execute(self) -> bool:
|
|
||||||
dx, dy = 0, 0
|
|
||||||
if self.direction == 'W' or self.direction == 'w':
|
|
||||||
dy = -1
|
|
||||||
elif self.direction == 'S' or self.direction == 's':
|
|
||||||
dy = 1
|
|
||||||
elif self.direction == 'A' or self.direction == 'a':
|
|
||||||
dx = -1
|
|
||||||
elif self.direction == 'D' or self.direction == 'd':
|
|
||||||
dx = 1
|
|
||||||
|
|
||||||
new_x = self.player.current_cell.x + dx
|
|
||||||
new_y = self.player.current_cell.y + dy
|
|
||||||
new_cell = self.maze.get_cell(new_x, new_y)
|
|
||||||
|
|
||||||
if new_cell and new_cell.is_passable():
|
|
||||||
self.executed = self.player.move_to(new_cell)
|
|
||||||
return self.executed
|
|
||||||
return False
|
|
||||||
|
|
||||||
def undo(self):
|
|
||||||
if self.executed:
|
|
||||||
self.player.undo()
|
|
||||||
self.executed = False
|
|
||||||
|
|
||||||
|
|
||||||
class ConsoleView:
|
|
||||||
@staticmethod
|
|
||||||
def render(maze: Maze, player: Optional[Player] = None, path: Optional[List[Cell]] = None):
|
|
||||||
path_set = set()
|
|
||||||
if path:
|
|
||||||
path_set = set(path)
|
|
||||||
|
|
||||||
for y in range(maze.height):
|
|
||||||
line = ""
|
|
||||||
for x in range(maze.width):
|
|
||||||
cell = maze.get_cell(x, y)
|
|
||||||
if not cell:
|
|
||||||
line += " "
|
|
||||||
elif player and player.current_cell == cell:
|
|
||||||
line += "P"
|
|
||||||
elif cell.is_start:
|
|
||||||
line += "S"
|
|
||||||
elif cell.is_exit:
|
|
||||||
line += "E"
|
|
||||||
elif cell.is_wall:
|
|
||||||
line += "#"
|
|
||||||
elif path and cell in path_set:
|
|
||||||
line += "."
|
|
||||||
else:
|
|
||||||
line += " "
|
|
||||||
print(line)
|
|
||||||
print()
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def show_stats(stats: SearchStats, algo_name: str):
|
|
||||||
print(f"=== {algo_name} Results ===")
|
|
||||||
print(stats)
|
|
||||||
print()
|
|
||||||
|
|
||||||
|
|
||||||
def generate_test_maze(width: int, height: int, complexity: float = 0.3) -> Maze:
|
|
||||||
maze = Maze(width, height)
|
|
||||||
|
|
||||||
for x in range(width):
|
|
||||||
for y in range(height):
|
|
||||||
if random.random() < complexity:
|
|
||||||
maze.cells[x][y].is_wall = True
|
|
||||||
|
|
||||||
maze.start = maze.get_cell(0, 0)
|
|
||||||
if maze.start:
|
|
||||||
maze.start.is_start = True
|
|
||||||
maze.start.is_wall = False
|
|
||||||
|
|
||||||
maze.exit = maze.get_cell(width - 1, height - 1)
|
|
||||||
if maze.exit:
|
|
||||||
maze.exit.is_exit = True
|
|
||||||
maze.exit.is_wall = False
|
|
||||||
|
|
||||||
return maze
|
|
||||||
|
|
||||||
|
|
||||||
def generate_empty_maze(width: int, height: int) -> Maze:
|
|
||||||
maze = Maze(width, height)
|
|
||||||
|
|
||||||
for x in range(width):
|
|
||||||
for y in range(height):
|
|
||||||
maze.cells[x][y].is_wall = False
|
|
||||||
|
|
||||||
maze.start = maze.get_cell(0, 0)
|
|
||||||
if maze.start:
|
|
||||||
maze.start.is_start = True
|
|
||||||
|
|
||||||
maze.exit = maze.get_cell(width - 1, height - 1)
|
|
||||||
if maze.exit:
|
|
||||||
maze.exit.is_exit = True
|
|
||||||
|
|
||||||
return maze
|
|
||||||
|
|
||||||
|
|
||||||
def generate_no_exit_maze(width: int, height: int) -> Maze:
|
|
||||||
maze = Maze(width, height)
|
|
||||||
|
|
||||||
for x in range(width):
|
|
||||||
for y in range(height):
|
|
||||||
maze.cells[x][y].is_wall = False
|
|
||||||
|
|
||||||
for x in range(width):
|
|
||||||
maze.cells[x][height // 2].is_wall = True
|
|
||||||
|
|
||||||
maze.start = maze.get_cell(0, 0)
|
|
||||||
if maze.start:
|
|
||||||
maze.start.is_start = True
|
|
||||||
|
|
||||||
maze.exit = maze.get_cell(width - 1, height - 1)
|
|
||||||
if maze.exit:
|
|
||||||
maze.exit.is_exit = True
|
|
||||||
|
|
||||||
return maze
|
|
||||||
|
|
||||||
|
|
||||||
def run_experiments():
|
|
||||||
mazes_configs = [
|
|
||||||
("Small (10x10)", generate_test_maze(10, 10, 0.2)),
|
|
||||||
("Medium (50x50)", generate_test_maze(50, 50, 0.25)),
|
|
||||||
("Large (100x100)", generate_test_maze(100, 100, 0.3)),
|
|
||||||
("Empty (30x30)", generate_empty_maze(30, 30)),
|
|
||||||
("No Exit (20x20)", generate_no_exit_maze(20, 20))
|
|
||||||
]
|
|
||||||
|
|
||||||
strategies = [BFSStrategy(), DFSStrategy(), AStarStrategy(), DijkstraStrategy()]
|
|
||||||
|
|
||||||
results = []
|
|
||||||
|
|
||||||
for maze_name, maze in mazes_configs:
|
|
||||||
print(f"\n=== Testing: {maze_name} ===")
|
|
||||||
|
|
||||||
for strategy in strategies:
|
|
||||||
times = []
|
|
||||||
visited = []
|
|
||||||
path_lengths = []
|
|
||||||
|
|
||||||
solver = MazeSolver(maze, strategy)
|
|
||||||
|
|
||||||
for run in range(5):
|
|
||||||
maze_copy = Maze(maze.width, maze.height)
|
|
||||||
for x in range(maze.width):
|
|
||||||
for y in range(maze.height):
|
|
||||||
orig = maze.get_cell(x, y)
|
|
||||||
copy = maze_copy.get_cell(x, y)
|
|
||||||
if orig:
|
|
||||||
copy.is_wall = orig.is_wall
|
|
||||||
copy.is_start = orig.is_start
|
|
||||||
copy.is_exit = orig.is_exit
|
|
||||||
maze_copy.start = maze_copy.get_cell(maze.start.x, maze.start.y) if maze.start else None
|
|
||||||
maze_copy.exit = maze_copy.get_cell(maze.exit.x, maze.exit.y) if maze.exit else None
|
|
||||||
|
|
||||||
solver.maze = maze_copy
|
|
||||||
solver.set_strategy(strategy)
|
|
||||||
path, stats = solver.solve()
|
|
||||||
|
|
||||||
times.append(stats.time_ms)
|
|
||||||
visited.append(stats.visited_cells)
|
|
||||||
path_lengths.append(stats.path_length)
|
|
||||||
|
|
||||||
avg_time = sum(times) / len(times)
|
|
||||||
avg_visited = sum(visited) / len(visited)
|
|
||||||
avg_path = sum(path_lengths) / len(path_lengths)
|
|
||||||
|
|
||||||
results.append({
|
|
||||||
'maze': maze_name,
|
|
||||||
'algorithm': strategy.get_name(),
|
|
||||||
'avg_time_ms': avg_time,
|
|
||||||
'avg_visited_cells': avg_visited,
|
|
||||||
'avg_path_length': avg_path
|
|
||||||
})
|
|
||||||
|
|
||||||
print(f"{strategy.get_name()}: {avg_time:.2f}ms, {avg_visited:.0f} cells, path={avg_path:.0f}")
|
|
||||||
|
|
||||||
with open('experiment_results.csv', 'w', newline='', encoding='utf-8') as f:
|
|
||||||
writer = csv.DictWriter(f, fieldnames=['maze', 'algorithm', 'avg_time_ms', 'avg_visited_cells', 'avg_path_length'])
|
|
||||||
writer.writeheader()
|
|
||||||
writer.writerows(results)
|
|
||||||
|
|
||||||
print("\nResults saved to experiment_results.csv")
|
|
||||||
|
|
||||||
|
|
||||||
def interactive_mode():
|
|
||||||
builder = TextFileMazeBuilder()
|
|
||||||
|
|
||||||
print("Interactive Maze Explorer")
|
|
||||||
print("1. Load maze from file")
|
|
||||||
print("2. Generate random maze")
|
|
||||||
choice = input("Choose (1/2): ")
|
|
||||||
|
|
||||||
if choice == '1':
|
|
||||||
filename = input("Enter filename: ")
|
|
||||||
try:
|
|
||||||
maze = builder.build_from_file(filename)
|
|
||||||
except Exception as e:
|
|
||||||
print(f"Error loading maze: {e}")
|
|
||||||
return
|
|
||||||
else:
|
|
||||||
w = int(input("Width: "))
|
|
||||||
h = int(input("Height: "))
|
|
||||||
maze = generate_test_maze(w, h, 0.3)
|
|
||||||
|
|
||||||
player = Player(maze.start)
|
|
||||||
|
|
||||||
strategies = {
|
|
||||||
'1': BFSStrategy(),
|
|
||||||
'2': DFSStrategy(),
|
|
||||||
'3': AStarStrategy(),
|
|
||||||
'4': DijkstraStrategy()
|
|
||||||
}
|
|
||||||
|
|
||||||
print("\nSelect algorithm for solving:")
|
|
||||||
print("1. BFS (shortest path)")
|
|
||||||
print("2. DFS (fast, not optimal)")
|
|
||||||
print("3. A* (heuristic)")
|
|
||||||
print("4. Dijkstra")
|
|
||||||
algo_choice = input("Choose: ")
|
|
||||||
|
|
||||||
solver = MazeSolver(maze, strategies.get(algo_choice, BFSStrategy()))
|
|
||||||
path, stats = solver.solve()
|
|
||||||
|
|
||||||
view = ConsoleView()
|
|
||||||
|
|
||||||
if path:
|
|
||||||
print(f"\nPath found! Length: {len(path)}")
|
|
||||||
view.show_stats(stats, solver.strategy.get_name())
|
|
||||||
else:
|
|
||||||
print("\nNo path found!")
|
|
||||||
|
|
||||||
while True:
|
|
||||||
view.render(maze, player, path if path else None)
|
|
||||||
|
|
||||||
if player.current_cell == maze.exit:
|
|
||||||
print("Congratulations! You reached the exit!")
|
|
||||||
break
|
|
||||||
|
|
||||||
cmd = input("Move (W/A/S/D) | U=undo | Q=quit | S=solve: ").upper()
|
|
||||||
|
|
||||||
if cmd == 'Q':
|
|
||||||
break
|
|
||||||
elif cmd == 'U':
|
|
||||||
player.undo()
|
|
||||||
print("Undo last move")
|
|
||||||
elif cmd == 'S' and path:
|
|
||||||
for cell in path:
|
|
||||||
if cell == player.current_cell:
|
|
||||||
continue
|
|
||||||
player.move_to(cell)
|
|
||||||
view.render(maze, player, path)
|
|
||||||
input("Press Enter to continue...")
|
|
||||||
if player.current_cell == maze.exit:
|
|
||||||
print("You reached the exit!")
|
|
||||||
break
|
|
||||||
elif cmd in ['W', 'A', 'S', 'D']:
|
|
||||||
move_cmd = MoveCommand(player, maze, cmd)
|
|
||||||
if move_cmd.execute():
|
|
||||||
print("Moved")
|
|
||||||
else:
|
|
||||||
print("Can't move there!")
|
|
||||||
|
|
||||||
|
|
||||||
def main():
|
|
||||||
print("Maze Solver with Design Patterns")
|
|
||||||
print("1. Run experiments")
|
|
||||||
print("2. Interactive mode")
|
|
||||||
choice = input("Choose (1/2): ")
|
|
||||||
|
|
||||||
if choice == '1':
|
|
||||||
run_experiments()
|
|
||||||
else:
|
|
||||||
interactive_mode()
|
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
main()
|
|
||||||
|
|
@ -1,21 +0,0 @@
|
||||||
maze,algorithm,avg_time_ms,avg_visited_cells,avg_path_length
|
|
||||||
Small (10x10),BFS,0.006740167737007141,80.0,0.0
|
|
||||||
Small (10x10),DFS,0.00408003106713295,80.0,0.0
|
|
||||||
Small (10x10),A*,0.005039852112531662,80.0,0.0
|
|
||||||
Small (10x10),Dijkstra,0.0031800009310245514,80.0,0.0
|
|
||||||
Medium (50x50),BFS,3.44578018411994,1890.0,99.0
|
|
||||||
Medium (50x50),DFS,1.3188599608838558,1890.0,341.0
|
|
||||||
Medium (50x50),A*,2.061920054256916,1890.0,99.0
|
|
||||||
Medium (50x50),Dijkstra,4.679400008171797,1890.0,99.0
|
|
||||||
Large (100x100),BFS,0.025319866836071014,6998.0,0.0
|
|
||||||
Large (100x100),DFS,0.019940081983804703,6998.0,0.0
|
|
||||||
Large (100x100),A*,0.035060010850429535,6998.0,0.0
|
|
||||||
Large (100x100),Dijkstra,0.02901991829276085,6998.0,0.0
|
|
||||||
Empty (30x30),BFS,1.2404202483594418,900.0,59.0
|
|
||||||
Empty (30x30),DFS,0.8887200616300106,900.0,465.0
|
|
||||||
Empty (30x30),A*,0.9468601085245609,900.0,59.0
|
|
||||||
Empty (30x30),Dijkstra,2.678940072655678,900.0,59.0
|
|
||||||
No Exit (20x20),BFS,0.27012014761567116,380.0,0.0
|
|
||||||
No Exit (20x20),DFS,0.3163599409162998,380.0,0.0
|
|
||||||
No Exit (20x20),A*,0.5885399878025055,380.0,0.0
|
|
||||||
No Exit (20x20),Dijkstra,0.5776201374828815,380.0,0.0
|
|
||||||
|
|
|
@ -1,196 +0,0 @@
|
||||||
Методы программирования
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Поиск выхода из лабиринта.
|
|
||||||
Анализ 2 задания
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Бобров К. Н.
|
|
||||||
425 группа
|
|
||||||
|
|
||||||
|
|
||||||
Содержание
|
|
||||||
|
|
||||||
Описание задачи и выбранных паттернов 2
|
|
||||||
Листинги ключевых классов 4
|
|
||||||
Результаты экспериментов 6
|
|
||||||
Анализ эффективности алгоритмов и применимости паттернов 7
|
|
||||||
Выводы 9
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Описание задачи и выбранных паттернов
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Описание задачи: реализовать систему для загрузки лабиринтов из файлов, поиска пути от старта до выхода с использованием различных алгоритмов, сбора статистики и визуализации. Ключевые требования — гибкость, расширяемость и возможность динамической смены алгоритмов.
|
|
||||||
|
|
||||||
Выбранные паттерны:
|
|
||||||
|
|
||||||
?Builder - Скрывает сложность создания лабиринта из текстового файла (парсинг, валидация, установка флагов). Позволяет легко добавить поддержку других форматов (JSON, XML).
|
|
||||||
?Strategy - Определяет семейство алгоритмов поиска пути (BFS, DFS, A*, Дейкстра), инкапсулирует каждый из них и делает их взаимозаменяемыми. Клиент (MazeSolver) может переключать стратегии во время выполнения.
|
|
||||||
?Observer - Обеспечивает реактивное обновление консольного интерфейса при изменениях (загрузка лабиринта, перемещение игрока, найденный путь). Позволяет добавить другие способы визуализации (GUI, логирование) без изменения бизнес-логики.
|
|
||||||
?Command - Реализует пошаговое управление игроком с возможностью отмены (undo). Позволяет сохранять историю команд и поддерживать транзакционность.
|
|
||||||
|
|
||||||
|
|
||||||
Листинги ключевых классов
|
|
||||||
|
|
||||||
Builder (TextFileMazeBuilder):
|
|
||||||
class TextFileMazeBuilder(MazeBuilder):
|
|
||||||
def build_from_file(self, filename: str) -> Maze:
|
|
||||||
with open(filename, 'r', encoding='utf-8') 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, ch in enumerate(line):
|
|
||||||
cell = maze.get_cell(x, y)
|
|
||||||
if cell is None:
|
|
||||||
continue
|
|
||||||
if ch == '#':
|
|
||||||
cell.is_wall = True
|
|
||||||
elif ch == 'S':
|
|
||||||
cell.is_start = True
|
|
||||||
maze.start = cell
|
|
||||||
elif ch == 'E':
|
|
||||||
cell.is_exit = True
|
|
||||||
maze.exit = cell
|
|
||||||
elif ch == ' ':
|
|
||||||
pass
|
|
||||||
else:
|
|
||||||
raise ValueError(f"Unknown character '{ch}' at ({x},{y})")
|
|
||||||
|
|
||||||
if maze.start is None or maze.exit is None:
|
|
||||||
raise ValueError("Maze must have start (S) and exit (E)")
|
|
||||||
return maze
|
|
||||||
Strategy (пример BFS):
|
|
||||||
class BFSStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze: Maze, start: Cell, exit: Cell) -> List[Cell]:
|
|
||||||
queue = deque([start])
|
|
||||||
came_from = {start: None}
|
|
||||||
|
|
||||||
while queue:
|
|
||||||
current = queue.popleft()
|
|
||||||
if current == exit:
|
|
||||||
break
|
|
||||||
for nb in maze.get_neighbors(current):
|
|
||||||
if nb not in came_from:
|
|
||||||
came_from[nb] = current
|
|
||||||
queue.append(nb)
|
|
||||||
|
|
||||||
if exit not in came_from:
|
|
||||||
return []
|
|
||||||
|
|
||||||
path = []
|
|
||||||
cur = exit
|
|
||||||
while cur:
|
|
||||||
path.append(cur)
|
|
||||||
cur = came_from[cur]
|
|
||||||
path.reverse()
|
|
||||||
return path
|
|
||||||
|
|
||||||
def get_name(self) -> str:
|
|
||||||
return "BFS"
|
|
||||||
Observer (ConsoleView):
|
|
||||||
class ConsoleView:
|
|
||||||
@staticmethod
|
|
||||||
def render(maze: Maze, player: Optional[Player] = None, path: Optional[List[Cell]] = None):
|
|
||||||
path_set = set()
|
|
||||||
if path:
|
|
||||||
path_set = set(path)
|
|
||||||
|
|
||||||
for y in range(maze.height):
|
|
||||||
line = ""
|
|
||||||
for x in range(maze.width):
|
|
||||||
cell = maze.get_cell(x, y)
|
|
||||||
if not cell:
|
|
||||||
line += " "
|
|
||||||
elif player and player.current_cell == cell:
|
|
||||||
line += "P"
|
|
||||||
elif cell.is_start:
|
|
||||||
line += "S"
|
|
||||||
elif cell.is_exit:
|
|
||||||
line += "E"
|
|
||||||
elif cell.is_wall:
|
|
||||||
line += "#"
|
|
||||||
elif path and cell in path_set:
|
|
||||||
line += "."
|
|
||||||
else:
|
|
||||||
line += " "
|
|
||||||
print(line)
|
|
||||||
print()
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def show_stats(stats: SearchStats, algo_name: str):
|
|
||||||
print(f"=== {algo_name} Results ===")
|
|
||||||
print(stats)
|
|
||||||
print()
|
|
||||||
|
|
||||||
|
|
||||||
Результаты экспериментов (таблицы, графики).
|
|
||||||
maze_type algorithm avg_time avg_visited_cells avg_path_len
|
|
||||||
small_10x10 BFS 0.08572000006097369 79.0 19.0
|
|
||||||
small_10x10 DFS 0.039739999920129776 79.0 31.0
|
|
||||||
small_10x10_ A* 0.13467999997374136 79.0 19.0
|
|
||||||
small_10x10 Dijkstra 0.11474000057205558 79.0 19.0
|
|
||||||
medium_50x50 BFS 1.8074600004183594 1874.0 99.0
|
|
||||||
medium_50x50 DFS 0.5937599995377241 1874.0 429.0
|
|
||||||
medium_50x50 A* 1.6300600003887666 1874.0 99.0
|
|
||||||
medium_50x50 Dijkstra 3.1870400001935195 1874.0 99.0
|
|
||||||
large_100x100 BFS 0.014439999722526409 7033.0 0.0
|
|
||||||
large_100x100 DFS 0.014839999857940711 7033.0 0.0
|
|
||||||
large_100x100 A* 0.02542000001994893 7033.0 0.0
|
|
||||||
large_100x100 Dijkstra 0.02548000011302065 7033.0 0.0
|
|
||||||
empty_30x30 BFS 0.784620000194991 900.0 59.0
|
|
||||||
empty_30x30 DFS 0.5252399994787993 900.0 465.
|
|
||||||
empty_30x30 A* 1.150900000357069 900.0 59.0
|
|
||||||
empty_30x30 Dijkstra 1.564640000287909 900.0 59.0
|
|
||||||
no_exit_20x20 BFS 0.2002399993216386 380. 0.0
|
|
||||||
no_exit_20x20 DFS 0.2512400002160575 380.0 0.0
|
|
||||||
no_exit_20x20 A* 0.5590400000073714 380.0 0.
|
|
||||||
no_exit_20x20 Dijkstra 0.35640000060084276 380.0 0.0
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Графики построены кодом из файла RESULT22.
|
|
||||||
|
|
||||||
Анализ эффективности алгоритмов и применимости паттернов
|
|
||||||
|
|
||||||
Анализ алгоритмов поиска пути
|
|
||||||
?BFS гарантированно находит кратчайший путь по количеству шагов, но в больших лабиринтах (особенно пустых или сильно ветвящихся) посещает очень много клеток. Время работы растёт пропорционально числу достижимых клеток.
|
|
||||||
?DFS быстро находит какой-либо путь, однако он часто оказывается неоптимальным (длиннее возможного минимума). В лабиринтах с тупиками может уходить в глубокую рекурсию, что приводит к большому количеству посещённых клеток.
|
|
||||||
?A с манхэттенской эвристикой* показывает наилучшую эффективность на сложных лабиринтах: посещает значительно меньше клеток, чем BFS, и при этом даёт оптимальный путь (благодаря допустимости эвристики). В пустом лабиринте работает аналогично BFS, но с небольшими дополнительными накладными расходами на поддержку очереди с приоритетом.
|
|
||||||
?Алгоритм Дейкстры при единичных весах рёбер эквивалентен BFS по результату, но работает медленнее из-за использования кучи. Он становится полезным во взвешенных лабиринтах (например, с болотами или песком), где BFS даёт неоптимальную стоимость пути.
|
|
||||||
Применимость паттернов проектирования
|
|
||||||
?Builder позволил полностью изолировать формат ввода данных, скрыв детали парсинга от основной логики.
|
|
||||||
?Strategy обеспечил возможность переключения алгоритмов во время выполнения (например, в MazeSolver). Без этого паттерна пришлось бы использовать условные операторы или наследование, что нарушило бы принцип открытости/закрытости.
|
|
||||||
?Observer отделил визуализацию от бизнес-логики. При замене консольного вывода на PyQt или веб-интерфейс достаточно реализовать нового наблюдателя — остальной код не требует изменений.
|
|
||||||
?Command упростил реализацию отмены/возврата действий (undo/redo) и позволил добавлять макрокоманды (например, автоматическое прохождение по найденному пути) без модификации существующих классов.
|
|
||||||
|
|
||||||
Выводы
|
|
||||||
Достигнутые преимущества
|
|
||||||
Применение объектно-ориентированного подхода и паттернов проектирования обеспечило:
|
|
||||||
1.Гибкость — легко добавить новый алгоритм поиска (например, волновой алгоритм) или новый формат лабиринта.
|
|
||||||
2.Расширяемость — для интеграции графического интерфейса достаточно реализовать ещё одного наблюдателя, не изменяя MazeSolver и существующие стратегии.
|
|
||||||
3.Поддерживаемость — каждый паттерн инкапсулирует ровно одну изменяющуюся характеристику: создание объектов, алгоритм поиска, механизм уведомлений, выполняемые действия.
|
|
||||||
4.Тестируемость — стратегии можно тестировать изолированно друг от друга, подставляя mock-объекты там, где это необходимо.
|
|
||||||
Что потребовало бы больших усилий без паттернов
|
|
||||||
?Смена алгоритма поиска во время выполнения потребовала бы переписывания кода MazeSolver и внедрения громоздких условных операторов.
|
|
||||||
?Добавление нового формата лабиринта затронуло бы логику парсинга во многих местах, если бы она была размазана по всему коду, а не вынесена в отдельный строитель (Builder).
|
|
||||||
?Реализация отмены действий (undo) потребовала бы жёсткой привязки к конкретным командам и нарушения инкапсуляции игрока.
|
|
||||||
?Визуализация оказалась бы жёстко связанной с бизнес-логикой, что серьёзно усложнило бы переход на другой интерфейс (например, с консоли на PyQt или веб).
|
|
||||||
Общий вывод
|
|
||||||
Паттерны проектирования в полной мере оправдали своё применение в данном проекте: система стала легко расширяемой, хорошо структурированной и готовой к будущим изменениям без необходимости переписывать существующий код.
|
|
||||||
Binary file not shown.
|
Before Width: | Height: | Size: 13 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 13 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 13 KiB |
|
|
@ -1,19 +0,0 @@
|
||||||
structure,order,operation,run1,run2,run3,run4,run5,average
|
|
||||||
LinkedList,random,insert,3.000600399999712,3.022712899999533,2.9421689999999217,2.9075659000000087,3.0319512999994913,2.980999899999733
|
|
||||||
LinkedList,random,find,0.031094500000108383,0.02800200000001496,0.034349299999121286,0.029372199999670556,0.03242119999958959,0.031047839999700955
|
|
||||||
LinkedList,random,delete,0.017322699999567703,0.0368361000000732,0.04029200000059063,0.03775789999963308,0.03554420000000391,0.033550579999973705
|
|
||||||
HashTable,random,insert,0.011551699999472476,0.012756400000398571,0.011765299999751733,0.011679000000185624,0.011983400000644906,0.011947160000090662
|
|
||||||
HashTable,random,find,0.00012409999999363208,0.00011009999980160501,0.0001415999995515449,0.00010400000064691994,0.00010089999977935804,0.000116139999954612
|
|
||||||
HashTable,random,delete,6.38999999864609e-05,6.779999966965988e-05,6.0600000324484427e-05,6.070000017643906e-05,6.0600000324484427e-05,6.272000009630574e-05
|
|
||||||
BST,random,insert,0.014788199999202334,0.014159299999846553,0.013975800000480376,0.014118900000539725,0.013331299999663315,0.01407469999994646
|
|
||||||
BST,random,find,0.00013829999988956843,0.00011389999963284936,0.00011369999992894009,0.00011379999978089472,0.00011439999980211724,0.00011881999980687397
|
|
||||||
BST,random,delete,8.690000049682567e-05,6.450000000768341e-05,6.2199999774748e-05,6.209999992279336e-05,6.229999962670263e-05,6.759999996575061e-05
|
|
||||||
LinkedList,sorted,insert,2.4411346000006233,2.36463619999995,2.2797248999995645,2.2860746000005747,2.2526011999998445,2.3248343000001115
|
|
||||||
LinkedList,sorted,find,0.024703000000044995,0.02455259999987902,0.02468479999970441,0.02444869999999355,0.02606350000041857,0.02489052000000811
|
|
||||||
LinkedList,sorted,delete,0.012835599999561964,0.027673999999933585,0.027570299999752024,0.02708100000018021,0.02999909999925876,0.02503199999973731
|
|
||||||
HashTable,sorted,insert,0.011780100000578386,0.010850699999537028,0.010314100000869075,0.010621500000524975,0.011015500000212342,0.010916380000344362
|
|
||||||
HashTable,sorted,find,0.0001464000006308197,0.00017980000029638177,0.00016909999976633117,0.00012620000052265823,0.00023630000032426324,0.0001715600003080908
|
|
||||||
HashTable,sorted,delete,0.00016370000048482325,0.00018089999957737746,0.0001443999999537482,7.579999964946182e-05,6.469999971159268e-05,0.0001258999998754007
|
|
||||||
BST,sorted,insert,3.5400651999998445,3.5145174999997835,3.5583661999999094,3.5149656000003233,3.481246600000304,3.521832220000033
|
|
||||||
BST,sorted,find,0.03275260000009439,0.030442500000390282,0.02994349999971746,0.030269500000031258,0.030329999999594293,0.030747619999965538
|
|
||||||
BST,sorted,delete,0.012705400000413647,0.01333390000036161,0.013192000000344706,0.013699000000087835,0.013079800000014075,0.013202020000244374
|
|
||||||
|
|
|
@ -1,34 +0,0 @@
|
||||||
Лабораторная работа 1
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Цель работы
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Нужно было сделать три структуры данных и проверить как они работают на телефонном справочнике.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Ход работы
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Сделал связный список хеш таблицу и двоичное дерево поиска. Для всех структур сделал добавление поиск удаление и вывод записей. Для проверки создал 10000 записей с именами User\_00000 и т.д. Потом проверил работу со случайным порядком и с отсортированным порядком. Каждый эксперимент повторял 5 раз.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Результаты
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Результаты сохранились в results.csv. Также сделал графики для добавления поиска и удаления. По результатам видно что связный список медленно ищет записи потому что нужно идти по элементам. Хеш таблица работает примерно одинаково при разном порядке записей. У двоичного дерева порядок записей влияет намного сильнее. Если добавлять записи по порядку дерево становится похожим на обычный список и работает медленнее.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Вывод
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
В работе я сделал три структуры данных и проверил их работу. Самой удобной для телефонного справочника получилась хеш таблица. Связный список проще но поиск медленный. Двоичное дерево может работать быстро но сильно зависит от порядка добавления данных.
|
|
||||||
|
|
||||||
|
|
@ -1,185 +0,0 @@
|
||||||
import random
|
|
||||||
import time
|
|
||||||
import csv
|
|
||||||
import os
|
|
||||||
|
|
||||||
from phonebook import *
|
|
||||||
|
|
||||||
N = 10000
|
|
||||||
REPEATS = 5
|
|
||||||
|
|
||||||
def generate_test_data():
|
|
||||||
records = [
|
|
||||||
(f"User_{i:05d}", f"+7900000{i:04d}")
|
|
||||||
for i in range(N)
|
|
||||||
]
|
|
||||||
|
|
||||||
records_shuffled = records.copy()
|
|
||||||
random.shuffle(records_shuffled)
|
|
||||||
|
|
||||||
records_sorted = records.copy()
|
|
||||||
|
|
||||||
return records_shuffled, records_sorted
|
|
||||||
|
|
||||||
def measure_experiment(insert_function, find_function, delete_function, records):
|
|
||||||
insert_times = []
|
|
||||||
find_times = []
|
|
||||||
delete_times = []
|
|
||||||
|
|
||||||
for _ in range(REPEATS):
|
|
||||||
structure = None
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name, phone in records:
|
|
||||||
structure = insert_function(structure, name, phone)
|
|
||||||
|
|
||||||
insert_times.append(time.perf_counter() - start)
|
|
||||||
|
|
||||||
structure_for_find = structure
|
|
||||||
|
|
||||||
names = [name for name, phone in records]
|
|
||||||
search_names = random.sample(names, 100) + [
|
|
||||||
"NotFound_001",
|
|
||||||
"NotFound_002",
|
|
||||||
"NotFound_003",
|
|
||||||
"NotFound_004",
|
|
||||||
"NotFound_005",
|
|
||||||
"NotFound_006",
|
|
||||||
"NotFound_007",
|
|
||||||
"NotFound_008",
|
|
||||||
"NotFound_009",
|
|
||||||
"NotFound_010"
|
|
||||||
]
|
|
||||||
|
|
||||||
for _ in range(REPEATS):
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name in search_names:
|
|
||||||
find_function(structure_for_find, name)
|
|
||||||
|
|
||||||
find_times.append(time.perf_counter() - start)
|
|
||||||
|
|
||||||
delete_names = random.sample(names, 50)
|
|
||||||
|
|
||||||
for _ in range(REPEATS):
|
|
||||||
structure = structure_for_find
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name in delete_names:
|
|
||||||
structure = delete_function(structure, name)
|
|
||||||
|
|
||||||
delete_times.append(time.perf_counter() - start)
|
|
||||||
|
|
||||||
return insert_times, find_times, delete_times
|
|
||||||
|
|
||||||
def measure_hash(records):
|
|
||||||
insert_times = []
|
|
||||||
find_times = []
|
|
||||||
delete_times = []
|
|
||||||
|
|
||||||
names = [name for name, phone in records]
|
|
||||||
search_names = random.sample(names, 100) + [
|
|
||||||
f"NotFound_{i:03d}" for i in range(10)
|
|
||||||
]
|
|
||||||
delete_names = random.sample(names, 50)
|
|
||||||
|
|
||||||
for _ in range(REPEATS):
|
|
||||||
buckets = ht_create()
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name, phone in records:
|
|
||||||
ht_insert(buckets, name, phone)
|
|
||||||
|
|
||||||
insert_times.append(time.perf_counter() - start)
|
|
||||||
|
|
||||||
structure_for_find = buckets
|
|
||||||
|
|
||||||
for _ in range(REPEATS):
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name in search_names:
|
|
||||||
ht_find(structure_for_find, name)
|
|
||||||
|
|
||||||
find_times.append(time.perf_counter() - start)
|
|
||||||
|
|
||||||
for _ in range(REPEATS):
|
|
||||||
buckets = structure_for_find.copy()
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name in delete_names:
|
|
||||||
ht_delete(buckets, name)
|
|
||||||
|
|
||||||
delete_times.append(time.perf_counter() - start)
|
|
||||||
|
|
||||||
return insert_times, find_times, delete_times
|
|
||||||
|
|
||||||
def average(values):
|
|
||||||
return sum(values) / len(values)
|
|
||||||
|
|
||||||
def run():
|
|
||||||
records_shuffled, records_sorted = generate_test_data()
|
|
||||||
|
|
||||||
results = []
|
|
||||||
|
|
||||||
for order_name, records in [
|
|
||||||
("random", records_shuffled),
|
|
||||||
("sorted", records_sorted)
|
|
||||||
]:
|
|
||||||
print("Order:", order_name)
|
|
||||||
|
|
||||||
ll = measure_experiment(
|
|
||||||
ll_insert,
|
|
||||||
ll_find,
|
|
||||||
ll_delete,
|
|
||||||
records
|
|
||||||
)
|
|
||||||
|
|
||||||
results.append(["LinkedList", order_name, "insert", *ll[0]])
|
|
||||||
results.append(["LinkedList", order_name, "find", *ll[1]])
|
|
||||||
results.append(["LinkedList", order_name, "delete", *ll[2]])
|
|
||||||
|
|
||||||
ht = measure_hash(records)
|
|
||||||
|
|
||||||
results.append(["HashTable", order_name, "insert", *ht[0]])
|
|
||||||
results.append(["HashTable", order_name, "find", *ht[1]])
|
|
||||||
results.append(["HashTable", order_name, "delete", *ht[2]])
|
|
||||||
|
|
||||||
bst = measure_experiment(
|
|
||||||
bst_insert,
|
|
||||||
bst_find,
|
|
||||||
bst_delete,
|
|
||||||
records
|
|
||||||
)
|
|
||||||
|
|
||||||
results.append(["BST", order_name, "insert", *bst[0]])
|
|
||||||
results.append(["BST", order_name, "find", *bst[1]])
|
|
||||||
results.append(["BST", order_name, "delete", *bst[2]])
|
|
||||||
|
|
||||||
os.makedirs("docs/data", exist_ok=True)
|
|
||||||
|
|
||||||
with open("docs/data/results.csv", "w", newline="", encoding="utf-8") as file:
|
|
||||||
writer = csv.writer(file)
|
|
||||||
|
|
||||||
writer.writerow([
|
|
||||||
"structure",
|
|
||||||
"order",
|
|
||||||
"operation",
|
|
||||||
"run1",
|
|
||||||
"run2",
|
|
||||||
"run3",
|
|
||||||
"run4",
|
|
||||||
"run5",
|
|
||||||
"average"
|
|
||||||
])
|
|
||||||
|
|
||||||
for row in results:
|
|
||||||
writer.writerow(row + [average(row[3:])])
|
|
||||||
|
|
||||||
print("Results saved to docs/data/results.csv")
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
run()
|
|
||||||
|
|
@ -1,56 +0,0 @@
|
||||||
import csv
|
|
||||||
import os
|
|
||||||
import matplotlib.pyplot as plt
|
|
||||||
|
|
||||||
data = []
|
|
||||||
|
|
||||||
with open("docs/data/results.csv", "r", encoding="utf-8") as file:
|
|
||||||
reader = csv.DictReader(file)
|
|
||||||
|
|
||||||
for row in reader:
|
|
||||||
data.append(row)
|
|
||||||
|
|
||||||
def get_average(structure, order, operation):
|
|
||||||
for row in data:
|
|
||||||
if (
|
|
||||||
row["structure"] == structure
|
|
||||||
and row["order"] == order
|
|
||||||
and row["operation"] == operation
|
|
||||||
):
|
|
||||||
return float(row["average"])
|
|
||||||
|
|
||||||
return 0
|
|
||||||
|
|
||||||
structures = ["LinkedList", "HashTable", "BST"]
|
|
||||||
orders = ["random", "sorted"]
|
|
||||||
|
|
||||||
os.makedirs("docs/data", exist_ok=True)
|
|
||||||
|
|
||||||
for operation in ["insert", "find", "delete"]:
|
|
||||||
random_values = [
|
|
||||||
get_average(s, "random", operation)
|
|
||||||
for s in structures
|
|
||||||
]
|
|
||||||
|
|
||||||
sorted_values = [
|
|
||||||
get_average(s, "sorted", operation)
|
|
||||||
for s in structures
|
|
||||||
]
|
|
||||||
|
|
||||||
x = range(len(structures))
|
|
||||||
|
|
||||||
plt.figure()
|
|
||||||
plt.bar([i - 0.2 for i in x], random_values, width=0.4, label="random")
|
|
||||||
plt.bar([i + 0.2 for i in x], sorted_values, width=0.4, label="sorted")
|
|
||||||
|
|
||||||
plt.xticks(list(x), structures)
|
|
||||||
plt.ylabel("Time, seconds")
|
|
||||||
plt.title(operation.capitalize() + " time")
|
|
||||||
plt.yscale("log")
|
|
||||||
plt.legend()
|
|
||||||
plt.tight_layout()
|
|
||||||
|
|
||||||
plt.savefig("docs/data/graph_" + operation + ".png")
|
|
||||||
plt.close()
|
|
||||||
|
|
||||||
print("Graphs saved to docs/data/")
|
|
||||||
|
|
@ -1,211 +0,0 @@
|
||||||
def ll_insert(head, name, phone):
|
|
||||||
new_node = {
|
|
||||||
'name': name,
|
|
||||||
'phone': phone,
|
|
||||||
'next': None
|
|
||||||
}
|
|
||||||
|
|
||||||
if head is None:
|
|
||||||
return new_node
|
|
||||||
|
|
||||||
current = head
|
|
||||||
|
|
||||||
while current['next'] is not None:
|
|
||||||
if current['name'] == name:
|
|
||||||
current['phone'] = phone
|
|
||||||
return head
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
if current['name'] == name:
|
|
||||||
current['phone'] = phone
|
|
||||||
else:
|
|
||||||
current['next'] = new_node
|
|
||||||
|
|
||||||
return head
|
|
||||||
|
|
||||||
def ll_find(head, name):
|
|
||||||
current = head
|
|
||||||
|
|
||||||
while current is not None:
|
|
||||||
if current['name'] == name:
|
|
||||||
return current['phone']
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
return None
|
|
||||||
|
|
||||||
def ll_delete(head, name):
|
|
||||||
if head is None:
|
|
||||||
return None
|
|
||||||
|
|
||||||
if head['name'] == name:
|
|
||||||
return head['next']
|
|
||||||
|
|
||||||
current = head
|
|
||||||
|
|
||||||
while current['next'] is not None:
|
|
||||||
if current['next']['name'] == name:
|
|
||||||
current['next'] = current['next']['next']
|
|
||||||
return head
|
|
||||||
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
return head
|
|
||||||
|
|
||||||
def ll_list_all(head):
|
|
||||||
records = []
|
|
||||||
current = head
|
|
||||||
|
|
||||||
while current is not None:
|
|
||||||
records.append((current['name'], current['phone']))
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
records.sort(key=lambda x: x[0])
|
|
||||||
return records
|
|
||||||
|
|
||||||
def hash_function(name, table_size):
|
|
||||||
total = 0
|
|
||||||
|
|
||||||
for ch in name:
|
|
||||||
total = (total * 31 + ord(ch)) % table_size
|
|
||||||
|
|
||||||
return total
|
|
||||||
|
|
||||||
def ht_create(size=1000):
|
|
||||||
return [None] * size
|
|
||||||
|
|
||||||
def ht_insert(buckets, name, phone):
|
|
||||||
index = hash_function(name, len(buckets))
|
|
||||||
buckets[index] = ll_insert(buckets[index], name, phone)
|
|
||||||
return buckets
|
|
||||||
|
|
||||||
def ht_find(buckets, name):
|
|
||||||
index = hash_function(name, len(buckets))
|
|
||||||
return ll_find(buckets[index], name)
|
|
||||||
|
|
||||||
def ht_delete(buckets, name):
|
|
||||||
index = hash_function(name, len(buckets))
|
|
||||||
buckets[index] = ll_delete(buckets[index], name)
|
|
||||||
return buckets
|
|
||||||
|
|
||||||
def ht_list_all(buckets):
|
|
||||||
records = []
|
|
||||||
|
|
||||||
for bucket in buckets:
|
|
||||||
current = bucket
|
|
||||||
|
|
||||||
while current is not None:
|
|
||||||
records.append((current['name'], current['phone']))
|
|
||||||
current = current['next']
|
|
||||||
|
|
||||||
records.sort(key=lambda x: x[0])
|
|
||||||
return records
|
|
||||||
|
|
||||||
def bst_insert(root, name, phone):
|
|
||||||
new_node = {
|
|
||||||
'name': name,
|
|
||||||
'phone': phone,
|
|
||||||
'left': None,
|
|
||||||
'right': None
|
|
||||||
}
|
|
||||||
|
|
||||||
if root is None:
|
|
||||||
return new_node
|
|
||||||
|
|
||||||
current = root
|
|
||||||
|
|
||||||
while True:
|
|
||||||
if name < current['name']:
|
|
||||||
if current['left'] is None:
|
|
||||||
current['left'] = new_node
|
|
||||||
break
|
|
||||||
current = current['left']
|
|
||||||
|
|
||||||
elif name > current['name']:
|
|
||||||
if current['right'] is None:
|
|
||||||
current['right'] = new_node
|
|
||||||
break
|
|
||||||
current = current['right']
|
|
||||||
|
|
||||||
else:
|
|
||||||
current['phone'] = phone
|
|
||||||
break
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
def bst_find(root, name):
|
|
||||||
current = root
|
|
||||||
|
|
||||||
while current is not None:
|
|
||||||
if name == current['name']:
|
|
||||||
return current['phone']
|
|
||||||
|
|
||||||
if name < current['name']:
|
|
||||||
current = current['left']
|
|
||||||
else:
|
|
||||||
current = current['right']
|
|
||||||
|
|
||||||
return None
|
|
||||||
|
|
||||||
def bst_delete(root, name):
|
|
||||||
parent = None
|
|
||||||
current = root
|
|
||||||
|
|
||||||
while current is not None and current['name'] != name:
|
|
||||||
parent = current
|
|
||||||
|
|
||||||
if name < current['name']:
|
|
||||||
current = current['left']
|
|
||||||
else:
|
|
||||||
current = current['right']
|
|
||||||
|
|
||||||
if current is None:
|
|
||||||
return root
|
|
||||||
|
|
||||||
if current['left'] is None:
|
|
||||||
child = current['right']
|
|
||||||
|
|
||||||
elif current['right'] is None:
|
|
||||||
child = current['left']
|
|
||||||
|
|
||||||
else:
|
|
||||||
successor_parent = current
|
|
||||||
successor = current['right']
|
|
||||||
|
|
||||||
while successor['left'] is not None:
|
|
||||||
successor_parent = successor
|
|
||||||
successor = successor['left']
|
|
||||||
|
|
||||||
current['name'] = successor['name']
|
|
||||||
current['phone'] = successor['phone']
|
|
||||||
|
|
||||||
if successor_parent['left'] == successor:
|
|
||||||
successor_parent['left'] = successor['right']
|
|
||||||
else:
|
|
||||||
successor_parent['right'] = successor['right']
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
if parent is None:
|
|
||||||
return child
|
|
||||||
|
|
||||||
if parent['left'] == current:
|
|
||||||
parent['left'] = child
|
|
||||||
else:
|
|
||||||
parent['right'] = child
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
def bst_list_all(root):
|
|
||||||
records = []
|
|
||||||
|
|
||||||
def inorder(node):
|
|
||||||
if node is None:
|
|
||||||
return
|
|
||||||
|
|
||||||
inorder(node['left'])
|
|
||||||
records.append((node['name'], node['phone']))
|
|
||||||
inorder(node['right'])
|
|
||||||
|
|
||||||
inorder(root)
|
|
||||||
|
|
||||||
return records
|
|
||||||
Binary file not shown.
|
Before Width: | Height: | Size: 15 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 12 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 15 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB |
|
|
@ -1,16 +0,0 @@
|
||||||
maze,strategy,time_ms,visited_cells,path_length
|
|
||||||
simple.txt,BFS,0.01464000015403144,11.0,6.0
|
|
||||||
simple.txt,DFS,0.010180000390391797,9.0,8.0
|
|
||||||
simple.txt,A*,0.017740000475896522,9.0,6.0
|
|
||||||
dead.txt,BFS,0.3642999996372964,307.0,35.0
|
|
||||||
dead.txt,DFS,0.23493999906349927,279.0,151.0
|
|
||||||
dead.txt,A*,0.38374000068870373,235.0,35.0
|
|
||||||
large.txt,BFS,23.894459999428364,6812.0,2329.0
|
|
||||||
large.txt,DFS,84.77875999960816,6796.0,4537.0
|
|
||||||
large.txt,A*,28.69542000044021,6791.0,2329.0
|
|
||||||
empty.txt,BFS,1.2770400004228577,1176.0,48.0
|
|
||||||
empty.txt,DFS,7.602279999264283,2304.0,1176.0
|
|
||||||
empty.txt,A*,0.10093999881064519,48.0,48.0
|
|
||||||
noexit.txt,BFS,0.003699999797390774,1.0,0.0
|
|
||||||
noexit.txt,DFS,0.0032000003557186574,1.0,0.0
|
|
||||||
noexit.txt,A*,0.004120000085094944,1.0,0.0
|
|
||||||
|
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB |
|
|
@ -1,212 +0,0 @@
|
||||||
Лабораторная работа 2
|
|
||||||
|
|
||||||
Поиск выхода из лабиринта
|
|
||||||
|
|
||||||
Цель работы
|
|
||||||
-----------
|
|
||||||
Цель работы состоит в реализации программы для поиска выхода из лабиринта с использованием объектно ориентированного подхода и паттернов проектирования
|
|
||||||
|
|
||||||
В программе реализована загрузка лабиринта из файла несколько алгоритмов поиска и сравнение их работы
|
|
||||||
|
|
||||||
Структура программы
|
|
||||||
-------------------
|
|
||||||
В программе используются классы Cell для отдельной клетки лабиринта и Maze для самого лабиринта
|
|
||||||
|
|
||||||
Для загрузки используется MazeBuilder и его реализация TextFileMazeBuilder
|
|
||||||
|
|
||||||
Для поиска пути используется общий класс PathFindingStrategy и три алгоритма BFSStrategy DFSStrategy и AStarStrategy
|
|
||||||
|
|
||||||
За хранение результатов отвечает SearchStats а запуск поиска выполняет MazeSolver
|
|
||||||
|
|
||||||
Для вывода информации используются Observer и ConsoleView
|
|
||||||
|
|
||||||
Использованные паттерны
|
|
||||||
-----------------------
|
|
||||||
В работе использованы три паттерна Builder Strategy и Observer
|
|
||||||
|
|
||||||
Builder используется для загрузки лабиринта из текстового файла
|
|
||||||
|
|
||||||
TextFileMazeBuilder читает файл и создаёт объект Maze
|
|
||||||
|
|
||||||
В файле символ # обозначает стену пробел обозначает свободную клетку S является началом а E выходом
|
|
||||||
|
|
||||||
Использование Builder позволяет отдельно реализовать загрузку лабиринта и сам класс лабиринта
|
|
||||||
|
|
||||||
Strategy используется для выбора алгоритма поиска
|
|
||||||
|
|
||||||
В программе реализованы BFS DFS и A*
|
|
||||||
|
|
||||||
Все алгоритмы имеют общий интерфейс PathFindingStrategy поэтому в MazeSolver можно менять алгоритм без изменения самого решателя
|
|
||||||
|
|
||||||
Observer используется для вывода информации о поиске
|
|
||||||
|
|
||||||
MazeSolver отправляет события а ConsoleView получает их и выводит информацию в консоль
|
|
||||||
|
|
||||||
Таким образом вывод отделён от основной логики поиска
|
|
||||||
|
|
||||||
Алгоритмы поиска
|
|
||||||
----------------
|
|
||||||
BFS использует очередь и при обычных условиях находит кратчайший путь в лабиринте без весов
|
|
||||||
|
|
||||||
DFS использует стек и может найти путь быстрее но найденный путь не обязательно будет кратчайшим
|
|
||||||
|
|
||||||
A* использует очередь с приоритетом и манхэттенскую эвристику поэтому старается в первую очередь проверять клетки которые находятся ближе к выходу
|
|
||||||
|
|
||||||
Схема классов
|
|
||||||
-------------
|
|
||||||
classDiagram
|
|
||||||
|
|
||||||
class Cell {
|
|
||||||
x
|
|
||||||
y
|
|
||||||
is_wall
|
|
||||||
is_start
|
|
||||||
is_exit
|
|
||||||
is_passable()
|
|
||||||
}
|
|
||||||
|
|
||||||
class Maze {
|
|
||||||
width
|
|
||||||
height
|
|
||||||
cells
|
|
||||||
start
|
|
||||||
exit
|
|
||||||
get_cell()
|
|
||||||
get_neighbors()
|
|
||||||
}
|
|
||||||
|
|
||||||
class MazeBuilder {
|
|
||||||
build_from_file()
|
|
||||||
}
|
|
||||||
|
|
||||||
class TextFileMazeBuilder {
|
|
||||||
build_from_file()
|
|
||||||
}
|
|
||||||
|
|
||||||
class PathFindingStrategy {
|
|
||||||
find_path()
|
|
||||||
}
|
|
||||||
|
|
||||||
class BFSStrategy {
|
|
||||||
find_path()
|
|
||||||
}
|
|
||||||
|
|
||||||
class DFSStrategy {
|
|
||||||
find_path()
|
|
||||||
}
|
|
||||||
|
|
||||||
class AStarStrategy {
|
|
||||||
find_path()
|
|
||||||
}
|
|
||||||
|
|
||||||
class SearchStats {
|
|
||||||
path
|
|
||||||
time_ms
|
|
||||||
visited_count
|
|
||||||
path_length
|
|
||||||
}
|
|
||||||
|
|
||||||
class MazeSolver {
|
|
||||||
maze
|
|
||||||
strategy
|
|
||||||
set_strategy()
|
|
||||||
solve()
|
|
||||||
}
|
|
||||||
|
|
||||||
class Observer {
|
|
||||||
update()
|
|
||||||
}
|
|
||||||
|
|
||||||
class ConsoleView {
|
|
||||||
update()
|
|
||||||
}
|
|
||||||
|
|
||||||
MazeBuilder <|-- TextFileMazeBuilder
|
|
||||||
PathFindingStrategy <|-- BFSStrategy
|
|
||||||
PathFindingStrategy <|-- DFSStrategy
|
|
||||||
PathFindingStrategy <|-- AStarStrategy
|
|
||||||
Observer <|-- ConsoleView
|
|
||||||
MazeSolver --> Maze
|
|
||||||
MazeSolver --> PathFindingStrategy
|
|
||||||
MazeSolver --> Observer
|
|
||||||
Maze --> Cell
|
|
||||||
Тестирование
|
|
||||||
------------
|
|
||||||
Для проверки использовалось пять разных лабиринтов
|
|
||||||
|
|
||||||
simple.txt представляет простой лабиринт dead.txt содержит тупики large.txt является большим запутанным лабиринтом empty.txt не содержит стен а в noexit.txt выход недостижим
|
|
||||||
|
|
||||||
Каждый алгоритм запускался пять раз
|
|
||||||
|
|
||||||
Во время эксперимента измерялось время поиска количество посещённых клеток и длина найденного пути
|
|
||||||
|
|
||||||
Результаты сохранялись в файл results.csv
|
|
||||||
|
|
||||||
Результаты
|
|
||||||
----------
|
|
||||||
simple.txt
|
|
||||||
Алгоритм Время мс Посещено Путь
|
|
||||||
BFS 0.01464 11 6
|
|
||||||
DFS 0.01018 9 8
|
|
||||||
A* 0.01774 9 6
|
|
||||||
|
|
||||||
Все алгоритмы работают быстро
|
|
||||||
|
|
||||||
BFS и A* нашли более короткий путь чем DFS
|
|
||||||
|
|
||||||
dead.txt
|
|
||||||
Алгоритм Время мс Посещено Путь
|
|
||||||
BFS 0.36430 307 35
|
|
||||||
DFS 0.23494 279 151
|
|
||||||
A* 0.38374 235 35
|
|
||||||
|
|
||||||
DFS работал немного быстрее но нашёл более длинный путь
|
|
||||||
|
|
||||||
BFS и A* нашли короткий путь
|
|
||||||
|
|
||||||
large.txt
|
|
||||||
Алгоритм Время мс Посещено Путь
|
|
||||||
BFS 23.89446 6812 2329
|
|
||||||
DFS 84.77876 6796 4537
|
|
||||||
A* 28.69542 6791 2329
|
|
||||||
|
|
||||||
На большом лабиринте DFS показал худшее время и самый длинный путь
|
|
||||||
|
|
||||||
BFS и A* нашли одинаковый путь
|
|
||||||
|
|
||||||
empty.txt
|
|
||||||
Алгоритм Время мс Посещено Путь
|
|
||||||
BFS 1.277
|
|
||||||
|
|
||||||
|
|
||||||
04 1176 48
|
|
||||||
DFS 7.60228 2304 1176
|
|
||||||
A* 0.10094 48 48
|
|
||||||
|
|
||||||
В лабиринте без стен лучше всего показал себя A*
|
|
||||||
|
|
||||||
Он посетил меньше всего клеток и работал быстрее
|
|
||||||
|
|
||||||
noexit.txt
|
|
||||||
Алгоритм Время мс Посещено Путь
|
|
||||||
BFS 0.00370 1 0
|
|
||||||
DFS 0.00320 1 0
|
|
||||||
A* 0.00412 1 0
|
|
||||||
|
|
||||||
В этом лабиринте выход недостижим поэтому все алгоритмы быстро закончили поиск
|
|
||||||
|
|
||||||
Графики
|
|
||||||
-------
|
|
||||||
Для сравнения времени работы были построены графики для каждого лабиринта
|
|
||||||
|
|
||||||
Графики находятся в папке docs/data
|
|
||||||
|
|
||||||
simple_time.png dead_time.png large_time.png empty_time.png и noexit_time.png
|
|
||||||
|
|
||||||
Вывод
|
|
||||||
-----
|
|
||||||
В работе была создана программа для поиска выхода из лабиринта
|
|
||||||
|
|
||||||
Были реализованы BFS DFS и A* а также использованы паттерны Builder Strategy и Observer
|
|
||||||
|
|
||||||
По результатам эксперимента BFS хорошо подходит для поиска кратчайшего пути DFS может найти путь быстрее но он не всегда получается коротким A* хорошо показывает себя на больших и открытых лабиринтах
|
|
||||||
|
|
@ -1,93 +0,0 @@
|
||||||
import csv
|
|
||||||
import os
|
|
||||||
|
|
||||||
from maze_solver import (
|
|
||||||
TextFileMazeBuilder,
|
|
||||||
MazeSolver,
|
|
||||||
BFSStrategy,
|
|
||||||
DFSStrategy,
|
|
||||||
AStarStrategy
|
|
||||||
)
|
|
||||||
|
|
||||||
REPEATS = 5
|
|
||||||
|
|
||||||
MAZES = [
|
|
||||||
"simple.txt",
|
|
||||||
"dead.txt",
|
|
||||||
"large.txt",
|
|
||||||
"empty.txt",
|
|
||||||
"noexit.txt"
|
|
||||||
]
|
|
||||||
|
|
||||||
STRATEGIES = [
|
|
||||||
("BFS", BFSStrategy()),
|
|
||||||
("DFS", DFSStrategy()),
|
|
||||||
("A*", AStarStrategy())
|
|
||||||
]
|
|
||||||
|
|
||||||
def average(values):
|
|
||||||
return sum(values) / len(values)
|
|
||||||
|
|
||||||
def run():
|
|
||||||
builder = TextFileMazeBuilder()
|
|
||||||
results = []
|
|
||||||
|
|
||||||
for maze_name in MAZES:
|
|
||||||
filename = os.path.join("lab2", "mazes", maze_name)
|
|
||||||
|
|
||||||
print("Maze:", maze_name)
|
|
||||||
|
|
||||||
for strategy_name, strategy in STRATEGIES:
|
|
||||||
times = []
|
|
||||||
visited = []
|
|
||||||
path_lengths = []
|
|
||||||
|
|
||||||
for _ in range(REPEATS):
|
|
||||||
maze = builder.build_from_file(filename)
|
|
||||||
|
|
||||||
solver = MazeSolver(maze, strategy)
|
|
||||||
stats = solver.solve()
|
|
||||||
|
|
||||||
times.append(stats.time_ms)
|
|
||||||
visited.append(stats.visited_count)
|
|
||||||
path_lengths.append(stats.path_length)
|
|
||||||
|
|
||||||
results.append([
|
|
||||||
maze_name,
|
|
||||||
strategy_name,
|
|
||||||
average(times),
|
|
||||||
average(visited),
|
|
||||||
average(path_lengths)
|
|
||||||
])
|
|
||||||
|
|
||||||
print(
|
|
||||||
strategy_name,
|
|
||||||
"time =", average(times),
|
|
||||||
"visited =", average(visited),
|
|
||||||
"path =", average(path_lengths)
|
|
||||||
)
|
|
||||||
|
|
||||||
os.makedirs("lab2/docs/data", exist_ok=True)
|
|
||||||
|
|
||||||
with open(
|
|
||||||
"lab2/docs/data/results.csv",
|
|
||||||
"w",
|
|
||||||
newline="",
|
|
||||||
encoding="utf-8"
|
|
||||||
) as file:
|
|
||||||
writer = csv.writer(file)
|
|
||||||
|
|
||||||
writer.writerow([
|
|
||||||
"maze",
|
|
||||||
"strategy",
|
|
||||||
"time_ms",
|
|
||||||
"visited_cells",
|
|
||||||
"path_length"
|
|
||||||
])
|
|
||||||
|
|
||||||
writer.writerows(results)
|
|
||||||
|
|
||||||
print("Results saved to lab2/docs/data/results.csv")
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
run()
|
|
||||||
|
|
@ -1,23 +0,0 @@
|
||||||
import csv
|
|
||||||
import matplotlib.pyplot as plt
|
|
||||||
|
|
||||||
with open("lab2/docs/data/results.csv", encoding="utf-8") as file:
|
|
||||||
rows = list(csv.DictReader(file))
|
|
||||||
|
|
||||||
mazes = ["simple.txt", "dead.txt", "large.txt", "empty.txt", "noexit.txt"]
|
|
||||||
strategies = ["BFS", "DFS", "A*"]
|
|
||||||
|
|
||||||
for maze in mazes:
|
|
||||||
values = []
|
|
||||||
|
|
||||||
for strategy in strategies:
|
|
||||||
for row in rows:
|
|
||||||
if row["maze"] == maze and row["strategy"] == strategy:
|
|
||||||
values.append(float(row["time_ms"]))
|
|
||||||
|
|
||||||
plt.bar(strategies, values)
|
|
||||||
plt.title("Время поиска: " + maze)
|
|
||||||
plt.xlabel("Стратегия")
|
|
||||||
plt.ylabel("Время, мс")
|
|
||||||
plt.savefig("lab2/docs/data/" + maze.replace(".txt", "_time.png"))
|
|
||||||
plt.close()
|
|
||||||
|
|
@ -1,26 +0,0 @@
|
||||||
lines = []
|
|
||||||
|
|
||||||
for y in range(100):
|
|
||||||
row = [" "] * 100
|
|
||||||
|
|
||||||
if y == 0 or y == 99:
|
|
||||||
row = ["#"] * 100
|
|
||||||
else:
|
|
||||||
row[0] = "#"
|
|
||||||
row[99] = "#"
|
|
||||||
|
|
||||||
lines.append(row)
|
|
||||||
|
|
||||||
lines[1][1] = "S"
|
|
||||||
lines[98][98] = "E"
|
|
||||||
|
|
||||||
for x in range(4, 96, 4):
|
|
||||||
gap = 1 if (x // 4) % 2 == 0 else 98
|
|
||||||
|
|
||||||
for y in range(1, 99):
|
|
||||||
if y != gap:
|
|
||||||
lines[y][x] = "#"
|
|
||||||
|
|
||||||
with open("lab2/mazes/large.txt", "w", encoding="utf-8") as file:
|
|
||||||
for row in lines:
|
|
||||||
file.write("".join(row) + "\n")
|
|
||||||
|
|
@ -1,284 +0,0 @@
|
||||||
from abc import ABC, abstractmethod
|
|
||||||
from collections import deque
|
|
||||||
import heapq
|
|
||||||
import time
|
|
||||||
|
|
||||||
class Cell:
|
|
||||||
def __init__(self, x, y):
|
|
||||||
self.x = x
|
|
||||||
self.y = y
|
|
||||||
self.is_wall = False
|
|
||||||
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.cells = []
|
|
||||||
self.start = None
|
|
||||||
self.exit = None
|
|
||||||
|
|
||||||
for y in range(height):
|
|
||||||
row = []
|
|
||||||
|
|
||||||
for x in range(width):
|
|
||||||
row.append(Cell(x, y))
|
|
||||||
|
|
||||||
self.cells.append(row)
|
|
||||||
|
|
||||||
def get_cell(self, x, y):
|
|
||||||
if 0 <= x < self.width and 0 <= y < self.height:
|
|
||||||
return self.cells[y][x]
|
|
||||||
|
|
||||||
return None
|
|
||||||
|
|
||||||
def get_neighbors(self, cell):
|
|
||||||
neighbors = []
|
|
||||||
|
|
||||||
directions = [
|
|
||||||
(0, -1),
|
|
||||||
(0, 1),
|
|
||||||
(-1, 0),
|
|
||||||
(1, 0)
|
|
||||||
]
|
|
||||||
|
|
||||||
for dx, dy in directions:
|
|
||||||
neighbor = self.get_cell(
|
|
||||||
cell.x + dx,
|
|
||||||
cell.y + dy
|
|
||||||
)
|
|
||||||
|
|
||||||
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", encoding="utf-8") as file:
|
|
||||||
lines = [line.rstrip("\n") for line in file]
|
|
||||||
|
|
||||||
if not lines:
|
|
||||||
raise ValueError("Файл лабиринта пустой")
|
|
||||||
|
|
||||||
width = len(lines[0])
|
|
||||||
|
|
||||||
for line in lines:
|
|
||||||
if len(line) != width:
|
|
||||||
raise ValueError("Строки лабиринта имеют разную длину")
|
|
||||||
|
|
||||||
maze = Maze(width, len(lines))
|
|
||||||
|
|
||||||
for y, line in enumerate(lines):
|
|
||||||
for x, symbol in enumerate(line):
|
|
||||||
cell = maze.get_cell(x, y)
|
|
||||||
|
|
||||||
if symbol == "#":
|
|
||||||
cell.is_wall = True
|
|
||||||
|
|
||||||
elif symbol == "S":
|
|
||||||
if maze.start is not None:
|
|
||||||
raise ValueError("В лабиринте несколько стартов")
|
|
||||||
|
|
||||||
maze.start = cell
|
|
||||||
cell.is_start = True
|
|
||||||
|
|
||||||
elif symbol == "E":
|
|
||||||
if maze.exit is not None:
|
|
||||||
raise ValueError("В лабиринте несколько выходов")
|
|
||||||
|
|
||||||
maze.exit = cell
|
|
||||||
cell.is_exit = True
|
|
||||||
|
|
||||||
elif symbol == " ":
|
|
||||||
pass
|
|
||||||
|
|
||||||
else:
|
|
||||||
raise ValueError("Неизвестный символ в лабиринте")
|
|
||||||
|
|
||||||
if maze.start is None:
|
|
||||||
raise ValueError("В лабиринте нет старта")
|
|
||||||
|
|
||||||
if maze.exit is None:
|
|
||||||
raise ValueError("В лабиринте нет выхода")
|
|
||||||
|
|
||||||
return maze
|
|
||||||
|
|
||||||
class PathFindingStrategy(ABC):
|
|
||||||
@abstractmethod
|
|
||||||
def find_path(self, maze, start, exit):
|
|
||||||
pass
|
|
||||||
|
|
||||||
class BFSStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze, start, exit):
|
|
||||||
if start is None or exit is None:
|
|
||||||
return [], 0
|
|
||||||
|
|
||||||
queue = deque([(start, [start])])
|
|
||||||
visited = {start}
|
|
||||||
|
|
||||||
while queue:
|
|
||||||
current, path = queue.popleft()
|
|
||||||
|
|
||||||
if current == exit:
|
|
||||||
return path, len(visited)
|
|
||||||
|
|
||||||
for neighbor in maze.get_neighbors(current):
|
|
||||||
if neighbor not in visited:
|
|
||||||
visited.add(neighbor)
|
|
||||||
queue.append((neighbor, path + [neighbor]))
|
|
||||||
|
|
||||||
return [], len(visited)
|
|
||||||
|
|
||||||
class DFSStrategy(PathFindingStrategy):
|
|
||||||
def find_path(self, maze, start, exit):
|
|
||||||
if start is None or exit is None:
|
|
||||||
return [], 0
|
|
||||||
|
|
||||||
stack = [(start, [start])]
|
|
||||||
visited = {start}
|
|
||||||
|
|
||||||
while stack:
|
|
||||||
current, path = stack.pop()
|
|
||||||
|
|
||||||
if current == exit:
|
|
||||||
return path, len(visited)
|
|
||||||
|
|
||||||
for neighbor in maze.get_neighbors(current):
|
|
||||||
if neighbor not in visited:
|
|
||||||
visited.add(neighbor)
|
|
||||||
stack.append((neighbor, path + [neighbor]))
|
|
||||||
|
|
||||||
return [], len(visited)
|
|
||||||
|
|
||||||
class AStarStrategy(PathFindingStrategy):
|
|
||||||
def heuristic(self, a, b):
|
|
||||||
return abs(a.x - b.x) + abs(a.y - b.y)
|
|
||||||
|
|
||||||
def find_path(self, maze, start, exit):
|
|
||||||
if start is None or exit is None:
|
|
||||||
return [], 0
|
|
||||||
|
|
||||||
heap = []
|
|
||||||
counter = 0
|
|
||||||
|
|
||||||
heapq.heappush(
|
|
||||||
heap,
|
|
||||||
(self.heuristic(start, exit), counter, start, [start])
|
|
||||||
)
|
|
||||||
|
|
||||||
g_score = {start: 0}
|
|
||||||
visited = set()
|
|
||||||
|
|
||||||
while heap:
|
|
||||||
_, _, current, path = heapq.heappop(heap)
|
|
||||||
|
|
||||||
if current in visited:
|
|
||||||
continue
|
|
||||||
|
|
||||||
visited.add(current)
|
|
||||||
|
|
||||||
if current == exit:
|
|
||||||
return path, len(visited)
|
|
||||||
|
|
||||||
for neighbor in maze.get_neighbors(current):
|
|
||||||
new_cost = g_score[current] + 1
|
|
||||||
|
|
||||||
if neighbor not in g_score or new_cost < g_score[neighbor]:
|
|
||||||
g_score[neighbor] = new_cost
|
|
||||||
counter += 1
|
|
||||||
|
|
||||||
priority = new_cost + self.heuristic(
|
|
||||||
neighbor,
|
|
||||||
exit
|
|
||||||
)
|
|
||||||
|
|
||||||
heapq.heappush(
|
|
||||||
heap,
|
|
||||||
(
|
|
||||||
priority,
|
|
||||||
counter,
|
|
||||||
neighbor,
|
|
||||||
path + [neighbor]
|
|
||||||
)
|
|
||||||
)
|
|
||||||
|
|
||||||
return [], len(visited)
|
|
||||||
|
|
||||||
class SearchStats:
|
|
||||||
def __init__(self, path, time_ms, visited_count):
|
|
||||||
self.path = path
|
|
||||||
self.time_ms = time_ms
|
|
||||||
self.visited_count = visited_count
|
|
||||||
self.path_length = len(path) if path else 0
|
|
||||||
|
|
||||||
class MazeSolver:
|
|
||||||
def __init__(self, maze, strategy=None):
|
|
||||||
self.maze = maze
|
|
||||||
self.strategy = strategy
|
|
||||||
self.observers = []
|
|
||||||
|
|
||||||
def attach(self, observer):
|
|
||||||
self.observers.append(observer)
|
|
||||||
|
|
||||||
def detach(self, observer):
|
|
||||||
self.observers.remove(observer)
|
|
||||||
|
|
||||||
def notify(self, event, data=None):
|
|
||||||
for observer in self.observers:
|
|
||||||
observer.update(event, data)
|
|
||||||
|
|
||||||
def set_strategy(self, strategy):
|
|
||||||
self.strategy = strategy
|
|
||||||
|
|
||||||
def solve(self):
|
|
||||||
if self.strategy is None:
|
|
||||||
raise ValueError("Стратегия не установлена")
|
|
||||||
|
|
||||||
self.notify("search_started")
|
|
||||||
|
|
||||||
start_time = time.perf_counter()
|
|
||||||
|
|
||||||
path, visited_count = self.strategy.find_path(
|
|
||||||
self.maze,
|
|
||||||
self.maze.start,
|
|
||||||
self.maze.exit
|
|
||||||
)
|
|
||||||
|
|
||||||
end_time = time.perf_counter()
|
|
||||||
|
|
||||||
time_ms = (end_time - start_time) * 1000
|
|
||||||
|
|
||||||
self.notify("search_finished", time_ms)
|
|
||||||
self.notify("path_found", path)
|
|
||||||
|
|
||||||
return SearchStats(
|
|
||||||
path,
|
|
||||||
time_ms,
|
|
||||||
visited_count
|
|
||||||
)
|
|
||||||
|
|
||||||
class Observer(ABC):
|
|
||||||
@abstractmethod
|
|
||||||
def update(self, event, data=None):
|
|
||||||
pass
|
|
||||||
|
|
||||||
class ConsoleView(Observer):
|
|
||||||
def update(self, event, data=None):
|
|
||||||
if event == "search_started":
|
|
||||||
print("Поиск начат")
|
|
||||||
|
|
||||||
elif event == "search_finished":
|
|
||||||
print(f"Поиск завершен за {data:.3f} мс")
|
|
||||||
|
|
||||||
elif event == "path_found":
|
|
||||||
print(f"Длина пути: {len(data)}")
|
|
||||||
|
|
@ -1,20 +0,0 @@
|
||||||
####################
|
|
||||||
#S #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# ######### #
|
|
||||||
# # #
|
|
||||||
# # #
|
|
||||||
# # #
|
|
||||||
# # #
|
|
||||||
# # #
|
|
||||||
# # #
|
|
||||||
# # #
|
|
||||||
# # #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# E#
|
|
||||||
####################
|
|
||||||
|
|
@ -1,50 +0,0 @@
|
||||||
##################################################
|
|
||||||
#S #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
# #
|
|
||||||
#E #
|
|
||||||
##################################################
|
|
||||||
|
|
@ -1,100 +0,0 @@
|
||||||
####################################################################################################
|
|
||||||
#S # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # # # # # # # # # # # # # #
|
|
||||||
# # # # # # # # # # # # E#
|
|
||||||
####################################################################################################
|
|
||||||
|
|
@ -1,10 +0,0 @@
|
||||||
##########
|
|
||||||
#S########
|
|
||||||
##########
|
|
||||||
##########
|
|
||||||
##########
|
|
||||||
##########
|
|
||||||
##########
|
|
||||||
##########
|
|
||||||
########E#
|
|
||||||
##########
|
|
||||||
|
|
@ -1,5 +0,0 @@
|
||||||
#######
|
|
||||||
#S #
|
|
||||||
# ### #
|
|
||||||
# E #
|
|
||||||
#######
|
|
||||||
|
|
@ -1,252 +0,0 @@
|
||||||
from MP_records import records
|
|
||||||
import random as rd
|
|
||||||
import time
|
|
||||||
import csv
|
|
||||||
import codecs
|
|
||||||
import sys
|
|
||||||
|
|
||||||
sys.setrecursionlimit(15000)
|
|
||||||
|
|
||||||
|
|
||||||
# ---------- Binary Search Tree ----------
|
|
||||||
# Узел:
|
|
||||||
# {
|
|
||||||
# "name": name,
|
|
||||||
# "phone": phone,
|
|
||||||
# "left": None,
|
|
||||||
# "right": None
|
|
||||||
# }
|
|
||||||
|
|
||||||
|
|
||||||
def bst_insert(root, name, phone):
|
|
||||||
"""
|
|
||||||
Вставляет новую запись или обновляет телефон по имени.
|
|
||||||
Возвращает корень дерева.
|
|
||||||
"""
|
|
||||||
if root is None:
|
|
||||||
return {
|
|
||||||
"name": name,
|
|
||||||
"phone": phone,
|
|
||||||
"left": None,
|
|
||||||
"right": None
|
|
||||||
}
|
|
||||||
|
|
||||||
if name == root["name"]:
|
|
||||||
root["phone"] = phone
|
|
||||||
|
|
||||||
elif name < root["name"]:
|
|
||||||
root["left"] = bst_insert(root["left"], name, phone)
|
|
||||||
|
|
||||||
else:
|
|
||||||
root["right"] = bst_insert(root["right"], name, phone)
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
|
|
||||||
def bst_find(root, name):
|
|
||||||
"""
|
|
||||||
Поиск телефона по имени.
|
|
||||||
"""
|
|
||||||
if root is None:
|
|
||||||
return None
|
|
||||||
|
|
||||||
if name == root["name"]:
|
|
||||||
return root["phone"]
|
|
||||||
|
|
||||||
if name < root["name"]:
|
|
||||||
return bst_find(root["left"], name)
|
|
||||||
|
|
||||||
return bst_find(root["right"], name)
|
|
||||||
|
|
||||||
|
|
||||||
def bst_find_min(node):
|
|
||||||
"""
|
|
||||||
Возвращает узел с минимальным именем.
|
|
||||||
"""
|
|
||||||
current = node
|
|
||||||
|
|
||||||
while current["left"] is not None:
|
|
||||||
current = current["left"]
|
|
||||||
|
|
||||||
return current
|
|
||||||
|
|
||||||
|
|
||||||
def bst_delete(root, name):
|
|
||||||
"""
|
|
||||||
Удаляет запись по имени.
|
|
||||||
Возвращает новый корень дерева.
|
|
||||||
"""
|
|
||||||
if root is None:
|
|
||||||
return None
|
|
||||||
|
|
||||||
if name < root["name"]:
|
|
||||||
root["left"] = bst_delete(root["left"], name)
|
|
||||||
|
|
||||||
elif name > root["name"]:
|
|
||||||
root["right"] = bst_delete(root["right"], name)
|
|
||||||
|
|
||||||
else:
|
|
||||||
# Узел без левого потомка
|
|
||||||
if root["left"] is None:
|
|
||||||
return root["right"]
|
|
||||||
|
|
||||||
# Узел без правого потомка
|
|
||||||
if root["right"] is None:
|
|
||||||
return root["left"]
|
|
||||||
|
|
||||||
# Узел с двумя потомками
|
|
||||||
successor = bst_find_min(root["right"])
|
|
||||||
|
|
||||||
root["name"] = successor["name"]
|
|
||||||
root["phone"] = successor["phone"]
|
|
||||||
|
|
||||||
root["right"] = bst_delete(root["right"], successor["name"])
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
|
|
||||||
def bst_inorder(root, result):
|
|
||||||
"""
|
|
||||||
Центрированный обход дерева.
|
|
||||||
"""
|
|
||||||
if root is None:
|
|
||||||
return
|
|
||||||
|
|
||||||
bst_inorder(root["left"], result)
|
|
||||||
|
|
||||||
result.append((root["name"], root["phone"]))
|
|
||||||
|
|
||||||
bst_inorder(root["right"], result)
|
|
||||||
|
|
||||||
|
|
||||||
def bst_list_all(root):
|
|
||||||
"""
|
|
||||||
Возвращает список записей в отсортированном порядке.
|
|
||||||
"""
|
|
||||||
result = []
|
|
||||||
bst_inorder(root, result)
|
|
||||||
return result
|
|
||||||
|
|
||||||
|
|
||||||
# ---------- Benchmark helpers ----------
|
|
||||||
|
|
||||||
def build_bst(records_list):
|
|
||||||
root = None
|
|
||||||
|
|
||||||
for name, phone in records_list:
|
|
||||||
root = bst_insert(root, name, phone)
|
|
||||||
|
|
||||||
return root
|
|
||||||
|
|
||||||
|
|
||||||
def measure_bst(records_list, mode_name, repeats=5):
|
|
||||||
rows = []
|
|
||||||
|
|
||||||
insertion_times = []
|
|
||||||
finding_times = []
|
|
||||||
deletion_times = []
|
|
||||||
|
|
||||||
for run_number in range(1, repeats + 1):
|
|
||||||
data = records_list[:]
|
|
||||||
|
|
||||||
if mode_name == "случайный":
|
|
||||||
rd.shuffle(data)
|
|
||||||
|
|
||||||
# А. Вставка
|
|
||||||
root = None
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name, phone in data:
|
|
||||||
root = bst_insert(root, name, phone)
|
|
||||||
|
|
||||||
end = time.perf_counter()
|
|
||||||
|
|
||||||
insertion_time = end - start
|
|
||||||
insertion_times.append(insertion_time)
|
|
||||||
|
|
||||||
# Б. Поиск
|
|
||||||
existing_names = [name for name, phone in rd.sample(data, 100)]
|
|
||||||
missing_names = [f"None_{i}" for i in range(10)]
|
|
||||||
|
|
||||||
search_names = existing_names + missing_names
|
|
||||||
rd.shuffle(search_names)
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name in search_names:
|
|
||||||
bst_find(root, name)
|
|
||||||
|
|
||||||
end = time.perf_counter()
|
|
||||||
|
|
||||||
finding_time = end - start
|
|
||||||
finding_times.append(finding_time)
|
|
||||||
|
|
||||||
# В. Удаление
|
|
||||||
delete_names = rd.sample(existing_names, 50)
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name in delete_names:
|
|
||||||
root = bst_delete(root, name)
|
|
||||||
|
|
||||||
end = time.perf_counter()
|
|
||||||
|
|
||||||
deletion_time = end - start
|
|
||||||
deletion_times.append(deletion_time)
|
|
||||||
|
|
||||||
rows.append(["BinarySearchTree", mode_name, "вставка", run_number, insertion_time])
|
|
||||||
rows.append(["BinarySearchTree", mode_name, "поиск", run_number, finding_time])
|
|
||||||
rows.append(["BinarySearchTree", mode_name, "удаление", run_number, deletion_time])
|
|
||||||
|
|
||||||
rows.append(["BinarySearchTree", mode_name, "вставка", "среднее", sum(insertion_times) / repeats])
|
|
||||||
rows.append(["BinarySearchTree", mode_name, "поиск", "среднее", sum(finding_times) / repeats])
|
|
||||||
rows.append(["BinarySearchTree", mode_name, "удаление", "среднее", sum(deletion_times) / repeats])
|
|
||||||
|
|
||||||
return rows
|
|
||||||
|
|
||||||
|
|
||||||
def save_results(rows, filename="results.csv"):
|
|
||||||
with codecs.open(filename, "a+", "utf-16") as file:
|
|
||||||
writer = csv.writer(file)
|
|
||||||
writer.writerows(rows)
|
|
||||||
|
|
||||||
|
|
||||||
def run_shuffled(records_shuffled):
|
|
||||||
rows = measure_bst(records_shuffled, "случайный")
|
|
||||||
save_results(rows)
|
|
||||||
return rows
|
|
||||||
|
|
||||||
|
|
||||||
def run_sorted(records_sorted):
|
|
||||||
rows = measure_bst(records_sorted, "отсортированный")
|
|
||||||
save_results(rows)
|
|
||||||
return rows
|
|
||||||
|
|
||||||
|
|
||||||
# ---------- Manual tests ----------
|
|
||||||
|
|
||||||
def test():
|
|
||||||
root = None
|
|
||||||
|
|
||||||
root = bst_insert(root, "Ivan", "111")
|
|
||||||
root = bst_insert(root, "Anna", "222")
|
|
||||||
root = bst_insert(root, "Petr", "333")
|
|
||||||
root = bst_insert(root, "Maria", "444")
|
|
||||||
|
|
||||||
print(bst_find(root, "Anna")) # 222
|
|
||||||
print(bst_find(root, "Unknown")) # None
|
|
||||||
|
|
||||||
root = bst_insert(root, "Anna", "999")
|
|
||||||
print(bst_find(root, "Anna")) # 999
|
|
||||||
|
|
||||||
root = bst_delete(root, "Ivan")
|
|
||||||
|
|
||||||
print(bst_list_all(root))
|
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
records_shuffled, records_sorted = records()
|
|
||||||
|
|
||||||
run_shuffled(records_shuffled)
|
|
||||||
run_sorted(records_sorted)
|
|
||||||
|
|
@ -1,456 +0,0 @@
|
||||||
from MP_records import records
|
|
||||||
import string
|
|
||||||
import random as rd
|
|
||||||
import time
|
|
||||||
import csv
|
|
||||||
import codecs
|
|
||||||
|
|
||||||
def polynomial_hash(word):
|
|
||||||
p=11111
|
|
||||||
m=(10**9)+9
|
|
||||||
hashh=0
|
|
||||||
for i in range(len(word)):
|
|
||||||
hashh+=ord(word[i])*(p**i)
|
|
||||||
hashh=hashh%m
|
|
||||||
return hashh
|
|
||||||
|
|
||||||
def hash_to_index(hashh,length):
|
|
||||||
#print(hashh)
|
|
||||||
#if len(str(hashh))>4:
|
|
||||||
#hashh=int(str(hashh)[3:])
|
|
||||||
while hashh>length:
|
|
||||||
hashh=hashh%(length)
|
|
||||||
return hashh
|
|
||||||
|
|
||||||
def ll_insert(table,name,phone,index):
|
|
||||||
if table[index]==None:
|
|
||||||
entry={"name":name,"phone":phone,"next":None}
|
|
||||||
table[index]=entry
|
|
||||||
return table
|
|
||||||
else:
|
|
||||||
entry={"name":name,"phone":phone,"next":None}
|
|
||||||
if table[index]["phone"]==phone:
|
|
||||||
table[index]["name"]=name
|
|
||||||
return table
|
|
||||||
if table[index]["next"]==None:
|
|
||||||
table[index]["next"]=entry
|
|
||||||
return table
|
|
||||||
else:
|
|
||||||
nexxt=table[index]["next"]
|
|
||||||
if nexxt["phone"]==phone:
|
|
||||||
nexxt["name"]=name
|
|
||||||
return table
|
|
||||||
while nexxt["next"]!=None:
|
|
||||||
nexxt=nexxt["next"]
|
|
||||||
if nexxt["phone"]==phone:
|
|
||||||
nexxt["name"]=name
|
|
||||||
return table
|
|
||||||
nexxt["next"]=entry
|
|
||||||
return table
|
|
||||||
|
|
||||||
def ht_insert(table,name,phone):
|
|
||||||
index=hash_to_index(polynomial_hash(name), len(table))
|
|
||||||
ll_insert(table,name,phone,index)
|
|
||||||
return table
|
|
||||||
|
|
||||||
def ht_find(table, name):
|
|
||||||
index=hash_to_index(polynomial_hash(name), len(table))
|
|
||||||
if table[index]!=None:
|
|
||||||
if table[index]["name"]==name:
|
|
||||||
return table[index]["phone"]
|
|
||||||
elif table[index]["next"]!=None:
|
|
||||||
if table[index]["next"]["name"]==name:
|
|
||||||
return table[index]["next"]["phone"]
|
|
||||||
else:
|
|
||||||
nexxt=table[index]["next"]
|
|
||||||
while nexxt["next"]!=None:
|
|
||||||
nexxt=nexxt["next"]
|
|
||||||
if nexxt["name"]==name:
|
|
||||||
return nexxt["phone"]
|
|
||||||
return None
|
|
||||||
|
|
||||||
def ht_delete(table,name):
|
|
||||||
index=hash_to_index(polynomial_hash(name), len(table))
|
|
||||||
if len(table)>0:
|
|
||||||
if table[index]["name"]==name:
|
|
||||||
if table[index]["next"]!=None:
|
|
||||||
table[index]=table[index]["next"]
|
|
||||||
return table
|
|
||||||
else:
|
|
||||||
table[index]=None
|
|
||||||
return table
|
|
||||||
elif table[index]["next"]!=None:
|
|
||||||
if table[index]["next"]["name"]==name:
|
|
||||||
if table[index]["next"]["next"]!=None:
|
|
||||||
table[index]["next"]=table[index]["next"]["next"]
|
|
||||||
return table
|
|
||||||
else:
|
|
||||||
table[index]["next"]=None
|
|
||||||
return table
|
|
||||||
elif table[index]["next"]["next"]!=None:
|
|
||||||
nexxt1=table[index]["next"]
|
|
||||||
nexxt2=nexxt1["next"]
|
|
||||||
if nexxt2["name"]==name:
|
|
||||||
if nexxt2["next"]!=None:
|
|
||||||
nexxt1["next"]=nexxt2["next"]
|
|
||||||
return table
|
|
||||||
else:
|
|
||||||
nexxt1["next"]=None
|
|
||||||
return table
|
|
||||||
while nexxt2["next"]!=None:
|
|
||||||
nexxt1=nexxt2
|
|
||||||
nexxt2=nexxt1["next"]
|
|
||||||
if nexxt2["name"]==name:
|
|
||||||
if nexxt2["next"]!=None:
|
|
||||||
nexxt1["next"]=nexxt2["next"]
|
|
||||||
return table
|
|
||||||
else:
|
|
||||||
nexxt1["next"]=None
|
|
||||||
return table
|
|
||||||
|
|
||||||
def bad_sort(names,phones):
|
|
||||||
names1=[]
|
|
||||||
phones1=[]
|
|
||||||
while len(names)>0:
|
|
||||||
min_=names[0].encode()
|
|
||||||
ph=phones[0]
|
|
||||||
for i in range(len(names)):
|
|
||||||
nm=names[i].encode()
|
|
||||||
if nm<min_:
|
|
||||||
min_=nm
|
|
||||||
ph=phones[i]
|
|
||||||
#print(min_.decode()," - ",ph)
|
|
||||||
names1.append(min_.decode())
|
|
||||||
phones1.append(ph)
|
|
||||||
names.remove(min_.decode())
|
|
||||||
phones.remove(ph)
|
|
||||||
#print(names1,"\n",phones1)
|
|
||||||
return names1, phones1
|
|
||||||
|
|
||||||
def Shell(names,phones):
|
|
||||||
N = len(names)
|
|
||||||
n = N // 2
|
|
||||||
while n>0:
|
|
||||||
for i in range (0,N-n):
|
|
||||||
j=i
|
|
||||||
while j+n<N:
|
|
||||||
if (names[j].encode())>(names[j+n].encode()):
|
|
||||||
t=names[j]
|
|
||||||
t1=phones[j]
|
|
||||||
names[j]=names[j+n]
|
|
||||||
phones[j]=phones[j+n]
|
|
||||||
names[j+n]=t
|
|
||||||
phones[j+n]=t1
|
|
||||||
j=i
|
|
||||||
else:
|
|
||||||
j+=n
|
|
||||||
n=n//2
|
|
||||||
return names,phones
|
|
||||||
|
|
||||||
def ht_listall(table):
|
|
||||||
names=[]
|
|
||||||
phones=[]
|
|
||||||
pointer=0
|
|
||||||
while pointer<len(table):
|
|
||||||
if table[pointer]!=None:
|
|
||||||
names.append(table[pointer]["name"])
|
|
||||||
phones.append(table[pointer]["phone"])
|
|
||||||
if table[pointer]["next"]!=None:
|
|
||||||
names.append(table[pointer]["next"]["name"])
|
|
||||||
phones.append(table[pointer]["next"]["phone"])
|
|
||||||
nexxt=table[pointer]["next"]
|
|
||||||
while nexxt["next"]!=None:
|
|
||||||
nexxt=nexxt["next"]
|
|
||||||
names.append(nexxt["name"])
|
|
||||||
phones.append(nexxt["phone"])
|
|
||||||
pointer+=1
|
|
||||||
names1, phones1 = bad_sort(names, phones)
|
|
||||||
#names1, phones1 = Shell(names, phones)
|
|
||||||
for i in range(len(names1)):
|
|
||||||
print(names1[i]," - ",phones1[i],end='')
|
|
||||||
if i%4==0:
|
|
||||||
print("\n")
|
|
||||||
else:
|
|
||||||
print(", ",end='')
|
|
||||||
print("\n")
|
|
||||||
|
|
||||||
def test():
|
|
||||||
table=[]
|
|
||||||
for i in range(8):
|
|
||||||
table.append(None)
|
|
||||||
ht_insert(table, "Zyky", 1)
|
|
||||||
ht_insert(table, "Abba", 2)
|
|
||||||
ht_insert(table, "Babba", 3)
|
|
||||||
ht_insert(table, "Aaaaa", 4)
|
|
||||||
ht_insert(table, "Aakk", 5)
|
|
||||||
ht_insert(table, "Bfaw", 6)
|
|
||||||
ht_insert(table, "Uno", 7)
|
|
||||||
ht_insert(table, "Uk", 8)
|
|
||||||
ht_insert(table, "Uaa", 9)
|
|
||||||
ht_insert(table, "h", 10)
|
|
||||||
print(table)
|
|
||||||
print(ht_find(table,"Aakk"))
|
|
||||||
# ht_delete(table, "Aakk")
|
|
||||||
#ht_delete(table, "Aaaaa")
|
|
||||||
#print(table)
|
|
||||||
#ht_delete(table, "Uaa")
|
|
||||||
#ht_delete(table, "Zyky")
|
|
||||||
print(table)
|
|
||||||
ht_listall(table)
|
|
||||||
|
|
||||||
def run_shuffled(records_shuffled):
|
|
||||||
insertion_times=[]
|
|
||||||
finding_times=[]
|
|
||||||
deletion_times1=[]
|
|
||||||
print("Shuffled list: ")
|
|
||||||
for k in range(5):
|
|
||||||
lisst=[]
|
|
||||||
for i in range(5000):
|
|
||||||
lisst.append(None)
|
|
||||||
rd.shuffle(records_shuffled)
|
|
||||||
|
|
||||||
#А. Вставка всех записей
|
|
||||||
start=time.perf_counter()
|
|
||||||
for i in range(len(records_shuffled)):
|
|
||||||
ht_insert(lisst, records_shuffled[i][0], records_shuffled[i][1])
|
|
||||||
end=time.perf_counter()
|
|
||||||
insertion_times.append(end-start)
|
|
||||||
|
|
||||||
#Б. Поиск 100 случайных записей
|
|
||||||
names=[]
|
|
||||||
index=rd.randint(0,9899)
|
|
||||||
for i in range(100):
|
|
||||||
names.append(records_shuffled[index][0])
|
|
||||||
index+=1
|
|
||||||
for i in range(10):
|
|
||||||
names.append("A")
|
|
||||||
rd.shuffle(names)
|
|
||||||
|
|
||||||
start=time.perf_counter()
|
|
||||||
for i in range(len(names)):
|
|
||||||
ht_find(lisst,names[i])
|
|
||||||
end=time.perf_counter()
|
|
||||||
finding_times.append(end-start)
|
|
||||||
|
|
||||||
#В. Удаление 50 случайных записей
|
|
||||||
for i in range(10):
|
|
||||||
names.remove("A")
|
|
||||||
rd.shuffle(names)
|
|
||||||
deletion_times=[]
|
|
||||||
|
|
||||||
for i in range(50):
|
|
||||||
start=time.perf_counter()
|
|
||||||
ht_delete(lisst,names[i])
|
|
||||||
end=time.perf_counter()
|
|
||||||
ttt=end-start
|
|
||||||
deletion_times.append(ttt)
|
|
||||||
deletion_times1.append(deletion_times)
|
|
||||||
|
|
||||||
print("Run number ",k+1)
|
|
||||||
print("Insertion time: ",insertion_times[k])
|
|
||||||
print("Finding time: ",finding_times[k])
|
|
||||||
print("Deletion times: ","\n",deletion_times)
|
|
||||||
print("\n")
|
|
||||||
|
|
||||||
temp=0
|
|
||||||
for i in range(5):
|
|
||||||
temp+=insertion_times[i]
|
|
||||||
temp=temp/5
|
|
||||||
|
|
||||||
results = [
|
|
||||||
[u"Структура", u"Режим", u"Операция", u"Время (сек)"],
|
|
||||||
["HashTable", u"случайный", u"вставка", insertion_times[0]],
|
|
||||||
["HashTable", u"случайный", u"вставка", insertion_times[1]],
|
|
||||||
["HashTable", u"случайный", u"вставка", insertion_times[2]],
|
|
||||||
["HashTable", u"случайный", u"вставка", insertion_times[3]],
|
|
||||||
["HashTable", u"случайный", u"вставка", insertion_times[4]],
|
|
||||||
[u"Структура", u"Режим", u"Операция", u"Среднее время (сек)"],
|
|
||||||
["HashTable", u"случайный", u"вставка", temp,]
|
|
||||||
]
|
|
||||||
|
|
||||||
with codecs.open("results.csv", "a+", "utf-16") as f:
|
|
||||||
writer = csv.writer(f)
|
|
||||||
writer.writerows(results)
|
|
||||||
writer.writerows("\n")
|
|
||||||
|
|
||||||
temp=0
|
|
||||||
for i in range(5):
|
|
||||||
temp+=finding_times[i]
|
|
||||||
temp=temp/5
|
|
||||||
|
|
||||||
results = [
|
|
||||||
[u"Структура", u"Режим", u"Операция", u"Время (сек)"],
|
|
||||||
["HashTable", u"случайный", u"поиск", finding_times[0]],
|
|
||||||
["HashTable", u"случайный", u"поиск", finding_times[1]],
|
|
||||||
["HashTable", u"случайный", u"поиск", finding_times[2]],
|
|
||||||
["HashTable", u"случайный", u"поиск", finding_times[3]],
|
|
||||||
["HashTable", u"случайный", u"поиск", finding_times[4]],
|
|
||||||
[u"Структура", u"Режим", u"Операция", u"Среднее время (сек)"],
|
|
||||||
["HashTable", u"случайный", u"поиск", temp,]
|
|
||||||
]
|
|
||||||
|
|
||||||
with codecs.open("results.csv", "a+", "utf-16") as f:
|
|
||||||
writer = csv.writer(f)
|
|
||||||
writer.writerows(results)
|
|
||||||
writer.writerows("\n")
|
|
||||||
|
|
||||||
temp=0
|
|
||||||
del_times=[]
|
|
||||||
for i in range(5):
|
|
||||||
for j in range(50):
|
|
||||||
temp+=deletion_times1[i][j]
|
|
||||||
temp=temp/50
|
|
||||||
del_times.append(temp)
|
|
||||||
temp=0
|
|
||||||
|
|
||||||
temp=0
|
|
||||||
for i in range(5):
|
|
||||||
temp+=del_times[i]
|
|
||||||
temp=temp/5
|
|
||||||
|
|
||||||
results = [
|
|
||||||
[u"Структура", u"Режим", u"Операция", u"Время (сек)"],
|
|
||||||
["HashTable", u"случайный", u"удаление", del_times[0]],
|
|
||||||
["HashTable", u"случайный", u"удаление", del_times[1]],
|
|
||||||
["HashTable", u"случайный", u"удаление", del_times[2]],
|
|
||||||
["HashTable", u"случайный", u"удаление", del_times[3]],
|
|
||||||
["HashTable", u"случайный", u"удаление", del_times[4]],
|
|
||||||
[u"Структура", u"Режим", u"Операция", u"Среднее время (сек)"],
|
|
||||||
["HashTable", u"случайный", u"удаление", temp,]
|
|
||||||
]
|
|
||||||
|
|
||||||
with codecs.open("results.csv", "a+", "utf-16") as f:
|
|
||||||
writer = csv.writer(f)
|
|
||||||
writer.writerows(results)
|
|
||||||
writer.writerows("\n")
|
|
||||||
writer.writerows("\n")
|
|
||||||
|
|
||||||
def run_sorted(records_shuffled):
|
|
||||||
insertion_times=[]
|
|
||||||
finding_times=[]
|
|
||||||
deletion_times1=[]
|
|
||||||
print("Sorted list: ")
|
|
||||||
for k in range(5):
|
|
||||||
lisst=[]
|
|
||||||
for i in range(5000):
|
|
||||||
lisst.append(None)
|
|
||||||
|
|
||||||
#А. Вставка всех записей
|
|
||||||
start=time.perf_counter()
|
|
||||||
for i in range(len(records_shuffled)):
|
|
||||||
ht_insert(lisst, records_shuffled[i][0], records_shuffled[i][1])
|
|
||||||
end=time.perf_counter()
|
|
||||||
insertion_times.append(end-start)
|
|
||||||
|
|
||||||
#Б. Поиск 100 случайных записей
|
|
||||||
names=[]
|
|
||||||
index=rd.randint(0,9899)
|
|
||||||
for i in range(100):
|
|
||||||
names.append(records_shuffled[index][0])
|
|
||||||
index+=1
|
|
||||||
for i in range(10):
|
|
||||||
names.append("A")
|
|
||||||
rd.shuffle(names)
|
|
||||||
|
|
||||||
start=time.perf_counter()
|
|
||||||
for i in range(len(names)):
|
|
||||||
ht_find(lisst,names[i])
|
|
||||||
end=time.perf_counter()
|
|
||||||
finding_times.append(end-start)
|
|
||||||
|
|
||||||
#В. Удаление 50 случайных записей
|
|
||||||
for i in range(10):
|
|
||||||
names.remove("A")
|
|
||||||
rd.shuffle(names)
|
|
||||||
deletion_times=[]
|
|
||||||
|
|
||||||
for i in range(50):
|
|
||||||
start=time.perf_counter()
|
|
||||||
ht_delete(lisst,names[i])
|
|
||||||
end=time.perf_counter()
|
|
||||||
ttt=end-start
|
|
||||||
deletion_times.append(ttt)
|
|
||||||
deletion_times1.append(deletion_times)
|
|
||||||
|
|
||||||
print("Run number ",k+1)
|
|
||||||
print("Insertion time: ",insertion_times[k])
|
|
||||||
print("Finding time: ",finding_times[k])
|
|
||||||
print("Deletion average:", sum(deletion_times))
|
|
||||||
print("\n")
|
|
||||||
|
|
||||||
temp=0
|
|
||||||
for i in range(5):
|
|
||||||
temp+=insertion_times[i]
|
|
||||||
temp=temp/5
|
|
||||||
|
|
||||||
results = [
|
|
||||||
[u"Структура", u"Режим", u"Операция", u"Время (сек)"],
|
|
||||||
["HashTable", u"отсортированный", u"вставка", insertion_times[0]],
|
|
||||||
["HashTable", u"отсортированный", u"вставка", insertion_times[1]],
|
|
||||||
["HashTable", u"отсортированный", u"вставка", insertion_times[2]],
|
|
||||||
["HashTable", u"отсортированный", u"вставка", insertion_times[3]],
|
|
||||||
["HashTable", u"сотсортированный", u"вставка", insertion_times[4]],
|
|
||||||
[u"Структура", u"Режим", u"Операция", u"Среднее время (сек)"],
|
|
||||||
["HashTable", u"отсортированный", u"вставка", temp,]
|
|
||||||
]
|
|
||||||
|
|
||||||
with codecs.open("results.csv", "a+", "utf-16") as f:
|
|
||||||
writer = csv.writer(f)
|
|
||||||
writer.writerows(results)
|
|
||||||
writer.writerows("\n")
|
|
||||||
|
|
||||||
temp=0
|
|
||||||
for i in range(5):
|
|
||||||
temp+=finding_times[i]
|
|
||||||
temp=temp/5
|
|
||||||
|
|
||||||
results = [
|
|
||||||
[u"Структура", u"Режим", u"Операция", u"Время (сек)"],
|
|
||||||
["HashTable", u"отсортированный", u"поиск", finding_times[0]],
|
|
||||||
["HashTable", u"отсортированный", u"поиск", finding_times[1]],
|
|
||||||
["HashTable", u"отсортированный", u"поиск", finding_times[2]],
|
|
||||||
["HashTable", u"отсортированный", u"поиск", finding_times[3]],
|
|
||||||
["HashTable", u"отсортированный", u"поиск", finding_times[4]],
|
|
||||||
[u"Структура", u"Режим", u"Операция", u"Среднее время (сек)"],
|
|
||||||
["HashTable", u"отсортированный", u"поиск", temp,]
|
|
||||||
]
|
|
||||||
|
|
||||||
with codecs.open("results.csv", "a+", "utf-16") as f:
|
|
||||||
writer = csv.writer(f)
|
|
||||||
writer.writerows(results)
|
|
||||||
writer.writerows("\n")
|
|
||||||
|
|
||||||
temp=0
|
|
||||||
del_times=[]
|
|
||||||
for i in range(5):
|
|
||||||
for j in range(50):
|
|
||||||
temp+=deletion_times1[i][j]
|
|
||||||
temp=temp/50
|
|
||||||
del_times.append(temp)
|
|
||||||
temp=0
|
|
||||||
|
|
||||||
temp=0
|
|
||||||
for i in range(5):
|
|
||||||
temp+=del_times[i]
|
|
||||||
temp=temp/5
|
|
||||||
|
|
||||||
results = [
|
|
||||||
[u"Структура", u"Режим", u"Операция", u"Время (сек)"],
|
|
||||||
["HashTable", u"отсортированный", u"удаление", del_times[0]],
|
|
||||||
["HashTable", u"отсортированный", u"удаление", del_times[1]],
|
|
||||||
["HashTable", u"отсортированный", u"удаление", del_times[2]],
|
|
||||||
["HashTable", u"отсортированный", u"удаление", del_times[3]],
|
|
||||||
["HashTable", u"отсортированный", u"удаление", del_times[4]],
|
|
||||||
[u"Структура", u"Режим", u"Операция", u"Среднее время (сек)"],
|
|
||||||
["HashTable", u"отсортированный", u"удаление", temp,]
|
|
||||||
]
|
|
||||||
|
|
||||||
with codecs.open("results.csv", "a+", "utf-16") as f:
|
|
||||||
writer = csv.writer(f)
|
|
||||||
writer.writerows(results)
|
|
||||||
writer.writerows("\n")
|
|
||||||
writer.writerows("\n")
|
|
||||||
|
|
||||||
records_shuffled, records_sorted = records()
|
|
||||||
run_shuffled(records_shuffled)
|
|
||||||
run_sorted(records_sorted)
|
|
||||||
|
|
@ -1,241 +0,0 @@
|
||||||
from MP_records import records
|
|
||||||
import random as rd
|
|
||||||
import time
|
|
||||||
import csv
|
|
||||||
import codecs
|
|
||||||
|
|
||||||
|
|
||||||
# ---------- Linked List Phone Book ----------
|
|
||||||
# Узел списка:
|
|
||||||
# {"name": name, "phone": phone, "next": next_node}
|
|
||||||
|
|
||||||
|
|
||||||
def ll_insert(head, name, phone):
|
|
||||||
"""
|
|
||||||
Добавляет новую запись или обновляет телефон по имени.
|
|
||||||
Возвращает голову списка.
|
|
||||||
"""
|
|
||||||
new_node = {
|
|
||||||
"name": name,
|
|
||||||
"phone": phone,
|
|
||||||
"next": None
|
|
||||||
}
|
|
||||||
|
|
||||||
if head is None:
|
|
||||||
return new_node
|
|
||||||
|
|
||||||
current = head
|
|
||||||
|
|
||||||
while True:
|
|
||||||
if current["name"] == name:
|
|
||||||
current["phone"] = phone
|
|
||||||
return head
|
|
||||||
|
|
||||||
if current["next"] is None:
|
|
||||||
break
|
|
||||||
|
|
||||||
current = current["next"]
|
|
||||||
|
|
||||||
current["next"] = new_node
|
|
||||||
return head
|
|
||||||
|
|
||||||
|
|
||||||
def ll_find(head, name):
|
|
||||||
"""
|
|
||||||
Ищет запись по имени.
|
|
||||||
Возвращает телефон или None.
|
|
||||||
"""
|
|
||||||
current = head
|
|
||||||
|
|
||||||
while current is not None:
|
|
||||||
if current["name"] == name:
|
|
||||||
return current["phone"]
|
|
||||||
|
|
||||||
current = current["next"]
|
|
||||||
|
|
||||||
return None
|
|
||||||
|
|
||||||
|
|
||||||
def ll_delete(head, name):
|
|
||||||
"""
|
|
||||||
Удаляет запись по имени.
|
|
||||||
Если записи нет, ничего не меняет.
|
|
||||||
Возвращает новую голову списка.
|
|
||||||
"""
|
|
||||||
if head is None:
|
|
||||||
return None
|
|
||||||
|
|
||||||
if head["name"] == name:
|
|
||||||
return head["next"]
|
|
||||||
|
|
||||||
previous = head
|
|
||||||
current = head["next"]
|
|
||||||
|
|
||||||
while current is not None:
|
|
||||||
if current["name"] == name:
|
|
||||||
previous["next"] = current["next"]
|
|
||||||
return head
|
|
||||||
|
|
||||||
previous = current
|
|
||||||
current = current["next"]
|
|
||||||
|
|
||||||
return head
|
|
||||||
|
|
||||||
|
|
||||||
def ll_list_all(head):
|
|
||||||
"""
|
|
||||||
Возвращает список всех записей, отсортированный по имени.
|
|
||||||
"""
|
|
||||||
result = []
|
|
||||||
current = head
|
|
||||||
|
|
||||||
while current is not None:
|
|
||||||
result.append((current["name"], current["phone"]))
|
|
||||||
current = current["next"]
|
|
||||||
|
|
||||||
result.sort(key=lambda item: item[0])
|
|
||||||
return result
|
|
||||||
|
|
||||||
|
|
||||||
# ---------- Compatibility aliases ----------
|
|
||||||
# Можно оставить старые имена, если они уже используются в отчете/других файлах.
|
|
||||||
|
|
||||||
def insert(head, name, phone):
|
|
||||||
return ll_insert(head, name, phone)
|
|
||||||
|
|
||||||
|
|
||||||
def find(head, name):
|
|
||||||
return ll_find(head, name)
|
|
||||||
|
|
||||||
|
|
||||||
def delete(head, name):
|
|
||||||
return ll_delete(head, name)
|
|
||||||
|
|
||||||
|
|
||||||
def list_all(head):
|
|
||||||
return ll_list_all(head)
|
|
||||||
|
|
||||||
|
|
||||||
# ---------- Benchmark helpers ----------
|
|
||||||
|
|
||||||
def build_linked_list(records_list):
|
|
||||||
head = None
|
|
||||||
|
|
||||||
for name, phone in records_list:
|
|
||||||
head = ll_insert(head, name, phone)
|
|
||||||
|
|
||||||
return head
|
|
||||||
|
|
||||||
|
|
||||||
def measure_linked_list(records_list, mode_name, repeats=5):
|
|
||||||
"""
|
|
||||||
Выполняет 5 повторов:
|
|
||||||
1. вставка всех записей;
|
|
||||||
2. поиск 100 существующих и 10 отсутствующих имен;
|
|
||||||
3. удаление 50 существующих имен.
|
|
||||||
|
|
||||||
Возвращает строки для записи в CSV.
|
|
||||||
"""
|
|
||||||
rows = []
|
|
||||||
|
|
||||||
insertion_times = []
|
|
||||||
finding_times = []
|
|
||||||
deletion_times = []
|
|
||||||
|
|
||||||
for run_number in range(1, repeats + 1):
|
|
||||||
data = records_list[:]
|
|
||||||
|
|
||||||
if mode_name == "случайный":
|
|
||||||
rd.shuffle(data)
|
|
||||||
|
|
||||||
# А. Вставка всех записей
|
|
||||||
head = None
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name, phone in data:
|
|
||||||
head = ll_insert(head, name, phone)
|
|
||||||
|
|
||||||
end = time.perf_counter()
|
|
||||||
insertion_time = end - start
|
|
||||||
insertion_times.append(insertion_time)
|
|
||||||
|
|
||||||
# Б. Поиск 100 существующих + 10 отсутствующих
|
|
||||||
existing_names = [name for name, phone in rd.sample(data, 100)]
|
|
||||||
missing_names = [f"None_{i}" for i in range(10)]
|
|
||||||
search_names = existing_names + missing_names
|
|
||||||
rd.shuffle(search_names)
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name in search_names:
|
|
||||||
ll_find(head, name)
|
|
||||||
|
|
||||||
end = time.perf_counter()
|
|
||||||
finding_time = end - start
|
|
||||||
finding_times.append(finding_time)
|
|
||||||
|
|
||||||
# В. Удаление 50 существующих
|
|
||||||
delete_names = rd.sample(existing_names, 50)
|
|
||||||
|
|
||||||
start = time.perf_counter()
|
|
||||||
|
|
||||||
for name in delete_names:
|
|
||||||
head = ll_delete(head, name)
|
|
||||||
|
|
||||||
end = time.perf_counter()
|
|
||||||
deletion_time = end - start
|
|
||||||
deletion_times.append(deletion_time)
|
|
||||||
|
|
||||||
rows.append(["LinkedList", mode_name, "вставка", run_number, insertion_time])
|
|
||||||
rows.append(["LinkedList", mode_name, "поиск", run_number, finding_time])
|
|
||||||
rows.append(["LinkedList", mode_name, "удаление", run_number, deletion_time])
|
|
||||||
|
|
||||||
rows.append(["LinkedList", mode_name, "вставка", "среднее", sum(insertion_times) / repeats])
|
|
||||||
rows.append(["LinkedList", mode_name, "поиск", "среднее", sum(finding_times) / repeats])
|
|
||||||
rows.append(["LinkedList", mode_name, "удаление", "среднее", sum(deletion_times) / repeats])
|
|
||||||
|
|
||||||
return rows
|
|
||||||
|
|
||||||
|
|
||||||
def save_results(rows, filename="results.csv"):
|
|
||||||
with codecs.open(filename, "a+", "utf-16") as file:
|
|
||||||
writer = csv.writer(file)
|
|
||||||
writer.writerows(rows)
|
|
||||||
|
|
||||||
|
|
||||||
def run_shuffled(records_shuffled):
|
|
||||||
rows = measure_linked_list(records_shuffled, "случайный")
|
|
||||||
save_results(rows)
|
|
||||||
return rows
|
|
||||||
|
|
||||||
|
|
||||||
def run_sorted(records_sorted):
|
|
||||||
rows = measure_linked_list(records_sorted, "отсортированный")
|
|
||||||
save_results(rows)
|
|
||||||
return rows
|
|
||||||
|
|
||||||
|
|
||||||
# ---------- Manual tests ----------
|
|
||||||
|
|
||||||
def test():
|
|
||||||
head = None
|
|
||||||
|
|
||||||
head = ll_insert(head, "Ivan", "111")
|
|
||||||
head = ll_insert(head, "Anna", "222")
|
|
||||||
head = ll_insert(head, "Petr", "333")
|
|
||||||
|
|
||||||
print(ll_find(head, "Anna")) # 222
|
|
||||||
print(ll_find(head, "Unknown")) # None
|
|
||||||
|
|
||||||
head = ll_insert(head, "Anna", "999")
|
|
||||||
print(ll_find(head, "Anna")) # 999
|
|
||||||
|
|
||||||
head = ll_delete(head, "Ivan")
|
|
||||||
print(ll_list_all(head)) # [('Anna', '999'), ('Petr', '333')]
|
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
records_shuffled, records_sorted = records()
|
|
||||||
|
|
||||||
run_shuffled(records_shuffled)
|
|
||||||
run_sorted(records_sorted)
|
|
||||||
|
|
@ -1,34 +0,0 @@
|
||||||
import random
|
|
||||||
VOWELS = "aeiou"
|
|
||||||
CONSONANTS = "bcdfghjklmnpqrstvwxyz"
|
|
||||||
def generate_name():
|
|
||||||
length = random.randint(4, 10)
|
|
||||||
|
|
||||||
name = ""
|
|
||||||
|
|
||||||
for i in range(length):
|
|
||||||
if i % 2 == 0:
|
|
||||||
name += random.choice(CONSONANTS)
|
|
||||||
else:
|
|
||||||
name += random.choice(VOWELS)
|
|
||||||
|
|
||||||
return name.capitalize()
|
|
||||||
|
|
||||||
|
|
||||||
def generate_unique_names(count):
|
|
||||||
names = set()
|
|
||||||
|
|
||||||
while len(names) < count:
|
|
||||||
names.add(generate_name())
|
|
||||||
|
|
||||||
return list(names)
|
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
names = generate_unique_names(5000)
|
|
||||||
|
|
||||||
with open("names.txt", "w", encoding="utf-8") as file:
|
|
||||||
for name in names:
|
|
||||||
file.write(name + "\n")
|
|
||||||
|
|
||||||
print("names.txt generated")
|
|
||||||
|
|
@ -1,73 +0,0 @@
|
||||||
import random as rd
|
|
||||||
|
|
||||||
def Shell(arr):
|
|
||||||
N = len(arr)
|
|
||||||
n = N // 2
|
|
||||||
while n>0:
|
|
||||||
for i in range (0,N-n):
|
|
||||||
j=i
|
|
||||||
while j+n<N:
|
|
||||||
if arr[j]>arr[j+n]:
|
|
||||||
t=arr[j]
|
|
||||||
arr[j]=arr[j+n]
|
|
||||||
arr[j+n]=t
|
|
||||||
j=i
|
|
||||||
else:
|
|
||||||
j+=n
|
|
||||||
n=n//2
|
|
||||||
return arr
|
|
||||||
|
|
||||||
def records():
|
|
||||||
phones=[]
|
|
||||||
first=0
|
|
||||||
second=0
|
|
||||||
third=0
|
|
||||||
fourth=0
|
|
||||||
for i in range(10000):
|
|
||||||
phones.append(str(first)+str(second)+str(third)+str(fourth))
|
|
||||||
fourth+=1
|
|
||||||
if fourth==10:
|
|
||||||
third+=1
|
|
||||||
fourth=0
|
|
||||||
if third==10:
|
|
||||||
second+=1
|
|
||||||
third=0
|
|
||||||
if second==10:
|
|
||||||
first+=1
|
|
||||||
second=0
|
|
||||||
phones2=phones.copy()
|
|
||||||
|
|
||||||
f=open("names.txt","r")
|
|
||||||
count=0
|
|
||||||
names=[]
|
|
||||||
while count<5000:
|
|
||||||
name=f.readline()
|
|
||||||
names.append(name[:len(name)-1])
|
|
||||||
names.append(name[:len(name)-1])
|
|
||||||
count+=1
|
|
||||||
f.close()
|
|
||||||
|
|
||||||
names_sorted=names.copy()
|
|
||||||
for i in range(10000):
|
|
||||||
names_sorted[i]=names_sorted[i].encode()
|
|
||||||
Shell(names_sorted)
|
|
||||||
for i in range(10000):
|
|
||||||
names_sorted[i]=names_sorted[i].decode()
|
|
||||||
|
|
||||||
records_shuffled=[]
|
|
||||||
records_sorted=[]
|
|
||||||
count=0
|
|
||||||
while count<10000:
|
|
||||||
name_var=rd.randint(0,len(names)-1)
|
|
||||||
phone_var=rd.randint(0,len(phones2)-1)
|
|
||||||
records_shuffled.append((names[name_var],phones[count]))
|
|
||||||
records_sorted.append((names_sorted[count],phones2[phone_var]))
|
|
||||||
names.remove(names[name_var])
|
|
||||||
phones2.remove(phones2[phone_var])
|
|
||||||
count+=1
|
|
||||||
|
|
||||||
rd.shuffle(records_shuffled)
|
|
||||||
return records_shuffled, records_sorted
|
|
||||||
#print(records_shuffled)
|
|
||||||
#print(records_sorted)
|
|
||||||
|
|
||||||
Binary file not shown.
File diff suppressed because it is too large
Load Diff
Binary file not shown.
Binary file not shown.
|
Can't render this file because it has a wrong number of fields in line 37.
|
|
|
@ -1,143 +0,0 @@
|
||||||
import csv
|
|
||||||
import os
|
|
||||||
|
|
||||||
from builders import TextFileMazeBuilder
|
|
||||||
|
|
||||||
from solver import MazeSolver
|
|
||||||
|
|
||||||
from strategies import (
|
|
||||||
BFSStrategy,
|
|
||||||
DFSStrategy,
|
|
||||||
AStarStrategy
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
# =========================================================
|
|
||||||
# Benchmark
|
|
||||||
# =========================================================
|
|
||||||
|
|
||||||
class BenchmarkRunner:
|
|
||||||
|
|
||||||
def __init__(self):
|
|
||||||
|
|
||||||
self.strategies = [
|
|
||||||
("BFS", BFSStrategy()),
|
|
||||||
("DFS", DFSStrategy()),
|
|
||||||
("A*", AStarStrategy()),
|
|
||||||
]
|
|
||||||
|
|
||||||
# =====================================================
|
|
||||||
# Run benchmark
|
|
||||||
# =====================================================
|
|
||||||
|
|
||||||
def run(
|
|
||||||
self,
|
|
||||||
maze_files: list[str],
|
|
||||||
runs_per_test: int = 5
|
|
||||||
):
|
|
||||||
|
|
||||||
results = []
|
|
||||||
|
|
||||||
builder = TextFileMazeBuilder()
|
|
||||||
|
|
||||||
for maze_file in maze_files:
|
|
||||||
|
|
||||||
print()
|
|
||||||
print(f"Testing: {maze_file}")
|
|
||||||
|
|
||||||
maze = builder.build_from_file(
|
|
||||||
maze_file
|
|
||||||
)
|
|
||||||
|
|
||||||
for strategy_name, strategy in self.strategies:
|
|
||||||
|
|
||||||
total_time = 0
|
|
||||||
total_visited = 0
|
|
||||||
total_path_length = 0
|
|
||||||
|
|
||||||
for _ in range(runs_per_test):
|
|
||||||
|
|
||||||
solver = MazeSolver(
|
|
||||||
maze,
|
|
||||||
strategy
|
|
||||||
)
|
|
||||||
|
|
||||||
path, stats = solver.solve()
|
|
||||||
|
|
||||||
total_time += stats.time_ms
|
|
||||||
total_visited += stats.visited_cells
|
|
||||||
total_path_length += stats.path_length
|
|
||||||
|
|
||||||
avg_time = (
|
|
||||||
total_time / runs_per_test
|
|
||||||
)
|
|
||||||
|
|
||||||
avg_visited = (
|
|
||||||
total_visited / runs_per_test
|
|
||||||
)
|
|
||||||
|
|
||||||
avg_path_length = (
|
|
||||||
total_path_length / runs_per_test
|
|
||||||
)
|
|
||||||
|
|
||||||
result = {
|
|
||||||
"maze": maze_file,
|
|
||||||
"strategy": strategy_name,
|
|
||||||
"time_ms": round(avg_time, 3),
|
|
||||||
"visited_cells": int(avg_visited),
|
|
||||||
"path_length": int(avg_path_length),
|
|
||||||
}
|
|
||||||
|
|
||||||
results.append(result)
|
|
||||||
|
|
||||||
print(
|
|
||||||
f"{strategy_name}: "
|
|
||||||
f"time={avg_time:.3f} ms, "
|
|
||||||
f"visited={avg_visited:.0f}, "
|
|
||||||
f"path={avg_path_length:.0f}"
|
|
||||||
)
|
|
||||||
|
|
||||||
self.save_to_csv(results)
|
|
||||||
|
|
||||||
# =====================================================
|
|
||||||
# Save CSV
|
|
||||||
# =====================================================
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def save_to_csv(results):
|
|
||||||
|
|
||||||
base_dir = os.path.dirname(__file__)
|
|
||||||
|
|
||||||
csv_path = os.path.join(
|
|
||||||
base_dir,
|
|
||||||
"benchmark_results.csv"
|
|
||||||
)
|
|
||||||
|
|
||||||
with open(
|
|
||||||
csv_path,
|
|
||||||
"w",
|
|
||||||
newline="",
|
|
||||||
encoding="utf-8"
|
|
||||||
) as file:
|
|
||||||
|
|
||||||
writer = csv.DictWriter(
|
|
||||||
file,
|
|
||||||
fieldnames=[
|
|
||||||
"maze",
|
|
||||||
"strategy",
|
|
||||||
"time_ms",
|
|
||||||
"visited_cells",
|
|
||||||
"path_length"
|
|
||||||
]
|
|
||||||
)
|
|
||||||
|
|
||||||
writer.writeheader()
|
|
||||||
|
|
||||||
for row in results:
|
|
||||||
|
|
||||||
writer.writerow(row)
|
|
||||||
|
|
||||||
print()
|
|
||||||
print(
|
|
||||||
f"Results saved to: {csv_path}"
|
|
||||||
)
|
|
||||||
|
|
@ -1,13 +0,0 @@
|
||||||
maze,strategy,time_ms,visited_cells,path_length
|
|
||||||
mazes/small.txt,BFS,0.034,17,12
|
|
||||||
mazes/small.txt,DFS,0.026,13,12
|
|
||||||
mazes/small.txt,A*,0.048,17,12
|
|
||||||
mazes/open.txt,BFS,0.219,100,19
|
|
||||||
mazes/open.txt,DFS,0.135,55,55
|
|
||||||
mazes/open.txt,A*,0.334,100,19
|
|
||||||
mazes/medium.txt,BFS,0.093,36,0
|
|
||||||
mazes/medium.txt,DFS,0.059,36,0
|
|
||||||
mazes/medium.txt,A*,0.087,36,0
|
|
||||||
mazes/no_exit.txt,BFS,0.008,5,0
|
|
||||||
mazes/no_exit.txt,DFS,0.007,5,0
|
|
||||||
mazes/no_exit.txt,A*,0.011,5,0
|
|
||||||
|
|
|
@ -1,60 +0,0 @@
|
||||||
from abc import ABC, abstractmethod
|
|
||||||
|
|
||||||
from cell import Cell
|
|
||||||
from maze import Maze
|
|
||||||
|
|
||||||
|
|
||||||
class MazeBuilder(ABC):
|
|
||||||
|
|
||||||
@abstractmethod
|
|
||||||
def build_from_file(self, filename: str) -> Maze:
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class TextFileMazeBuilder(MazeBuilder):
|
|
||||||
|
|
||||||
def build_from_file(self, filename: str) -> Maze:
|
|
||||||
|
|
||||||
with open(filename, "r", encoding="utf-8") as file:
|
|
||||||
lines = [line.rstrip("\n") for line in file]
|
|
||||||
|
|
||||||
cells = []
|
|
||||||
|
|
||||||
start = None
|
|
||||||
exit = None
|
|
||||||
|
|
||||||
for y, line in enumerate(lines):
|
|
||||||
|
|
||||||
row = []
|
|
||||||
|
|
||||||
for x, char in enumerate(line):
|
|
||||||
|
|
||||||
is_wall = char == "#"
|
|
||||||
is_start = char == "S"
|
|
||||||
is_exit = char == "E"
|
|
||||||
|
|
||||||
cell = Cell(
|
|
||||||
x=x,
|
|
||||||
y=y,
|
|
||||||
is_wall=is_wall,
|
|
||||||
is_start=is_start,
|
|
||||||
is_exit=is_exit
|
|
||||||
)
|
|
||||||
|
|
||||||
if is_start:
|
|
||||||
start = cell
|
|
||||||
|
|
||||||
if is_exit:
|
|
||||||
exit = cell
|
|
||||||
|
|
||||||
row.append(cell)
|
|
||||||
|
|
||||||
cells.append(row)
|
|
||||||
|
|
||||||
if start is None:
|
|
||||||
raise ValueError("Старт S не найден")
|
|
||||||
|
|
||||||
if exit is None:
|
|
||||||
raise ValueError("Выход E не найден")
|
|
||||||
|
|
||||||
return Maze(cells, start, exit)
|
|
||||||
|
|
@ -1,13 +0,0 @@
|
||||||
from dataclasses import dataclass
|
|
||||||
|
|
||||||
|
|
||||||
@dataclass(frozen=True)
|
|
||||||
class Cell:
|
|
||||||
x: int
|
|
||||||
y: int
|
|
||||||
is_wall: bool = False
|
|
||||||
is_start: bool = False
|
|
||||||
is_exit: bool = False
|
|
||||||
|
|
||||||
def is_passable(self) -> bool:
|
|
||||||
return not self.is_wall
|
|
||||||
|
|
@ -1,91 +0,0 @@
|
||||||
from abc import ABC, abstractmethod
|
|
||||||
|
|
||||||
from cell import Cell
|
|
||||||
from maze import Maze
|
|
||||||
|
|
||||||
|
|
||||||
class Player:
|
|
||||||
|
|
||||||
def __init__(self, start_cell: Cell):
|
|
||||||
|
|
||||||
self.current_cell = start_cell
|
|
||||||
|
|
||||||
|
|
||||||
# =========================================================
|
|
||||||
# Command
|
|
||||||
# =========================================================
|
|
||||||
|
|
||||||
class Command(ABC):
|
|
||||||
|
|
||||||
@abstractmethod
|
|
||||||
def execute(self):
|
|
||||||
pass
|
|
||||||
|
|
||||||
@abstractmethod
|
|
||||||
def undo(self):
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
# =========================================================
|
|
||||||
# MoveCommand
|
|
||||||
# =========================================================
|
|
||||||
|
|
||||||
class MoveCommand(Command):
|
|
||||||
|
|
||||||
DIRECTIONS = {
|
|
||||||
"W": (0, -1),
|
|
||||||
"S": (0, 1),
|
|
||||||
"A": (-1, 0),
|
|
||||||
"D": (1, 0),
|
|
||||||
}
|
|
||||||
|
|
||||||
def __init__(
|
|
||||||
self,
|
|
||||||
player: Player,
|
|
||||||
maze: Maze,
|
|
||||||
direction: str
|
|
||||||
):
|
|
||||||
|
|
||||||
self.player = player
|
|
||||||
self.maze = maze
|
|
||||||
self.direction = direction.upper()
|
|
||||||
|
|
||||||
self.previous_cell = None
|
|
||||||
|
|
||||||
def execute(self):
|
|
||||||
|
|
||||||
if self.direction not in self.DIRECTIONS:
|
|
||||||
return False
|
|
||||||
|
|
||||||
dx, dy = self.DIRECTIONS[self.direction]
|
|
||||||
|
|
||||||
current = self.player.current_cell
|
|
||||||
|
|
||||||
new_x = current.x + dx
|
|
||||||
new_y = current.y + dy
|
|
||||||
|
|
||||||
target = self.maze.get_cell(
|
|
||||||
new_x,
|
|
||||||
new_y
|
|
||||||
)
|
|
||||||
|
|
||||||
if target is None:
|
|
||||||
return False
|
|
||||||
|
|
||||||
if not target.is_passable():
|
|
||||||
return False
|
|
||||||
|
|
||||||
self.previous_cell = current
|
|
||||||
|
|
||||||
self.player.current_cell = target
|
|
||||||
|
|
||||||
return True
|
|
||||||
|
|
||||||
def undo(self):
|
|
||||||
|
|
||||||
if self.previous_cell is not None:
|
|
||||||
|
|
||||||
self.player.current_cell = (
|
|
||||||
self.previous_cell
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
@ -1,164 +0,0 @@
|
||||||
from builders import TextFileMazeBuilder
|
|
||||||
|
|
||||||
from strategies import (
|
|
||||||
BFSStrategy,
|
|
||||||
DFSStrategy,
|
|
||||||
AStarStrategy
|
|
||||||
)
|
|
||||||
|
|
||||||
from solver import MazeSolver
|
|
||||||
|
|
||||||
from visualization import ConsoleView
|
|
||||||
|
|
||||||
from commands import (
|
|
||||||
Player,
|
|
||||||
MoveCommand
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
def test_strategy(name, strategy, maze):
|
|
||||||
|
|
||||||
print()
|
|
||||||
print("=" * 40)
|
|
||||||
|
|
||||||
view = ConsoleView()
|
|
||||||
|
|
||||||
solver = MazeSolver(
|
|
||||||
maze,
|
|
||||||
strategy
|
|
||||||
)
|
|
||||||
|
|
||||||
solver.add_observer(view)
|
|
||||||
|
|
||||||
path, stats = solver.solve()
|
|
||||||
|
|
||||||
print()
|
|
||||||
print(f"Strategy: {name}")
|
|
||||||
|
|
||||||
print(
|
|
||||||
f"Time: {stats.time_ms:.3f} ms"
|
|
||||||
)
|
|
||||||
|
|
||||||
print(
|
|
||||||
f"Visited cells: {stats.visited_cells}"
|
|
||||||
)
|
|
||||||
|
|
||||||
print(
|
|
||||||
f"Path length: {stats.path_length}"
|
|
||||||
)
|
|
||||||
|
|
||||||
print()
|
|
||||||
|
|
||||||
view.render(
|
|
||||||
maze,
|
|
||||||
path
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
# =========================================================
|
|
||||||
# Manual mode
|
|
||||||
# =========================================================
|
|
||||||
|
|
||||||
def manual_mode(maze):
|
|
||||||
|
|
||||||
print()
|
|
||||||
print("=" * 40)
|
|
||||||
print("MANUAL MODE")
|
|
||||||
print("W/A/S/D - move")
|
|
||||||
print("U - undo")
|
|
||||||
print("Q - quit")
|
|
||||||
|
|
||||||
view = ConsoleView()
|
|
||||||
|
|
||||||
player = Player(
|
|
||||||
maze.start
|
|
||||||
)
|
|
||||||
|
|
||||||
history = []
|
|
||||||
|
|
||||||
while True:
|
|
||||||
|
|
||||||
print()
|
|
||||||
|
|
||||||
view.render(
|
|
||||||
maze,
|
|
||||||
current=player.current_cell
|
|
||||||
)
|
|
||||||
|
|
||||||
if player.current_cell == maze.exit:
|
|
||||||
|
|
||||||
print()
|
|
||||||
print("YOU WIN!")
|
|
||||||
|
|
||||||
break
|
|
||||||
|
|
||||||
command_input = input(
|
|
||||||
"\nCommand: "
|
|
||||||
).upper()
|
|
||||||
|
|
||||||
if command_input == "Q":
|
|
||||||
break
|
|
||||||
|
|
||||||
if command_input == "U":
|
|
||||||
|
|
||||||
if history:
|
|
||||||
|
|
||||||
last_command = history.pop()
|
|
||||||
|
|
||||||
last_command.undo()
|
|
||||||
|
|
||||||
continue
|
|
||||||
|
|
||||||
command = MoveCommand(
|
|
||||||
player,
|
|
||||||
maze,
|
|
||||||
command_input
|
|
||||||
)
|
|
||||||
|
|
||||||
success = command.execute()
|
|
||||||
|
|
||||||
if success:
|
|
||||||
history.append(command)
|
|
||||||
else:
|
|
||||||
print("Invalid move")
|
|
||||||
|
|
||||||
|
|
||||||
def main():
|
|
||||||
|
|
||||||
builder = TextFileMazeBuilder()
|
|
||||||
|
|
||||||
maze = builder.build_from_file(
|
|
||||||
"mazes/small.txt"
|
|
||||||
)
|
|
||||||
|
|
||||||
# =====================================
|
|
||||||
# Strategies
|
|
||||||
# =====================================
|
|
||||||
|
|
||||||
test_strategy(
|
|
||||||
"BFS",
|
|
||||||
BFSStrategy(),
|
|
||||||
maze
|
|
||||||
)
|
|
||||||
|
|
||||||
test_strategy(
|
|
||||||
"DFS",
|
|
||||||
DFSStrategy(),
|
|
||||||
maze
|
|
||||||
)
|
|
||||||
|
|
||||||
test_strategy(
|
|
||||||
"A*",
|
|
||||||
AStarStrategy(),
|
|
||||||
maze
|
|
||||||
)
|
|
||||||
|
|
||||||
# =====================================
|
|
||||||
# Manual mode
|
|
||||||
# =====================================
|
|
||||||
|
|
||||||
manual_mode(maze)
|
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
main()
|
|
||||||
|
|
@ -1,33 +0,0 @@
|
||||||
from cell import Cell
|
|
||||||
|
|
||||||
|
|
||||||
class Maze:
|
|
||||||
def __init__(self, cells: list[list[Cell]], start: Cell, exit: Cell):
|
|
||||||
self.cells = cells
|
|
||||||
self.height = len(cells)
|
|
||||||
self.width = len(cells[0]) if self.height > 0 else 0
|
|
||||||
self.start = start
|
|
||||||
self.exit = exit
|
|
||||||
|
|
||||||
def get_cell(self, x: int, y: int) -> Cell | None:
|
|
||||||
if 0 <= y < self.height and 0 <= x < self.width:
|
|
||||||
return self.cells[y][x]
|
|
||||||
return None
|
|
||||||
|
|
||||||
def get_neighbors(self, cell: Cell) -> list[Cell]:
|
|
||||||
directions = [
|
|
||||||
(0, -1),
|
|
||||||
(0, 1),
|
|
||||||
(-1, 0),
|
|
||||||
(1, 0),
|
|
||||||
]
|
|
||||||
|
|
||||||
neighbors = []
|
|
||||||
|
|
||||||
for dx, dy in directions:
|
|
||||||
neighbor = self.get_cell(cell.x + dx, cell.y + dy)
|
|
||||||
|
|
||||||
if neighbor is not None and neighbor.is_passable():
|
|
||||||
neighbors.append(neighbor)
|
|
||||||
|
|
||||||
return neighbors
|
|
||||||
|
|
@ -1,11 +0,0 @@
|
||||||
####################
|
|
||||||
#S # # #
|
|
||||||
### ### ##### ### ##
|
|
||||||
# # # ##
|
|
||||||
# ### ### # ##### ##
|
|
||||||
# # # # # #
|
|
||||||
# # ##### ##### # #
|
|
||||||
# # # # # #
|
|
||||||
# ##### ##### # # #
|
|
||||||
# # # E#
|
|
||||||
####################
|
|
||||||
|
|
@ -1,5 +0,0 @@
|
||||||
##########
|
|
||||||
#S# #E#
|
|
||||||
# ### ####
|
|
||||||
# # #
|
|
||||||
##########
|
|
||||||
|
|
@ -1,10 +0,0 @@
|
||||||
S
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
E
|
|
||||||
|
|
@ -1,5 +0,0 @@
|
||||||
##########
|
|
||||||
#S #E#
|
|
||||||
# ### ## #
|
|
||||||
# # #
|
|
||||||
##########
|
|
||||||
Binary file not shown.
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user