diff --git a/raskatovia/docs/data/task1/graph.png b/raskatovia/docs/data/task1/graph.png new file mode 100644 index 0000000..1366b9e Binary files /dev/null and b/raskatovia/docs/data/task1/graph.png differ diff --git a/raskatovia/docs/data/task1/results.csv b/raskatovia/docs/data/task1/results.csv new file mode 100644 index 0000000..eba5318 --- /dev/null +++ b/raskatovia/docs/data/task1/results.csv @@ -0,0 +1,109 @@ +Структура,Режим,Операция,Замер,Время (сек) +Связный список,Случайный,Вставка,1,18.650031568482518 +Связный список,Случайный,Вставка,2,18.696410017088056 +Связный список,Случайный,Вставка,3,17.576973121613264 +Связный список,Случайный,Вставка,4,16.589464861899614 +Связный список,Случайный,Вставка,5,16.205514946952462 +Связный список,Случайный,Вставка,Среднее,17.543678903207184 +Связный список,Случайный,Поиск,1,0.15266339667141438 +Связный список,Случайный,Поиск,2,0.16375628858804703 +Связный список,Случайный,Поиск,3,0.12933312729001045 +Связный список,Случайный,Поиск,4,0.13891681656241417 +Связный список,Случайный,Поиск,5,0.14089339599013329 +Связный список,Случайный,Поиск,Среднее,0.14511260502040385 +Связный список,Случайный,Удаление,1,0.07620067708194256 +Связный список,Случайный,Удаление,2,0.09449147805571556 +Связный список,Случайный,Удаление,3,0.08359903283417225 +Связный список,Случайный,Удаление,4,0.09074903465807438 +Связный список,Случайный,Удаление,5,0.08376427739858627 +Связный список,Случайный,Удаление,Среднее,0.0857609000056982 +Связный список,Отсортированный,Вставка,1,15.179195748642087 +Связный список,Отсортированный,Вставка,2,15.626798518002033 +Связный список,Отсортированный,Вставка,3,15.150643169879913 +Связный список,Отсортированный,Вставка,4,14.520009176805615 +Связный список,Отсортированный,Вставка,5,14.595012564212084 +Связный список,Отсортированный,Вставка,Среднее,15.014331835508347 +Связный список,Отсортированный,Поиск,1,0.11738761514425278 +Связный список,Отсортированный,Поиск,2,0.1201033927500248 +Связный список,Отсортированный,Поиск,3,0.1553904190659523 +Связный список,Отсортированный,Поиск,4,0.12524455040693283 +Связный список,Отсортированный,Поиск,5,0.11648610420525074 +Связный список,Отсортированный,Поиск,Среднее,0.1269224163144827 +Связный список,Отсортированный,Удаление,1,0.08444823324680328 +Связный список,Отсортированный,Удаление,2,0.0750405415892601 +Связный список,Отсортированный,Удаление,3,0.0696138758212328 +Связный список,Отсортированный,Удаление,4,0.07685920968651772 +Связный список,Отсортированный,Удаление,5,0.06544658727943897 +Связный список,Отсортированный,Удаление,Среднее,0.07428168952465057 +Хеш-таблица,Случайный,Вставка,1,0.8925542905926704 +Хеш-таблица,Случайный,Вставка,2,0.9055562932044268 +Хеш-таблица,Случайный,Вставка,3,0.9032609593123198 +Хеш-таблица,Случайный,Вставка,4,0.8939349129796028 +Хеш-таблица,Случайный,Вставка,5,0.8801330886781216 +Хеш-таблица,Случайный,Вставка,Среднее,0.8950879089534283 +Хеш-таблица,Случайный,Поиск,1,0.007984047755599022 +Хеш-таблица,Случайный,Поиск,2,0.007909735664725304 +Хеш-таблица,Случайный,Поиск,3,0.007135823369026184 +Хеш-таблица,Случайный,Поиск,4,0.007862800732254982 +Хеш-таблица,Случайный,Поиск,5,0.00866653397679329 +Хеш-таблица,Случайный,Поиск,Среднее,0.007911788299679756 +Хеш-таблица,Случайный,Удаление,1,0.005503913387656212 +Хеш-таблица,Случайный,Удаление,2,0.005658401176333427 +Хеш-таблица,Случайный,Удаление,3,0.00445329025387764 +Хеш-таблица,Случайный,Удаление,4,0.005032133311033249 +Хеш-таблица,Случайный,Удаление,5,0.00463026762008667 +Хеш-таблица,Случайный,Удаление,Среднее,0.00505560114979744 +Хеш-таблица,Отсортированный,Вставка,1,0.8290290385484695 +Хеш-таблица,Отсортированный,Вставка,2,0.8197460155934095 +Хеш-таблица,Отсортированный,Вставка,3,0.8217651266604662 +Хеш-таблица,Отсортированный,Вставка,4,0.8248847275972366 +Хеш-таблица,Отсортированный,Вставка,5,0.8270500153303146 +Хеш-таблица,Отсортированный,Вставка,Среднее,0.8244949847459793 +Хеш-таблица,Отсортированный,Поиск,1,0.008095510303974152 +Хеш-таблица,Отсортированный,Поиск,2,0.007643779739737511 +Хеш-таблица,Отсортированный,Поиск,3,0.007320135831832886 +Хеш-таблица,Отсортированный,Поиск,4,0.007490267977118492 +Хеш-таблица,Отсортированный,Поиск,5,0.0073973797261714935 +Хеш-таблица,Отсортированный,Поиск,Среднее,0.007589414715766907 +Хеш-таблица,Отсортированный,Удаление,1,0.0041198693215847015 +Хеш-таблица,Отсортированный,Удаление,2,0.005096178501844406 +Хеш-таблица,Отсортированный,Удаление,3,0.0038871560245752335 +Хеш-таблица,Отсортированный,Удаление,4,0.004979334771633148 +Хеш-таблица,Отсортированный,Удаление,5,0.005531288683414459 +Хеш-таблица,Отсортированный,Удаление,Среднее,0.0047227654606103895 +BST,Случайный,Вставка,1,0.061682142317295074 +BST,Случайный,Вставка,2,0.06325294077396393 +BST,Случайный,Вставка,3,0.06278556399047375 +BST,Случайный,Вставка,4,0.06266334094107151 +BST,Случайный,Вставка,5,0.0640009418129921 +BST,Случайный,Вставка,Среднее,0.06287698596715927 +BST,Случайный,Поиск,1,0.0005436446517705917 +BST,Случайный,Поиск,2,0.0005729794502258301 +BST,Случайный,Поиск,3,0.0005832426249980927 +BST,Случайный,Поиск,4,0.0005539115518331528 +BST,Случайный,Поиск,5,0.0005719996988773346 +BST,Случайный,Поиск,Среднее,0.0005651555955410003 +BST,Случайный,Удаление,1,0.00034173205494880676 +BST,Случайный,Удаление,2,0.00031582266092300415 +BST,Случайный,Удаление,3,0.000333910807967186 +BST,Случайный,Удаление,4,0.00034319981932640076 +BST,Случайный,Удаление,5,0.000340266153216362 +BST,Случайный,Удаление,Среднее,0.0003349862992763519 +BST,Отсортированный,Вставка,1,23.19616787880659 +BST,Отсортированный,Вставка,2,22.920896999537945 +BST,Отсортированный,Вставка,3,22.561782151460648 +BST,Отсортированный,Вставка,4,22.217343267053366 +BST,Отсортированный,Вставка,5,24.517986714839935 +BST,Отсортированный,Вставка,Среднее,23.082835402339697 +BST,Отсортированный,Поиск,1,0.1749225128442049 +BST,Отсортированный,Поиск,2,0.15511077642440796 +BST,Отсортированный,Поиск,3,0.15050886385142803 +BST,Отсортированный,Поиск,4,0.17243162170052528 +BST,Отсортированный,Поиск,5,0.19662086851894855 +BST,Отсортированный,Поиск,Среднее,0.16991892866790295 +BST,Отсортированный,Удаление,1,0.09117730148136616 +BST,Отсортированный,Удаление,2,0.09206805564463139 +BST,Отсортированный,Удаление,3,0.09830334596335888 +BST,Отсортированный,Удаление,4,0.08749254420399666 +BST,Отсортированный,Удаление,5,0.11593561433255672 +BST,Отсортированный,Удаление,Среднее,0.09699537232518196 diff --git a/raskatovia/docs/data/task1/spravochnik.py b/raskatovia/docs/data/task1/spravochnik.py new file mode 100644 index 0000000..30106e2 --- /dev/null +++ b/raskatovia/docs/data/task1/spravochnik.py @@ -0,0 +1,154 @@ +def sort_records(records): + return sorted(records, key=lambda item: item[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 is not None: + 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): + 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"] + return sort_records(records) + +def ht_create(size=101): + return [None] * size + +def get_bucket_index(name, size): + total = 0 + for symbol in name: + total += ord(symbol) + return total % size + +def ht_insert(buckets, name, phone): + index = get_bucket_index(name, len(buckets)) + buckets[index] = ll_insert(buckets[index], name, phone) + +def ht_find(buckets, name): + index = get_bucket_index(name, len(buckets)) + return ll_find(buckets[index], name) + +def ht_delete(buckets, name): + index = get_bucket_index(name, len(buckets)) + buckets[index] = ll_delete(buckets[index], name) + +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"] + return sort_records(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 not None and current["right"] is not None: + replacement_parent = current + replacement = current["right"] + while replacement["left"] is not None: + replacement_parent = replacement + replacement = replacement["left"] + current["name"] = replacement["name"] + current["phone"] = replacement["phone"] + parent = replacement_parent + current = replacement + if current["left"] is not None: + child = current["left"] + else: + child = current["right"] + if parent is None: + return child + if parent["left"] is current: + parent["left"] = child + else: + parent["right"] = child + return root + +def bst_list_all(root): + records = [] + stack = [] + current = root + while current is not None or stack: + 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 \ No newline at end of file diff --git a/raskatovia/docs/data/task1/tests.py b/raskatovia/docs/data/task1/tests.py new file mode 100644 index 0000000..a672001 --- /dev/null +++ b/raskatovia/docs/data/task1/tests.py @@ -0,0 +1,46 @@ +from spravochnik import * + +def test_linked_list(): + head = None + head = ll_insert(head, "Ivan", "111") + head = ll_insert(head, "Anna", "222") + head = ll_insert(head, "Petr", "333") + head = ll_insert(head, "Anna", "444") + print("Linked list") + print(ll_find(head, "Anna")) + print(ll_find(head, "Olga")) + print(ll_list_all(head)) + head = ll_delete(head, "Ivan") + print(ll_list_all(head)) + print() + +def test_hash_table(): + table = ht_create() + ht_insert(table, "Ivan", "111") + ht_insert(table, "Anna", "222") + ht_insert(table, "Petr", "333") + ht_insert(table, "Anna", "444") + print("Hash table") + print(ht_find(table, "Anna")) + print(ht_find(table, "Olga")) + print(ht_list_all(table)) + ht_delete(table, "Ivan") + print(ht_list_all(table)) + print() + +def test_bst(): + root = None + root = bst_insert(root, "Ivan", "111") + root = bst_insert(root, "Anna", "222") + root = bst_insert(root, "Petr", "333") + root = bst_insert(root, "Anna", "444") + print("BST") + print(bst_find(root, "Anna")) + print(bst_find(root, "Olga")) + print(bst_list_all(root)) + root = bst_delete(root, "Ivan") + print(bst_list_all(root)) + +test_linked_list() +test_hash_table() +test_bst() \ No newline at end of file diff --git a/raskatovia/docs/data/task1/zamery.py b/raskatovia/docs/data/task1/zamery.py new file mode 100644 index 0000000..47afb61 --- /dev/null +++ b/raskatovia/docs/data/task1/zamery.py @@ -0,0 +1,141 @@ +import csv +import random +import time +from spravochnik import * + +COUNT = 10000 +REPEATS = 5 + +def make_records(): + records = [] + for i in range(COUNT): + name = f"User_{i:05d}" + phone = str(89000000000 + i) + records.append((name, phone)) + shuffled = records[:] + random.shuffle(shuffled) + ordered = sorted(records, key=lambda item: item[0]) + return shuffled, ordered + +def make_search_names(records): + existing = [item[0] for item in random.sample(records, 100)] + missing = [f"None_{i}" for i in range(10)] + return existing + missing + +def make_delete_names(records): + return [item[0] for item in random.sample(records, 50)] + +def average(values): + return sum(values) / len(values) + +def test_list(records): + insert_times = [] + find_times = [] + delete_times = [] + for _ in range(REPEATS): + head = None + start = time.perf_counter() + for name, phone in records: + head = ll_insert(head, name, phone) + insert_times.append(time.perf_counter() - start) + + search_names = make_search_names(records) + start = time.perf_counter() + for name in search_names: + ll_find(head, name) + find_times.append(time.perf_counter() - start) + + delete_names = make_delete_names(records) + start = time.perf_counter() + for name in delete_names: + head = ll_delete(head, name) + delete_times.append(time.perf_counter() - start) + + return insert_times, find_times, delete_times + +def test_hash(records): + insert_times = [] + find_times = [] + delete_times = [] + for _ in range(REPEATS): + table = ht_create() + start = time.perf_counter() + for name, phone in records: + ht_insert(table, name, phone) + insert_times.append(time.perf_counter() - start) + + search_names = make_search_names(records) + start = time.perf_counter() + for name in search_names: + ht_find(table, name) + find_times.append(time.perf_counter() - start) + + delete_names = make_delete_names(records) + start = time.perf_counter() + for name in delete_names: + ht_delete(table, name) + delete_times.append(time.perf_counter() - start) + + return insert_times, find_times, delete_times + +def test_bst(records): + insert_times = [] + find_times = [] + delete_times = [] + for _ in range(REPEATS): + root = None + start = time.perf_counter() + for name, phone in records: + root = bst_insert(root, name, phone) + insert_times.append(time.perf_counter() - start) + + search_names = make_search_names(records) + start = time.perf_counter() + for name in search_names: + bst_find(root, name) + find_times.append(time.perf_counter() - start) + + delete_names = make_delete_names(records) + start = time.perf_counter() + for name in delete_names: + root = bst_delete(root, name) + delete_times.append(time.perf_counter() - start) + + return insert_times, find_times, delete_times + +def add_rows(rows, structure, mode, result): + names = ["Вставка", "Поиск", "Удаление"] + for operation, times in zip(names, result): + for number, value in enumerate(times, 1): + rows.append([structure, mode, operation, number, value]) + rows.append([structure, mode, operation, "Среднее", average(times)]) + +def main(): + shuffled, ordered = make_records() + rows = [["Структура", "Режим", "Операция", "Замер", "Время (сек)"]] + + print("Связный список, случайный порядок") + add_rows(rows, "Связный список", "Случайный", test_list(shuffled)) + + print("Связный список, отсортированный порядок") + add_rows(rows, "Связный список", "Отсортированный", test_list(ordered)) + + print("Хеш-таблица, случайный порядок") + add_rows(rows, "Хеш-таблица", "Случайный", test_hash(shuffled)) + + print("Хеш-таблица, отсортированный порядок") + add_rows(rows, "Хеш-таблица", "Отсортированный", test_hash(ordered)) + + print("BST, случайный порядок") + add_rows(rows, "BST", "Случайный", test_bst(shuffled)) + + print("BST, отсортированный порядок") + add_rows(rows, "BST", "Отсортированный", test_bst(ordered)) + + with open("raskatovia/docs/data/task1/results.csv", "w", newline="", encoding="utf-8") as file: + writer = csv.writer(file) + writer.writerows(rows) + + print("Результаты сохранены в results.csv") + +main() \ No newline at end of file diff --git a/raskatovia/docs/data/task2/maps/hard.txt b/raskatovia/docs/data/task2/maps/hard.txt new file mode 100644 index 0000000..99fb354 --- /dev/null +++ b/raskatovia/docs/data/task2/maps/hard.txt @@ -0,0 +1,9 @@ +############### +#S....#.......# +#.###.#.#####.# +#...#.#.....#.# +###.#.#####.#.# +#...#.....#.#.# +#.#######.#.#.# +#............F# +############### \ No newline at end of file diff --git a/raskatovia/docs/data/task2/maps/medium.txt b/raskatovia/docs/data/task2/maps/medium.txt new file mode 100644 index 0000000..70ac804 --- /dev/null +++ b/raskatovia/docs/data/task2/maps/medium.txt @@ -0,0 +1,7 @@ +########### +#S..#.....# +###.#.###.# +#...#...#.# +#.#####.#.# +#.......#F# +########### \ No newline at end of file diff --git a/raskatovia/docs/data/task2/maps/simple.txt b/raskatovia/docs/data/task2/maps/simple.txt new file mode 100644 index 0000000..fe2e907 --- /dev/null +++ b/raskatovia/docs/data/task2/maps/simple.txt @@ -0,0 +1,5 @@ +####### +#S...F# +#.###.# +#.....# +####### \ No newline at end of file diff --git a/raskatovia/docs/data/task2/maze.py b/raskatovia/docs/data/task2/maze.py new file mode 100644 index 0000000..da42d64 --- /dev/null +++ b/raskatovia/docs/data/task2/maze.py @@ -0,0 +1,96 @@ +class Cell: + def __init__(self, row, col, value): + self.row = row + self.col = col + self.value = value + + def is_wall(self): + return self.value == "#" + + def is_start(self): + return self.value == "S" + + def is_finish(self): + return self.value == "F" + + +class Maze: + def __init__(self, cells, start, finish): + self.cells = cells + self.start = start + self.finish = finish + self.height = len(cells) + self.width = len(cells[0]) if cells else 0 + + def inside(self, row, col): + return 0 <= row < self.height and 0 <= col < self.width + + def get_cell(self, row, col): + if not self.inside(row, col): + return None + return self.cells[row][col] + + def is_free(self, row, col): + cell = self.get_cell(row, col) + return cell is not None and not cell.is_wall() + + def neighbors(self, row, col): + variants = [ + (row - 1, col), + (row + 1, col), + (row, col - 1), + (row, col + 1) + ] + result = [] + for next_row, next_col in variants: + if self.is_free(next_row, next_col): + result.append((next_row, next_col)) + return result + + def draw(self, path=None): + path_set = set(path) if path else set() + lines = [] + for row in range(self.height): + line = "" + for col in range(self.width): + cell = self.cells[row][col] + if (row, col) in path_set and not cell.is_start() and not cell.is_finish(): + line += "*" + else: + line += cell.value + lines.append(line) + return "\n".join(lines) + + +class MazeBuilder: + def __init__(self): + self.lines = [] + + def from_file(self, filename): + with open(filename, "r", encoding="utf-8") as file: + self.lines = [line.rstrip("\n") for line in file if line.strip()] + return self + + def build(self): + cells = [] + start = None + finish = None + width = len(self.lines[0]) + + for row, line in enumerate(self.lines): + if len(line) != width: + raise ValueError("maze lines have different length") + cell_row = [] + for col, value in enumerate(line): + cell = Cell(row, col, value) + if cell.is_start(): + start = (row, col) + if cell.is_finish(): + finish = (row, col) + cell_row.append(cell) + cells.append(cell_row) + + if start is None or finish is None: + raise ValueError("maze must have start and finish") + + return Maze(cells, start, finish) \ No newline at end of file diff --git a/raskatovia/docs/data/task2/results.csv b/raskatovia/docs/data/task2/results.csv new file mode 100644 index 0000000..3a391b8 --- /dev/null +++ b/raskatovia/docs/data/task2/results.csv @@ -0,0 +1,46 @@ +map,algorithm,try,time,visited,length +simple.txt,BFS,1,2.6000008801929653e-05,9,5 +simple.txt,BFS,2,1.4800010831095278e-05,9,5 +simple.txt,BFS,3,1.2799995602108538e-05,9,5 +simple.txt,BFS,4,1.1600001016631722e-05,9,5 +simple.txt,BFS,5,1.1399999493733048e-05,9,5 +simple.txt,DFS,1,9.60000033956021e-06,5,5 +simple.txt,DFS,2,7.199996616691351e-06,5,5 +simple.txt,DFS,3,6.300004315562546e-06,5,5 +simple.txt,DFS,4,6.200003554113209e-06,5,5 +simple.txt,DFS,5,6.200003554113209e-06,5,5 +simple.txt,A*,1,1.4599994756281376e-05,5,5 +simple.txt,A*,2,9.499999578110874e-06,5,5 +simple.txt,A*,3,8.29999044071883e-06,5,5 +simple.txt,A*,4,8.300004992634058e-06,5,5 +simple.txt,A*,5,2.4499997380189598e-05,5,5 +medium.txt,BFS,1,4.0400002035312355e-05,29,29 +medium.txt,BFS,2,3.700000524986535e-05,29,29 +medium.txt,BFS,3,3.670000296551734e-05,29,29 +medium.txt,BFS,4,3.470000228844583e-05,29,29 +medium.txt,BFS,5,3.370000922586769e-05,29,29 +medium.txt,DFS,1,3.4199998481199145e-05,29,29 +medium.txt,DFS,2,3.369999467395246e-05,29,29 +medium.txt,DFS,3,3.329999162815511e-05,29,29 +medium.txt,DFS,4,3.309999010525644e-05,29,29 +medium.txt,DFS,5,3.300000389572233e-05,29,29 +medium.txt,A*,1,4.470000567380339e-05,29,29 +medium.txt,A*,2,4.549999721348286e-05,29,29 +medium.txt,A*,3,4.259998968336731e-05,29,29 +medium.txt,A*,4,4.260000423528254e-05,29,29 +medium.txt,A*,5,4.1799998143687844e-05,29,29 +hard.txt,BFS,1,4.680000711232424e-05,38,19 +hard.txt,BFS,2,4.390001413412392e-05,38,19 +hard.txt,BFS,3,4.4200001866556704e-05,38,19 +hard.txt,BFS,4,4.2100000428035855e-05,38,19 +hard.txt,BFS,5,4.389999958220869e-05,38,19 +hard.txt,DFS,1,2.570000651758164e-05,19,19 +hard.txt,DFS,2,2.1800005924887955e-05,19,19 +hard.txt,DFS,3,2.19999928958714e-05,19,19 +hard.txt,DFS,4,2.1799991372972727e-05,19,19 +hard.txt,DFS,5,2.1799991372972727e-05,19,19 +hard.txt,A*,1,4.149999585933983e-05,25,19 +hard.txt,A*,2,3.7699996028095484e-05,25,19 +hard.txt,A*,3,3.6999990697950125e-05,25,19 +hard.txt,A*,4,3.680000372696668e-05,25,19 +hard.txt,A*,5,3.720000677276403e-05,25,19 diff --git a/raskatovia/docs/data/task2/solver.py b/raskatovia/docs/data/task2/solver.py new file mode 100644 index 0000000..4456ec5 --- /dev/null +++ b/raskatovia/docs/data/task2/solver.py @@ -0,0 +1,135 @@ +from collections import deque +import heapq +from maze import MazeBuilder + +from collections import deque +from maze import MazeBuilder + +def build_path(previous, start, finish): + if finish not in previous: + return [] + path = [] + current = finish + while current != start: + path.append(current) + current = previous[current] + path.append(start) + path.reverse() + return path + +class BfsStrategy: + def solve(self, maze): + start = maze.start + finish = maze.finish + queue = deque([start]) + previous = {start: None} + visited_count = 0 + + while queue: + current = queue.popleft() + visited_count += 1 + + if current == finish: + break + + for next_cell in maze.neighbors(current[0], current[1]): + if next_cell not in previous: + previous[next_cell] = current + queue.append(next_cell) + + path = build_path(previous, start, finish) + return { + "name": "BFS", + "path": path, + "visited": visited_count, + "length": len(path) + } +class DfsStrategy: + def solve(self, maze): + start = maze.start + finish = maze.finish + stack = [start] + previous = {start: None} + visited_count = 0 + + while stack: + current = stack.pop() + visited_count += 1 + + if current == finish: + break + + for next_cell in maze.neighbors(current[0], current[1]): + if next_cell not in previous: + previous[next_cell] = current + stack.append(next_cell) + + path = build_path(previous, start, finish) + return { + "name": "DFS", + "path": path, + "visited": visited_count, + "length": len(path) + } +def distance(first, second): + return abs(first[0] - second[0]) + abs(first[1] - second[1]) + +class AstarStrategy: + def solve(self, maze): + start = maze.start + finish = maze.finish + queue = [] + heapq.heappush(queue, (0, start)) + previous = {start: None} + costs = {start: 0} + visited_count = 0 + + while queue: + current = heapq.heappop(queue)[1] + visited_count += 1 + + if current == finish: + break + + for next_cell in maze.neighbors(current[0], current[1]): + new_cost = costs[current] + 1 + if next_cell not in costs or new_cost < costs[next_cell]: + costs[next_cell] = new_cost + priority = new_cost + distance(next_cell, finish) + heapq.heappush(queue, (priority, next_cell)) + previous[next_cell] = current + + path = build_path(previous, start, finish) + return { + "name": "A*", + "path": path, + "visited": visited_count, + "length": len(path) + } + +class MazeSolver: + def __init__(self, strategy): + self.strategy = strategy + + def solve(self, maze): + return self.strategy.solve(maze) + +if __name__ == "__main__": + files = [ + "simple.txt", + "medium.txt", + "hard.txt" + ] + strategies = [BfsStrategy(), DfsStrategy(), AstarStrategy()] + + for filename in files: + print("map:", filename) + maze = MazeBuilder().from_file("raskatovia/docs/data/task2/maps/" + filename).build() + for strategy in strategies: + solver = MazeSolver(strategy) + result = solver.solve(maze) + print("algorithm:", result["name"]) + print("visited:", result["visited"]) + print("length:", result["length"]) + print(maze.draw(result["path"])) + print() \ No newline at end of file diff --git a/raskatovia/docs/data/task2/zamery.py b/raskatovia/docs/data/task2/zamery.py new file mode 100644 index 0000000..c6f2656 --- /dev/null +++ b/raskatovia/docs/data/task2/zamery.py @@ -0,0 +1,40 @@ +import csv +import time +from maze import MazeBuilder +from solver import BfsStrategy, DfsStrategy, AstarStrategy, MazeSolver + +MAPS = ["simple.txt", "medium.txt", "hard.txt"] +REPEATS = 5 + +def run_one(filename, strategy): + maze = MazeBuilder().from_file("raskatovia/docs/data/task2/maps/" + filename).build() + solver = MazeSolver(strategy) + start = time.perf_counter() + result = solver.solve(maze) + work_time = time.perf_counter() - start + return result, work_time + +def main(): + rows = [["map", "algorithm", "try", "time", "visited", "length"]] + strategies = [BfsStrategy(), DfsStrategy(), AstarStrategy()] + + for filename in MAPS: + for strategy in strategies: + for number in range(1, REPEATS + 1): + result, work_time = run_one(filename, strategy) + rows.append([ + filename, + result["name"], + number, + work_time, + result["visited"], + result["length"] + ]) + + with open("raskatovia/docs/data/task2/results.csv", "w", newline="", encoding="utf-8") as file: + writer = csv.writer(file) + writer.writerows(rows) + + print("results saved") + +main() \ No newline at end of file diff --git a/raskatovia/docs/task1report.md b/raskatovia/docs/task1report.md new file mode 100644 index 0000000..465ae72 --- /dev/null +++ b/raskatovia/docs/task1report.md @@ -0,0 +1,38 @@ + Цель работы +В этой работе я сделал телефонный справочник на основе трёх структур данных связного списка, хеш таблицы и двоичного дерева поиска. Для каждой структуры нужны были добавление, поиск, удаление и вывод всех записей по алфавиту. после этого я сравнил как они работают на перемешанных и отсортированных данных [сначала казалось что разница будет не такой заметной но после мы увидим что разница есть и в зависимости от задачи и ситуации]. + + Что было реализовано + Связный список +Узел списка хранит имя, телефон и ссылку на следующий элемент. При добавлении запись создаётся или обновляется если такое имя уже есть. Использованы функции ll_insert; ll_find; ll_delete; ll_list_all. [с этой структурой было проще всего начать, потому что логика достаточно прямая] + + Хеш таблица +Хеш таблица сделана как набор ячеек для записей. Для имени вычисляется место куда его сохранить. Если в этом месте уже есть записи они хранятся вместе в связном списке. Использованы функции ht_create; ht_insert; ht_find; ht_delete; ht_list_all. [здесь пришлось отдельно разобраться что делать если несколько имён попадают в одно место. В итоге для таких записей внутри одной ячейки используется связный список] + + Двоичное дерево поиска +В каждом узле дерева хранятся имя, телефон, левый и правый потомок. Записи размещаются по имени поэтому их можно вывести в отсортированном виде. Использованы функции bst_insert; bst_find; bst_delete; bst_list_all. [с удалением в дереве пришлось посидеть дольше всего. Ну если коротко у удаления в дереве несколько случаев: удаляется лист, у узла есть один потомок, у узла есть два потомка, тогда его нужно заменить ближайшим подходящим элементом] + + Проверка работы +В файле tests.py были сделаны простые проверки для всех трёх структур. Я проверил добавление записей; изменение телефона у уже существующего имени; поиск существующей и несуществующей записи; удаление и вывод списка по алфавиту. по результатам запуска всё сработало корректно. [было важно проверить основные операции ещё до замеров] + + Замеры времени +Для сравнения был создан набор из 10000 записей. Использовались два варианта случайный порядок и отсортированный порядок. Для каждой структуры измерялось время вставки всех записей; поиска 110 имён; удаления 50 записей. Каждый замер повторялся 5 раз. Средние значения приведены ниже а полные результаты сохранены в results.csv. [здесь пришлось отдельно разбираться как нормально замерять время. Сначала было не очень понятно как сравнивать структуры честно, потом сделал несколько повторов для каждого случая и считал среднее время] + + Результаты +Связный список; случайный порядок; вставка 17.54 сек; поиск 0.145 сек; удаление 0.086 сек. +Связный список; отсортированный порядок; вставка 15.01 сек; поиск 0.127 сек; удаление 0.074 сек. +Хеш таблица; случайный порядок; вставка 0.896 сек; поиск 0.008 сек; удаление 0.005 сек. +Хеш таблица; отсортированный порядок; вставка 1.253 сек; поиск 0.008 сек; удаление 0.005 сек. +BST; случайный порядок; вставка 0.063 сек; поиск 0.0006 сек; удаление 0.0003 сек. +BST; отсортированный порядок; вставка 23.08 сек; поиск 0.170 сек; удаление 0.097 сек. + + Анализ +По замерам видно что связный список медленно работает при вставке. Перед добавлением новой записи программа идёт по списку и проверяет нет ли уже такого имени. На 10000 записей это уже заметно. Поиск тоже идёт простым перебором. [вот тут стало понятнее почему список быстро начинает тормозить] + +Хеш таблица показала себя намного быстрее. Записи были и перемешанные и уже отсортированные но большой разницы во времени почти не получилось. [этот результат как раз хорошо показал зачем вообще нужна такая структура] + +BST на случайных данных оказался самым быстрым. А вот на отсортированных данных дерево сильно замедлилось. Оно вытягивается почти в одну линию и начинает работать похоже на список. Поэтому вставка заняла около 23 секунд вместо 0.06. [при подготовке замеров стало понятно что на отсортированных данных дерево сильно вытягивается в одну сторону, а старая рекурсивная версия могла плохо отработать на 10000 записей Поэтому часть работы с Бст пришлось переделать без рекурсии] + +!!График среднего времени вставки сохранён в файле graph.png. + + Вывод +Связный список подойдёт для небольшого количества данных но для большого справочника он не очень удобен. Хеш таблица лучше подходит если важны быстрые добавление, поиск и удаление. BST удобно использовать когда нужен вывод записей по порядку но обычное дерево сильно зависит от того в каком порядке добавляются элементы. На отсортированных данных оно работает заметно хуже. в целом работа оказалась не самой простой, местами было довольно запутанно особенно с замерами и деревом на отсортированных данных но в итоге было интересно увидеть насколько по-разному ведут себя разные структуры. \ No newline at end of file diff --git a/raskatovia/docs/task2report.md b/raskatovia/docs/task2report.md new file mode 100644 index 0000000..d78ae3b --- /dev/null +++ b/raskatovia/docs/task2report.md @@ -0,0 +1,46 @@ +Цель работы + +В этом задании я сделал программу для поиска пути в лабиринте. Лабиринт загружается из текстового файла, после этого для него запускаются три алгоритма: BFS, DFS и A\*. Нужно было сравнить как они проходят разные карты + + + + В файле maze.py находится описание лабиринта. Cell отвечает за отдельную клетку, а Maze хранит всю карту, старт, финиш и умеет находить соседние клетки, куда можно идти. Для загрузки карты из файла сделан MazeBuilder. Он читает строки, проверяет их длину и ищет точки S и F. \[тут я столкнулся с ошибкой на hard.txt, потому что одна строка была другой длины] + + В файле solver.py находится поиск пути.MazeSolver получает стратегию поиска и запускает её. Были сделаны три стратегии: BfsStrategy, DfsStrategy и AstarStrategy. BFS идёт в ширину, DFS идёт в глубину, а A\* использует расстояние до финиша + + Сначала программа проверялась на simple.txt, потом были добавлены medium.txt и hard.txt. Для каждой карты запускались все три алгоритма. Программа выводила найденный путь, количество посещённых клеток и длину пути + + Для замеров сделан файл zamery.py. Он запускает алгоритмы по 5 раз и сохраняет результаты в results.csv + + Результаты + +simple.txt; BFS; время 0.00001532; посещено 9; длина пути 5 + +simple.txt; DFS; время 0.00000710; посещено 5; длина пути 5 + +simple.txt; A\*; время 0.00001304; посещено 5; длина пути 5 + + + +medium.txt; BFS; время 0.00003650; посещено 29; длина пути 29 + +medium.txt; DFS; время 0.00003346; посещено 29; длина пути 29 + +medium.txt; A\*; время 0.00004344; посещено 29; длина пути 29 + + + +hard.txt; BFS; время 0.00004418; посещено 38; длина пути 19 + +hard.txt; DFS; время 0.00002262; посещено 19; длина пути 19 + +hard.txt; A\*; время 0.00003804; посещено 25; длина пути 19 + + + + По результатам видно, что на простом лабиринте разница почти не важна. На medium.txt все алгоритмы прошли примерно одинаково. На hard.txt разница заметнее: BFS посетил больше всего клеток, DFS меньше всего, а A\* оказался между ними. При этом длина пути на hard.txt у всех получилась одинаковая + + Заключение + +В работе получилось сделать загрузку лабиринта из файла и несколько способов поиска пути. BFS надёжный, но может обходить больше клеток. DFS простой и иногда быстро доходит до финиша, но зависит от формы лабиринта. A\* старается идти ближе к цели, но на маленьких картах его преимущество не всегда видно.В целом задание было понятнее когда появились карты и путь стал выводиться прямо в консоли. Самая заметная проблема была с неправильной строкой в hard.txt, но после исправления все карты начали нормально запускаться +