From 54b28682b1693a4deade774af76eaa0e6daca186 Mon Sep 17 00:00:00 2001 From: Lorenzo Bianchi Date: Thu, 20 Apr 2023 13:16:53 +0200 Subject: [PATCH] initial commit --- .vscode/settings.json | 56 +++++++++++ Makefile | 29 ++++++ TODO.txt | 2 + a.out | Bin 0 -> 39992 bytes bakcup/.vscode/settings.json | 55 +++++++++++ bakcup/Makefile | 29 ++++++ bakcup/TODO.txt | 2 + bakcup/a.out | Bin 0 -> 39840 bytes bakcup/include/bfs.h | 6 ++ bakcup/include/binaryTree.h | 9 ++ bakcup/include/coor.h | 9 ++ bakcup/include/depthFirst.h | 9 ++ bakcup/include/dfs.h | 6 ++ bakcup/include/dijkstra.h | 8 ++ bakcup/include/eller.h | 9 ++ bakcup/include/labyrinth.h | 49 ++++++++++ bakcup/include/prim.h | 9 ++ bakcup/include/priority_queue.h | 40 ++++++++ bakcup/include/queue.h | 50 ++++++++++ bakcup/include/water.h | 6 ++ bakcup/obj/bfs.o | Bin 0 -> 4072 bytes bakcup/obj/binaryTree.o | Bin 0 -> 2888 bytes bakcup/obj/depthFirst.o | Bin 0 -> 3736 bytes bakcup/obj/dfs.o | Bin 0 -> 3568 bytes bakcup/obj/dijkstra.o | Bin 0 -> 5152 bytes bakcup/obj/eller.o | Bin 0 -> 6592 bytes bakcup/obj/labyrith.o | Bin 0 -> 7240 bytes bakcup/obj/main.o | Bin 0 -> 1992 bytes bakcup/obj/prim.o | Bin 0 -> 4472 bytes bakcup/obj/priorityQueuePP.o | Bin 0 -> 3696 bytes bakcup/obj/priority_queue.o | Bin 0 -> 5296 bytes bakcup/obj/queue.o | Bin 0 -> 3544 bytes bakcup/obj/water.o | Bin 0 -> 1368 bytes bakcup/src/bfs.c | 87 +++++++++++++++++ bakcup/src/binaryTree.c | 70 ++++++++++++++ bakcup/src/depthFirst.c | 77 +++++++++++++++ bakcup/src/dfs.c | 67 +++++++++++++ bakcup/src/dijkstra.c | 117 +++++++++++++++++++++++ bakcup/src/eller.c | 137 +++++++++++++++++++++++++++ bakcup/src/labyrith.c | 149 +++++++++++++++++++++++++++++ bakcup/src/main.c | 30 ++++++ bakcup/src/prim.c | 120 +++++++++++++++++++++++ bakcup/src/priority_queue.c | 127 +++++++++++++++++++++++++ bakcup/src/queue.c | 87 +++++++++++++++++ bakcup/src/water.c | 17 ++++ include/bfs.h | 6 ++ include/binaryTree.h | 9 ++ include/coor.h | 9 ++ include/depthFirst.h | 9 ++ include/dfs.h | 6 ++ include/dijkstra.h | 8 ++ include/eller.h | 9 ++ include/labyrinth.h | 49 ++++++++++ include/prim.h | 9 ++ include/priority_queue.h | 40 ++++++++ include/queue.h | 50 ++++++++++ include/water.h | 6 ++ obj/bfs.o | Bin 0 -> 4072 bytes obj/binaryTree.o | Bin 0 -> 2888 bytes obj/depthFirst.o | Bin 0 -> 3736 bytes obj/dfs.o | Bin 0 -> 3568 bytes obj/dijkstra.o | Bin 0 -> 5160 bytes obj/eller.o | Bin 0 -> 6592 bytes obj/labyrith.o | Bin 0 -> 7240 bytes obj/main.o | Bin 0 -> 1992 bytes obj/prim.o | Bin 0 -> 4472 bytes obj/priorityQueuePP.o | Bin 0 -> 3696 bytes obj/priority_queue.o | Bin 0 -> 5296 bytes obj/queue.o | Bin 0 -> 3800 bytes obj/water.o | Bin 0 -> 4944 bytes src/bfs.c | 87 +++++++++++++++++ src/binaryTree.c | 70 ++++++++++++++ src/depthFirst.c | 77 +++++++++++++++ src/dfs.c | 67 +++++++++++++ src/dijkstra.c | 117 +++++++++++++++++++++++ src/eller.c | 137 +++++++++++++++++++++++++++ src/labyrith.c | 149 +++++++++++++++++++++++++++++ src/main.c | 30 ++++++ src/prim.c | 120 +++++++++++++++++++++++ src/priority_queue.c | 127 +++++++++++++++++++++++++ src/queue.c | 99 +++++++++++++++++++ src/water.c | 163 ++++++++++++++++++++++++++++++++ 82 files changed, 2921 insertions(+) create mode 100644 .vscode/settings.json create mode 100644 Makefile create mode 100644 TODO.txt create mode 100755 a.out create mode 100644 bakcup/.vscode/settings.json create mode 100644 bakcup/Makefile create mode 100644 bakcup/TODO.txt create mode 100755 bakcup/a.out create mode 100644 bakcup/include/bfs.h create mode 100644 bakcup/include/binaryTree.h create mode 100644 bakcup/include/coor.h create mode 100644 bakcup/include/depthFirst.h create mode 100644 bakcup/include/dfs.h create mode 100644 bakcup/include/dijkstra.h create mode 100644 bakcup/include/eller.h create mode 100644 bakcup/include/labyrinth.h create mode 100644 bakcup/include/prim.h create mode 100644 bakcup/include/priority_queue.h create mode 100644 bakcup/include/queue.h create mode 100644 bakcup/include/water.h create mode 100644 bakcup/obj/bfs.o create mode 100644 bakcup/obj/binaryTree.o create mode 100644 bakcup/obj/depthFirst.o create mode 100644 bakcup/obj/dfs.o create mode 100644 bakcup/obj/dijkstra.o create mode 100644 bakcup/obj/eller.o create mode 100644 bakcup/obj/labyrith.o create mode 100644 bakcup/obj/main.o create mode 100644 bakcup/obj/prim.o create mode 100644 bakcup/obj/priorityQueuePP.o create mode 100644 bakcup/obj/priority_queue.o create mode 100644 bakcup/obj/queue.o create mode 100644 bakcup/obj/water.o create mode 100644 bakcup/src/bfs.c create mode 100644 bakcup/src/binaryTree.c create mode 100644 bakcup/src/depthFirst.c create mode 100644 bakcup/src/dfs.c create mode 100644 bakcup/src/dijkstra.c create mode 100644 bakcup/src/eller.c create mode 100644 bakcup/src/labyrith.c create mode 100644 bakcup/src/main.c create mode 100644 bakcup/src/prim.c create mode 100644 bakcup/src/priority_queue.c create mode 100644 bakcup/src/queue.c create mode 100644 bakcup/src/water.c create mode 100644 include/bfs.h create mode 100644 include/binaryTree.h create mode 100644 include/coor.h create mode 100644 include/depthFirst.h create mode 100644 include/dfs.h create mode 100644 include/dijkstra.h create mode 100644 include/eller.h create mode 100644 include/labyrinth.h create mode 100644 include/prim.h create mode 100644 include/priority_queue.h create mode 100644 include/queue.h create mode 100644 include/water.h create mode 100644 obj/bfs.o create mode 100644 obj/binaryTree.o create mode 100644 obj/depthFirst.o create mode 100644 obj/dfs.o create mode 100644 obj/dijkstra.o create mode 100644 obj/eller.o create mode 100644 obj/labyrith.o create mode 100644 obj/main.o create mode 100644 obj/prim.o create mode 100644 obj/priorityQueuePP.o create mode 100644 obj/priority_queue.o create mode 100644 obj/queue.o create mode 100644 obj/water.o create mode 100644 src/bfs.c create mode 100644 src/binaryTree.c create mode 100644 src/depthFirst.c create mode 100644 src/dfs.c create mode 100644 src/dijkstra.c create mode 100644 src/eller.c create mode 100644 src/labyrith.c create mode 100644 src/main.c create mode 100644 src/prim.c create mode 100644 src/priority_queue.c create mode 100644 src/queue.c create mode 100644 src/water.c diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..dfaa897 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,56 @@ +{ + "files.associations": { + "iostream": "cpp", + "vector": "cpp", + "*.tcc": "cpp", + "array": "cpp", + "atomic": "cpp", + "bit": "cpp", + "cctype": "cpp", + "clocale": "cpp", + "cmath": "cpp", + "cstdarg": "cpp", + "cstddef": "cpp", + "cstdint": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "cwchar": "cpp", + "cwctype": "cpp", + "deque": "cpp", + "unordered_map": "cpp", + "exception": "cpp", + "algorithm": "cpp", + "functional": "cpp", + "iterator": "cpp", + "memory": "cpp", + "memory_resource": "cpp", + "numeric": "cpp", + "optional": "cpp", + "random": "cpp", + "string": "cpp", + "string_view": "cpp", + "system_error": "cpp", + "tuple": "cpp", + "type_traits": "cpp", + "utility": "cpp", + "fstream": "cpp", + "initializer_list": "cpp", + "iosfwd": "cpp", + "istream": "cpp", + "limits": "cpp", + "new": "cpp", + "ostream": "cpp", + "sstream": "cpp", + "stdexcept": "cpp", + "streambuf": "cpp", + "typeinfo": "cpp", + "dfs.h": "c", + "eller.h": "c", + "stdio.h": "c", + "prim.h": "c", + "bfs.h": "c", + "water.h": "c", + "dijkstra.h": "c", + "labyrinth.h": "c" + } +} \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..3554a15 --- /dev/null +++ b/Makefile @@ -0,0 +1,29 @@ +CC := gcc +SRC := src +OBJ := obj + +TARGET := a.out + +SRCS := $(shell find $(SRC) -name *.c) +FILES := $(notdir $(basename $(SRCS))) +OBJS := $(addprefix $(OBJ)/,$(addsuffix .o,$(FILES))) + +FLAGS := -Werror -Wall + +all: clear build + +build: $(OBJS) + $(CC) $(FLAGS) $(OBJS) + ./$(TARGET) + +$(OBJ)/%.o: $(SRC)/%.c + $(CC) -Werror -Wall -c $< -o $@ + +only: build + +clean: clear + -rm -f $(OBJS) + + +clear: + clear diff --git a/TODO.txt b/TODO.txt new file mode 100644 index 0000000..f14498f --- /dev/null +++ b/TODO.txt @@ -0,0 +1,2 @@ +- water +- emplace \ No newline at end of file diff --git a/a.out b/a.out new file mode 100755 index 0000000000000000000000000000000000000000..a308670ef74e1f682f10d6542353a86cf87dbd77 GIT binary patch literal 39992 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 av_7g{g`12-GX7iWmt66jZDX)y*?$8BwidMj literal 0 HcmV?d00001 diff --git a/bakcup/.vscode/settings.json b/bakcup/.vscode/settings.json new file mode 100644 index 0000000..0947c0a --- /dev/null +++ b/bakcup/.vscode/settings.json @@ -0,0 +1,55 @@ +{ + "files.associations": { + "iostream": "cpp", + "vector": "cpp", + "*.tcc": "cpp", + "array": "cpp", + "atomic": "cpp", + "bit": "cpp", + "cctype": "cpp", + "clocale": "cpp", + "cmath": "cpp", + "cstdarg": "cpp", + "cstddef": "cpp", + "cstdint": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "cwchar": "cpp", + "cwctype": "cpp", + "deque": "cpp", + "unordered_map": "cpp", + "exception": "cpp", + "algorithm": "cpp", + "functional": "cpp", + "iterator": "cpp", + "memory": "cpp", + "memory_resource": "cpp", + "numeric": "cpp", + "optional": "cpp", + "random": "cpp", + "string": "cpp", + "string_view": "cpp", + "system_error": "cpp", + "tuple": "cpp", + "type_traits": "cpp", + "utility": "cpp", + "fstream": "cpp", + "initializer_list": "cpp", + "iosfwd": "cpp", + "istream": "cpp", + "limits": "cpp", + "new": "cpp", + "ostream": "cpp", + "sstream": "cpp", + "stdexcept": "cpp", + "streambuf": "cpp", + "typeinfo": "cpp", + "dfs.h": "c", + "eller.h": "c", + "stdio.h": "c", + "prim.h": "c", + "bfs.h": "c", + "water.h": "c", + "dijkstra.h": "c" + } +} \ No newline at end of file diff --git a/bakcup/Makefile b/bakcup/Makefile new file mode 100644 index 0000000..3554a15 --- /dev/null +++ b/bakcup/Makefile @@ -0,0 +1,29 @@ +CC := gcc +SRC := src +OBJ := obj + +TARGET := a.out + +SRCS := $(shell find $(SRC) -name *.c) +FILES := $(notdir $(basename $(SRCS))) +OBJS := $(addprefix $(OBJ)/,$(addsuffix .o,$(FILES))) + +FLAGS := -Werror -Wall + +all: clear build + +build: $(OBJS) + $(CC) $(FLAGS) $(OBJS) + ./$(TARGET) + +$(OBJ)/%.o: $(SRC)/%.c + $(CC) -Werror -Wall -c $< -o $@ + +only: build + +clean: clear + -rm -f $(OBJS) + + +clear: + clear diff --git a/bakcup/TODO.txt b/bakcup/TODO.txt new file mode 100644 index 0000000..f14498f --- /dev/null +++ b/bakcup/TODO.txt @@ -0,0 +1,2 @@ +- water +- emplace \ No newline at end of file diff --git a/bakcup/a.out b/bakcup/a.out new file mode 100755 index 0000000000000000000000000000000000000000..5a6bad88da7ae7a18be93165777ba5d351ea3ad9 GIT binary patch literal 39840 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 literal 0 HcmV?d00001 diff --git a/bakcup/include/bfs.h b/bakcup/include/bfs.h new file mode 100644 index 0000000..90818fb --- /dev/null +++ b/bakcup/include/bfs.h @@ -0,0 +1,6 @@ +#ifndef BFS_H +#define BFS_H + +void bfs(Labyrinth* labyrinth); + +#endif \ No newline at end of file diff --git a/bakcup/include/binaryTree.h b/bakcup/include/binaryTree.h new file mode 100644 index 0000000..e8abbf1 --- /dev/null +++ b/bakcup/include/binaryTree.h @@ -0,0 +1,9 @@ +#ifndef BINARY_TREE_H +#define BINARY_TREE_H + +#include "labyrinth.h" + +Labyrinth* binaryTree(int n, int m); +Labyrinth* binaryTreeShow(int n, int m); + +#endif \ No newline at end of file diff --git a/bakcup/include/coor.h b/bakcup/include/coor.h new file mode 100644 index 0000000..95f801a --- /dev/null +++ b/bakcup/include/coor.h @@ -0,0 +1,9 @@ +#ifndef COOR_H +#define COOR_H + +typedef struct coor{ + int x; + int y; +} coor; + +#endif \ No newline at end of file diff --git a/bakcup/include/depthFirst.h b/bakcup/include/depthFirst.h new file mode 100644 index 0000000..97da0f7 --- /dev/null +++ b/bakcup/include/depthFirst.h @@ -0,0 +1,9 @@ +#ifndef DEPTH_FIRST_H +#define DEPTH_FIRST_H + +#include "labyrinth.h" + +Labyrinth* depthFirst(int n, int m); +Labyrinth* depthFirstShow(int n, int m); + +#endif \ No newline at end of file diff --git a/bakcup/include/dfs.h b/bakcup/include/dfs.h new file mode 100644 index 0000000..a9f8244 --- /dev/null +++ b/bakcup/include/dfs.h @@ -0,0 +1,6 @@ +#ifndef DFS_H +#define DFS_H + +void dfs(Labyrinth* labyrinth); + +#endif \ No newline at end of file diff --git a/bakcup/include/dijkstra.h b/bakcup/include/dijkstra.h new file mode 100644 index 0000000..744fe8d --- /dev/null +++ b/bakcup/include/dijkstra.h @@ -0,0 +1,8 @@ +#ifndef DIJKSTRA_H +#define DIJKSTRA_H + +#include "labyrinth.h" + +void dijkstra(Labyrinth* labyrinth); + +#endif \ No newline at end of file diff --git a/bakcup/include/eller.h b/bakcup/include/eller.h new file mode 100644 index 0000000..5b00125 --- /dev/null +++ b/bakcup/include/eller.h @@ -0,0 +1,9 @@ +#ifndef ELLER_H +#define ELLER_H + +#include "labyrinth.h" + +Labyrinth* eller(int n, int m); +Labyrinth* ellerShow(int n, int m); + +#endif \ No newline at end of file diff --git a/bakcup/include/labyrinth.h b/bakcup/include/labyrinth.h new file mode 100644 index 0000000..ba09439 --- /dev/null +++ b/bakcup/include/labyrinth.h @@ -0,0 +1,49 @@ +#ifndef LABYRINTH_H +#define LABYRINTH_H + +#include "coor.h" + +enum Color{ + WHITE, + GREEN, + ORANGE, + BLUE +}; + +enum Direction{ + UP, + RIGHT, + DOWN, + LEFT +}; + +typedef struct Node{ + short south; + short east; + + short visited; + int dp; + + enum Color color; + enum Direction direction; +} Node; + +typedef struct Labyrinth { + Node** at; + int x_size; + int y_size; + + coor start; + coor end; +} Labyrinth; + +Labyrinth* newLabyrinth(int n, int m); +void resetLabyrinth(Labyrinth* Labyrinth); +void removeLabyrinth(Labyrinth* labyrinth); + +void find_path(Labyrinth* labyrinth); + +void printLab(Labyrinth* labyrinth); +void printLabWith(Labyrinth* labyrinth, char wall, char floor, char corner); + +#endif \ No newline at end of file diff --git a/bakcup/include/prim.h b/bakcup/include/prim.h new file mode 100644 index 0000000..c70d30a --- /dev/null +++ b/bakcup/include/prim.h @@ -0,0 +1,9 @@ +#ifndef PRIM_H +#define PRIM_H + +#include "labyrinth.h" + +Labyrinth* prim(int n, int m); +Labyrinth* primShow(int n, int m); + +#endif \ No newline at end of file diff --git a/bakcup/include/priority_queue.h b/bakcup/include/priority_queue.h new file mode 100644 index 0000000..5f5c3e9 --- /dev/null +++ b/bakcup/include/priority_queue.h @@ -0,0 +1,40 @@ +#ifndef PRIORITY_QUEUE_H +#define PRIORITY_QUEUE_H + +#define PRIORITY_QUEUE_INIT_GROWTH_FACT 2 + +#define priority_queue(pq, compare) priority_queue* pq = newPriority_queue(compare); + +typedef struct priority_queue{ + void** at; + int capacity; + int size; + + int growthFactor; + + void (*toString)(); + bool (*compare)(); +} priority_queue; + + +priority_queue* newPriority_queue(bool (*compare)()); + +void priority_queueResize(priority_queue* v, int capacity); + +void priority_queueClear(priority_queue* pq); + +void priority_queuePush(priority_queue* pq, void* element); + +void priority_queueFree(priority_queue* pq); + +void priority_queueShrink_to_fit(priority_queue* pq); + +bool priority_queueIsEmpty(priority_queue* pq); + +void* priority_queueTop(priority_queue* pq); + +void priority_queuePop(priority_queue* pq); + +void priority_queuePrint(priority_queue* pq); + +#endif \ No newline at end of file diff --git a/bakcup/include/queue.h b/bakcup/include/queue.h new file mode 100644 index 0000000..3ab254e --- /dev/null +++ b/bakcup/include/queue.h @@ -0,0 +1,50 @@ +#ifndef QUEUE_H +#define QUEUE_H + +#include + +/* + * Macro to create a new queue. + */ +#define queue(q) queue* q = newQueue(); + +typedef struct queue_element{ + void* next; + void* element; +} queue_element; + +typedef struct queue{ + + int size; /* The number of at in use */ + queue_element* front; /* pointer to the first element of the queue */ + queue_element* back; /* pointer to the back element of the queue */ + + void (*toString)(); /* Pointer to toString function */ +} queue; + + +/* + * Creates new queue. + */ +queue* newQueue(); + +/* + * Adds a new element to the queue. + */ +void queuePush(queue* q, void* element); + +void queuePrint(queue* q); + +void queuePop(queue* q); + +bool queueIsEmpty(queue* q); + +void queueMerge(queue* q1, queue* q2); + +void queueClear(queue* q); + +void queueFree(queue* q); + +void queueEmplace(queue* q, void* element, size_t size); + +#endif \ No newline at end of file diff --git a/bakcup/include/water.h b/bakcup/include/water.h new file mode 100644 index 0000000..6f00882 --- /dev/null +++ b/bakcup/include/water.h @@ -0,0 +1,6 @@ +#ifndef WATER_H +#define WATHER_H + +void water(Labyrinth* labyrinth); + +#endif \ No newline at end of file diff --git a/bakcup/obj/bfs.o b/bakcup/obj/bfs.o new file mode 100644 index 0000000000000000000000000000000000000000..2250d8213a3ffa547ebb2f3f18c7a940a38f2504 GIT binary patch literal 4072 zcmbtWL2nyH6rQ!+B!JU3C5K84$Q(c|YF7!gCcLCv9vv^_Z7A`Vr!pn#~9LJuGg4HZ&&Z)Rt+ws)O0j5IrM zKELnH+xOnQ^$lfwBp?Wc4}rW*4t5+Rq!K=mWh%;~lZ46N;!98Bs`)@Q9_3YYab-re zLa&?!1=UpcdN*py4l37_-_U4H*$vR;Q4p5zJK(Vk6LmLKOIfjE5m+`%e8Q%SZepQz z)ZvPosuf4&P1U@wnl%bP{H_g*AZE!ObehT*?6)jpDpe}TAyZjnG{ymW#gb3=E7j6D zCU^HMYo!+(b(}Nu>Ybec zLUh@z$zhBJCE0KAbOzEjIV3Bi8xP}B5yz8lpTK?t33RH} z*b9i|v4+4_#pN$Rsl_XJTvcAP6HQFxu5jo@cLFO?@1SPwU>;JlN3rc0*`pC7;0>!; zbm!2Ty$XSJg*GUbWk8I@HRuFy+Ce^Q^D}n4RAJL8*T&Z&*2ggA6oulQkL)royv zze20TZVOni9gwBOaBc+-5ck9yE2*q6!p zQ&@sNcm5v=@6D)hurI29f;Rde?vc@bWTO zo?|$HenYTFLC+v# z>TC#)cbl2cR>Q5Vvi9d=xFl@5^sNlG%EG_ zXyKI0Px|hFJqMHa`g(QpvJZaN2k-U4-}1qSeeek%{5>B$>4T?z@S+b+rqe|!g-?+#C87mbtwzQCE!bm~WNP0Fm zlgKCa49OQ}bNYC4niP_`8KyB-RI+*fI!PpodNMVaNM+^{>E!G@ct*$|ePXS#-2A)G z#)mE(|FUxYGZ)_J!oPLlCtdhYE?jis4_r9b1GhgUupiK$=UsT&g`aZa_gy&F7Ps@7 zeHGA-+fM@l7>)SPc(Fb3OZHW0)Sq( z*qY%|L7PuXx^_(`(o9lM5^1_vBvNW2o7HlFYbZd6pZ8c}H%{lw?Afe6U^0Dur%^sNU!Outg?!nLJ>j3=7Ww+kW5&gdcBvh@d zA=q<%6lC|{@#EMu2zY)Yp9i{+E81%#|9!x{@)yM>0fXlW^M_o{=eXzDpx0+B?%Bb? lyZnp?AF;;V0YrN2`dPw_Yc$3hdx{so&-Q=b#YM4^{~wTS>mvXF literal 0 HcmV?d00001 diff --git a/bakcup/obj/binaryTree.o b/bakcup/obj/binaryTree.o new file mode 100644 index 0000000000000000000000000000000000000000..e26ee707fa841fdb9e6fa145c8ae5d8142534ec2 GIT binary patch literal 2888 zcmbtV&1(}u6rWA1jkRBj2Sw4~K`iK!N(Hqdsb$+mqb;@pK_za|tr2ZnHXHi^RUsfQ z+k?mU;Kjc}JXv~3dr*Ri^w5I{LajYS?4d|8zBid^rqkV0@R8Yh@Ap3Ez1ht(E!GuK z6v9a%S4dUjC?TOxm5)+3N*YK#`Q3E-p7YXL7^It-CkYU2WqX+BhGb!ZI=o zbG~+%%-b&FOfEUOMW^^u`|QRSU2Vzv!s6+UwywLl2>b>M(SQO>RfZ!xpZrX0wF(xZ z^#Mpl0Ul-31C&^1L0iRgeoinqH@>Q;KIyaHf_i=>q$@?5j0f-C!OB0IS4@^Z59wWP zwOw0knwlt=%LT23<@}g|$L2vou2#}hMcpatvtI*P6K?tCL%K3wX#_p_z^)wp%hcVS z5^WY-f`Uu!+G5kx9a=E$-;YyJHZQ&ocv{gDR*}#EY^Zk{W!}HE-3Nfa5qke-W>-!q z#r#*LrRZpD`N=h6U)){}pRr#_g9RA<&kNff{m&uJB@g4|-CFruE{o&-2r`W;T+M|! z(%sp4DSSGf%w_Cc_@dgTM$We8sMPxOTttnusjV#)9FK}r1FIR<9$4Ks;{@*fd&GjU zkPcNgqD`j0Hh^V`aIFO(IZbeNRFd6p` z)&wgNm{QvCg4d8=WeKKY(DO@#XW^&W>J_A?--@9WBzw1m6tDHc@xZpZiYfaBa`x(e4Sxb-k&r^yIzAQH>S3=qrAnkX?P z)N&FQ65h=^SR3&9K)Qw?kc?XunBon))10%+$A)T~V>VF- z4BH@TGMgo8YItbK%m9`dwoMh@{j*uyNIhcmgG^2xv4%%X%N{2xjbNq|gO)L5vI_oh z3xhkhR({i>fFa$JURgGViV~hjVPP+$utXYT0T&sFcLjYzOg_wZe6J9f(va6O!0hGx zX8^~TviWZPTfrA&Mqr7={V~2sJU`zrfs*s0-GW>YQ_8mZ-r(0vymM$;Wd30k1mgYU zP!br7Df^e0{}?x9yX=1taIg9GvQMne{BVBg%l-NMymF&U8iN8&vjgu3ejhB^A2H8X avHOz)y-0HZ4uI0jf11_*Sab$n_WuVBFfalD literal 0 HcmV?d00001 diff --git a/bakcup/obj/depthFirst.o b/bakcup/obj/depthFirst.o new file mode 100644 index 0000000000000000000000000000000000000000..e98d45b834561f0698bf2deedb38c327dd54ee72 GIT binary patch literal 3736 zcmc&$UuauZ7(X|+?W(rBRfbF^BQI)&?b^;Mu85@TZhO(X72Du+jF2WbrmRg%a^qSd zZg9=;a>>|>P#**-iXcAdi+`X(x(yQ{4?(N;p^PF5Y2AavhZRxk_nmuAa(a_gyFK{9 z>G{s@e1CrTJKs6!1#NiHCrN~hM4ltH6-Nmx<&kdpYc_lHz#Il~f+aojoxb$5tV?Cx zX?L`u9x3Z~SzlW7Aw;KQtPp6C$nJa!f%YwsiIfHr{DVcah7d7^|C(ioXD=(+Nz_ifIgO8qo7R{M1rfRTT^Ap z%9P24d_h}=IAnbZf;-x>>z~al+4lgoG9{v1UVyFo3RoNMI~HB}BG3}UK#@Cgj}_n= zD4)N$=xC+f?3V5X^KiQMH}reg6_KsADJj_npo=7(K!;V4j%h_Dw*h6V=Ur`-c|A8G z)%8l1_9r`gH*PZ@=UmLqNG|6RYk~DM5U^TdYttukZl|0}O77{ptkzZOUmLti`ZlY= zZtjLyXU4f&=Z_$sz*$zZ@6fg=LR&by%w<*f=~9tVO^@twGIh0eUEvyw^<_Q5>uYJt z(9+AYa`~yh|KEFi1wL&vsz2#ISY|72*>A6rp@D%ue|K;^oiNk>W9m`0=WuVDu6o}* z(xdhqReK+Iaj0wyj4l|hFosSB2{e2jF}(FC``n30Z@fgL*)Hio$DZ~p&^&&?A7*+wr}yd_dqy>jT(BFz`IQ@&o{l@MoLg z{eWZq5(`9Y3;M|>_Gg(r=fUU6CidwjIEflFW_)lWnKIRgupptK;Zw)^heM|Z2S>HB z&{+TRVJ$=w#`)p!_*`-#Va7=^oQMi8p(IHfDZ{K8)MAgur_Ylabc0(Ww{TKuUX)$VaeS-e2;k+;79=ycXL`}_2na~qz%1pX*oNGyAGOU`$ ztVz^p*bEbOJe4A9WO{1KNC1|YHVqZtz{9ke*!s0ZTAfKw&lpK_j;J((5f8 zysOy{-gtCvo+tsf{+QK^Z+l<11F(T-65s}G{+&HVpE8Gg0Y{a;Q2UwPqYUToJ%h=H zCojjn`47Pc#=KMiUhu`3JupP!`7ypIJU^fNV3X^j-GknOvQ4k;^MK=PF7_On?q~jf zTnNJJ$DwghFs9f48RmbH8?xE!kMC}y^Lrl;3`BP)f=l$}{`~wJFUop-4MKd3TG^^Cq zY_)06kI+sFVP}1>S+xdIaK^`1Z{KoJ6`*cf#i|vnBsIJ5*-`Yi)MlgtoK0IfKA~2N zPdVe06KbV6bOV#T|LYMN6+A-d5p+C8z{5C;W6dUZtg0pMXg7ZnHKDHAgSJ}H5_Qe0 zYd3cS2+?k{rUWq}C3Vt0M1XWn=@Upz-GM03{fyCSY9m0qMzscyx# zZMCjlv(J@xEcKqPZo_z?yhA~Y4iJgm!?BsI3udWKE>~*m7Q`Xss5#sF39;W1O) zf~#&zl&+lmyVbe@B>2o?GpW5aPJbGVBlHTreT&S^%uI$yV~fR{Q4CMWV$Brr4Fp9cq+;=5N72b<}K2Y)Y4_B$T*Ro4STLr%Z9x?TVv`u-9l&a>Uk z66x3N#&9MQOsLyLGSCeIA`<+fZWF0$yK#*0q$^LV4PcKmoX@EyfIR_?Uf0mO?KznE z;gLP?$vyBl_P|LpU62#_#HQzoJ{LVdJr&i@&(6N9F6awW(@|9?>7`s!UyU0XvYKDY z8PWJ6$;Wd^qU!}Cp17bVG8go8d}*1C!a8VJJNT#3KP|_`5d=d#2#w=EAP9!|Ff@*z z#R33B{3tYze~uRnm^c1iw)I|I!h-hkSJ~Ek{nuQ$1U$ZO7=wV}@+<{9SLm~Y^L-_9 z;bPVRndE|zclrz;<&BF(rV&yZJ)MtdQ!Io3*M)(Ol6y~t0vOsQ&kMFa&P#ZnfQDKs(A@U&W6o@w zfmjpB`XM@$^N|F9&ye8jwa2M}p6$9bH%%&RrtpMHFW<-hFW;?T?g7ck^Xr~m)} literal 0 HcmV?d00001 diff --git a/bakcup/obj/dijkstra.o b/bakcup/obj/dijkstra.o new file mode 100644 index 0000000000000000000000000000000000000000..d814ac3dd52588ff7b016eb9b4cd45b1a2245373 GIT binary patch literal 5152 zcmbtXU2GIp6u#T7utH%ML+)iM8Lh&_Wzmp?C^Mj8?OD0!CFWej)AFI6GJ|t8s&?w$iLkXcy+fTBxMi zj(ti*>nmwiiQp!{e7ZEHL>#?I+)~l3pEPTVU;Ou=12{XIS?ZNKKxwwray=5U)T=V0 z*`pPE_Z2&N)i%L8yUQZaItsCs)^xLj7b>B#qB&NtMq+h*%Pp*Ts{*%L=8TmrS-You zEwzX%Y-MeyI%95h)*Cw2lDUf3MRDDq?=NAjFgneQC&8lG%udc|eLrd!es`T`t0jNO zwII0)qcbe}o<++>@xosb$NvE;qUYJbnPPP8**lW9l?Vx2D@nL6Tjp$adOQ&#bLOm= zti7MHSx z0xnacQ4Ny~PPEESTu>)+T;K>diC5Kld0-}ur*K&B-r95d8y6UsMdf1jJU%(Th@2-V z5gwG8==hn1J?qn`f{TTszG$@u6-%WSl!{v{D4dGZTPw98(3|{=*VS13zjQpsJZ&yV-C+K-l*S54d>R zdZ{q?PCbTQn0w0)U)l(Ae*W3ia295FH(&t53=dpS_{3W++0T7W7~%t5?76QA+ekm@ z)0K7(JwcNn4ms#K=<@NH(7G#tKN)}{rhfV}0r=?v`~$*a&zA@&5zhgdKcb(X{?7vN zZvyaA0RBq={#yXf`Uj64&l|aPypQ!|hO_CM&Wy}{BR4p5gr$0V_wL-$o7&smyTEbYG?eKBql6~R{80~dAd~eV2||QL zsho3FZ~Cx@Ygb+!&KjpYXm?K6*}&jPe=3_c=ql65dpNp=^mL9KLDcI^=oh>i{=MnY zb1se^vVwjB&$>AHmr1zk;^2=;_?U}>f4PL8b8+w^4}^YvL4km;qMyLmN%(3Be>4E! z9)RzW@OvaZ$0QuJDDHh(!tsxq!0~|zf}Qu#Pv9R)`27<8sf4eU@XuXb_+NCGFC_kT z68|*`e?Y>EP(bAM=M4#${rLhIefZBwxXk|#UMxQRkGL%kVlw|}w}pD``C7td{#Ga_ zg1N5Ae6R3v9vA)bkOvq2?oAIa`VNcdPYoMXL2)W_XFe)cIejP{H}sPRi}$CEG>ae3 z=UF_LaW>QqhV>CT8_5`YoZhWl@cM#MnjyZJ#uQ4_u6Ivcf#dxSdVDClAO0S{v%(f5K; z!mxDHvxYuKE3n?Fe21%3&Iu?N_ald7^4{M`hrrrpCR+dM+7J6=67pi+Nrz%B^F{n$ z`3=1LNC+wKwO`1$%1UYNb?Y(0aKBf+&AoqO5qV^xU;HnjNfRC7qtlzAQrs`%?{_yu titha)fAC#{_kmX)Y~I)t#54#HU3aG1==C+?>nGoamj)4iCD)Nx{y!IA9i{*P literal 0 HcmV?d00001 diff --git a/bakcup/obj/eller.o b/bakcup/obj/eller.o new file mode 100644 index 0000000000000000000000000000000000000000..3dc00fa727bf6399e9f6739e71feec64a822ab8a GIT binary patch literal 6592 zcmcgxU2I&%6`t$eBuneCOJXV{P-Ru5a-?RlX@u&Ow%(+hjM1eS67!>CHk-{&jr`m7 zu1Km<9IbEb(e)NT)RK`3;)N=*_u4PS&HXioK~yow_sL36p@a;6ZKd79n=NE3sU@F> zzy3u#WgpVqClU7i4VGPY9$t3hH~xq+>`$z?fQ@&~`^w>D9&)iKVvon#V}}mXlb=wK zVUrJ*%Vl=D*&Jo|_`l0#XAH$0o2$&qHNe=Dh;kFo zBudcK+cdXez{p|IYh@Q=lel0QG4uD@qFIzeol=F__1G%f4NysuR`z!69JWn|kD5*% zM@@FIHGF#3WCf^-G+$eT&83g1@fXT2;{42x2xE7x7z2<9FeE`RhhnBPhGHhWWIAV2 z#B?T6M9i@a)s&cHMw?@nriwItdYb0z_=YATuuQ%sqx2@Wd93Kt=d`O7p{zuAkZZ6# z_5s~_p0X>n`9fwJM1g=P&5hi<90rxEiy*k83{AT8LZxXJGTSSi+(L*Nb2Jx%@IX}v z(5ZzQIyF}VyX%KFiy+a|wDj(Az_7>cYY;;4?lM#`6~qF;IRP$c;QIS1z<#Fb$@$8L z-lgn)+WemPhNe%>iygfOTC#0l%0$FI*Vs>dZ~_;~sSaEmc5K0}63zV$*wsEtQzgpA zN@5FFDqBFXAix;~j^9L>{$JY~FWM$V1^0IKnR7vHiv{Y$3(gphvIuqBu|G`NELDfi zi4Tflnz~dBj-m+=8LwbYp6k|*=J*tb!>jLd$Nl^_(t&KAvUkyU!i}#AH=Yq5n@}F( zzI|1IrxfVv#&a6mmuOeD8$YHyFH`o#|9~B*sKZl_a?XlZ7hAtVNYSRs$@hVez;D>E z^4lplmg73$H58RzJHKLR@duDH)vOMwc%4qo2dGh^PDp5ShnD!E1QgGvG2^s^?81o- z9#Cjgd{}&9L)P+j2H2T!2-^#WkRjqe*pM;4G-kKKj!pIvo%(x?@D>8#EvIf2%wlGt zsf*5-L?Q9bLb4V9V|ByTD#6h_#TA0jr94AMqEoAU8y-0g#1gDzeE4b?KkY9qO`YU(eIl)n8AA&LA>3mxm<{8Iz*1|gRB&^K1N+gepxRf{eQgVC}^1_G~;aotSC=@}v zI3d~;%Y=KanRmnaN4cn=pbr_uS|A^}$v`1){+f*rpMt_^YlB2rt$Yob(>xU(x>O@m zV{Xo{3)wrxz0B8#IUsER9t75!B_wCTgI+zw%&}rijj>T>Sf2>d%}nmOMLaCR=|%g8 zuop~oi=V>J!)&ed@3@6)wO9UZTclI+d?GoD4Me4p8~e z)VN+Dv9hO;SVF*@HMdk*md`R^rpvgDpt!iId=5w2;kLxh@5@&=1_)UU+{U#Zl+>MS64>|k_@#o?iEGf3s0>vscxw$0dcO<|V*dm@; zqU%Pvtew#qT$#cF`WeNbFW#XJ1!NEeLSC*DE;<5{EIrXNqo%Ytt&r{Jssq$2hvn0|0p8`+RWI2S4b8clhAPeDFRWJmZ7s zeDJ&vPOR>3D;-UVTKpzNb+EJVIg&VFKC(AvCLYp3%dygY;;6gU1m0dssSw3Yl;Nnw<~UBjhHZhzJX52CZ6xcBud4cF}$xHu2_*EJk-q4LjJ4Zl;v-`8+Ft4h8e+F0;C z7avtxWJBTVJRf%9ZL&|I11EYiK*8uhCN1ht)k<64$!Nwpo*~hr$xM<&j|>cuXsWNL z$La;Fw=ZKwA;<6Hq?G-i^k$>|>Arp|ojF0G+=A7aIF?TKSZc=qs;&oZ%+ZoI6J8reY_vM;x~hb1_~7w&xNR~^i}-4=0=qeCI=`Da$%ST@Gf=hBj%1BK%`Of Z=N0T|#qDdH#!EjU|KEZ+T`z9^{{U8qDa!x= literal 0 HcmV?d00001 diff --git a/bakcup/obj/labyrith.o b/bakcup/obj/labyrith.o new file mode 100644 index 0000000000000000000000000000000000000000..a3be9b200c1d8cf92f2f0ac9125f7320bfe9be66 GIT binary patch literal 7240 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 WQ+rF{5ES#$k1+?Wnx@;3_5Ta!(3)TX literal 0 HcmV?d00001 diff --git a/bakcup/obj/main.o b/bakcup/obj/main.o new file mode 100644 index 0000000000000000000000000000000000000000..a76dc6845b2e9cfdfba6ad1ff4be93fc4afb0930 GIT binary patch literal 1992 zcmb`HL2DCH5P)Zs+Ez{4C>|;m2?$cbK9X8Qi%8nANswTnCg4TGCRv-b*-hBpNaH~d zf*5k~XL$4?cvJ8Y`~%)S2t9a+*n@~rXLjFfUbed+;=t_8eDBS?x9{!jGqsqDC<+Ks z;5LjSK>=P)js1-4W*`nR_%VO+SGmytT6q2~@t*iTJ^Dk}4As#*Mnm<0%%FTQP)GgG ze6Y}0e-;L)BK`~i9Tord5%SsWT5_pe?V3(Ed6TWO)N;D(M(L+3DVADg=_?+m1QObQ z0`&xH{%#o}03V1&QAy5u29zgTpzI}-#n{a3D?Eq`$Vo}M^iby#FCy9abfkqd2m}kA z;S_v73>u9Fo-pl2>}E16>h6A$Q51#gdl>9+p#o?OsA+-!P0G=oF0J&hDQ6bK8|r|JUdV58#|5q`_Pl~5|2szy2R;> z#r&Ma=On%*acV9x|DnX`J_O&9_!)^OImdpWo)`0MHdk(O= z=4imGwhgS-HVoZFX0{!jVUI1_j#k^{@wVAz9jo2ZEvE;}t)Mq5k1P$(`hQ3gi%`$` zJ0gROM0~$qks|>0v_jyac=I|6+T1Rx!0_T@G_jmAHKJGVELzb%;P|bhM zPh&3COrgpm)~EWii1meC!$IN8^S;P|q6S?*0KR_OIf8y6E?uqV?az(!2L2J`e8NU7-ZmE|~2ILd--yI?t@fWI7APFyb UM5rf&@)zi(P+FcjdiwMK0BH!)zyJUM literal 0 HcmV?d00001 diff --git a/bakcup/obj/prim.o b/bakcup/obj/prim.o new file mode 100644 index 0000000000000000000000000000000000000000..5b3503f077d7cdfe926ea21d010a7b76a36be835 GIT binary patch literal 4472 zcmd5hw@Wn5= z_k8DfzJKRC-*yR_}nZ zgPOjLn?RWw%1qM~HLg+Pl6e|MOr42e<<3FiWL}xTIP%ID=r6Ba@UY<W}{YTZVLYO{VS zU89;G_6oz4mrl=m==3!Y?CdPd@2B^y3>6GzTmV+G4CS1uj2lYERL&VnI{wbVJM@f&ODEqt@?ymG8oVC@F-5T^JqcRCUGFg#`8>#-HOZ} zI3qVcfi@R5(7Zks&`-dE)r1LHg&jIBj>UQ;@Kw;)35GKAL#cP>;djXjmW4PAA=^XL z=A?jr3YN;7a2muaV=a}9dlQyI)gG)}Q4`V(Tvnd4ID-{&dPJP|7JRb8(^5L56zDIo z@ds?vHPG^W;%!x)Pj5ii0L1n?I=md?R_pQD)E&!LbtX|`mC0+?d#qNQ#F8cf{lGtP zi4A9gd+zUI@&E9vX8&0SFj$Yx%kg-hYp6?LhpnkZI{TNojbSJ zZwj{$B-MfXZSq#RadXoEn>8KX(kM4>m75wY91er{;K47A74YnNJxrjNrVztR0%@H! z5b1+Ah%{Iyt*=?-KMA$90dRbfHsMQIUH7qPXYI-e2*4EAUP2tmZT)$`53*H4?x2Fu zZ#m&T?#rzhU8$||{_3}kaXGgELV-QpDY~tBUB5hWZ(?`lT3(ioatvo)va%9n_^K*6 zZm5#HEX(CMO0KcR$#Ml)Eywq9ah4_CO23K&Vn`{T&)#Ym)IjmEkov99h&XY_Cngg~Cg7ZBF&qwvf_LnFP0AdnM3W5Eo^ zTnqV+u%LiY9{-{U{8SZu-iG7Xw~+T^LjgJMyjKOkjD^7E?RM5avVdcrg?-tEKW@Y8 zEphB)_V6hQI&e`phaC7mJ|}YjP(p>=%l&G~8oLCSiuXiiH9n{kxg)AZiQL}bPvlr{ zA`wplmh4sIGTbGb*(ve)yU78$FV))@PpLyhW)|XIki+(^wDMcofb~4FZM~ z;`y>>maO1$Tn`VPRS+IK4c1sQ_B{?P))xBV$3>p7mdUdmcit=`4!>O7*6|jC_aWMR zSp6o@#kd;bv6JwR_U**WwiL&9SQMCD?)(zt$3DZ`5bMrP6I{RE4gxRoC*XEq(7#i^ z!1c32kdIFNHo)D^FOAI&M6H3HALpg X;KWAGTw@Qr>Cf=^du+PMI`#hr^>^7j literal 0 HcmV?d00001 diff --git a/bakcup/obj/priorityQueuePP.o b/bakcup/obj/priorityQueuePP.o new file mode 100644 index 0000000000000000000000000000000000000000..6c8d99e62f8c4e6a32e714be7958fe908d8f5d3c GIT binary patch literal 3696 zcmbtWL2MgE6rHt8Ytp0%ZGoazW$6J0iCPJYgp3Mu6Kyg`cCt;g6r@JRF&k`}#Fo8Q z6GT!ZQ>4`@5L6*J6ok0Y6O=omPI{=}fXoHuz#)eqSu}@K_z;1m@c-E`SbtZv9D>d;eetLAqshk?5zY!$acrxJj$j~a)fk|Ke|uKHW$!!fpP;V!hS zE9h7Tb{X)Ch<~Lex+p}q4uo|l8oFNohfsh-sMAAjqXty>7-+PtqyP2q+1W*kTz_2U z#^Pf@=vv*;wr#Be4(d+4LG2%<*f47>1H>VdazY`7#T~m?FD=$d_j@0~#x5@eUP?8^ zUR(YBNu~PpPMeIm*`!V%Q2pv{heTGF&UoC|Yfik5JJ>&o6#5uU-OTWPr8UPY1YEO= zo4{hZ69GoF&Fc2mzc@tL>yZ}`=2x_TX>;l$b5qy!mQ)0(|cO5AkV#>U#C;QQjUW%6yMO4 z9|9cx2zyq0z%K2>zq}8g|Tvk)Su5&yAjg7*3 z0mcvELH;M)KkG3hXu}IoX<}%X@y6)p;bEI%JnFGyqW}X7g&zS&@E06LK zztv878oRCx?1O*6aZCe#>wM$$@>@Km8d z!uhPbNM&bd%{kD`Wi2xdzX4|pRx)*kuiu<2hI9FB&dgg2V1u5_bYeQ6oHcnQ|8G#i z982rHk)nX1oWVj#!rP#UoP-%tqD{n|r1_PY<_3oW#;Ld|PjEioZ;12qbCi%N&%Q$8 z-TzropwItm-w(FvQ|>KTHurxD7m|4QkAM!bK8b_V5|1C_lSSBzaS)VZF7v+mm**b` zBm7nJ#($gJtFlv=i~I}tEtuf`Ui&Jy-w{MUdhM|bks9TCF;w|a-z^Sc{SgxOqW&>pI%^GDbj_ z6ii;4DKRne12KFcF^2dj!~|3V?NA4a8iqmnz=vU`8PvoX7hKHZJmqmW{uJ<<(A_55}uDk2xw`Ktx=`Dt7XUC znlb|GDa~>*csQWo%;IjVh68gH$Xh;Hx>?JdP92>l)yL20&#BpGOp|nITI;%@Wq$%+ zut(}%OV_2<>C~iRjb?wVRc6L!_->}OH0&3BUBKAPjUCSz+tEL0GL>xhZmn{)pi(eO z(mTM{H7$Dwd|l03qVZtLBiVbk%Js1s3y&>^OK~_BilqHjCo<*}TKWOpk7i{*Uk#%j z*WoRQ+2Jor{W>7lzXmB@F!Y4A?2Tgg$vni&EjmqO{BjFg^)t z7C&o)I#E5m6e@u+z+PINP%^2E(lBDYgs7IL`GOJhHKE+VjHO0gMOmXvb3(bVb=}ue zUn^Sn7YK7n!ctQTK=_lmaITUnVKys5s>D6sf;); zCX|$_kF&~XvgT9>sVIj{j9;MY_cBE>vs)bJnh>x2^}?Q5a=mCX$W`(krb%hx0}le^ zuhFFIy3)yBu60zM#bD>w*?NH*dxRDO6;;$iSSPxXQfIL>;?-(UXOE0tt^|FWpKDhF z?E!Cln^)Zt2=4L*I$GL0T7tX6J40$ntt7>3Z%d~wS4o2HoxzTlwq|czd(gXGZE9&# zw}a8<#>P$FwV{1xpJ93%d>edq>*`Iqs(*cbov&_#ul{Kp#}g1T4;~LZ7{cbZ5P^?P z1~E50NGt4tD2F?Ua>%2ss#;KS650VaGJKHs;7eWNdBfGXc)lwL5;ku$;y@qbE6+cZ z=kG=w=tq3z`QPRFM-T`46kmD%**yOg;y`}!#TVyy7xY)7U!YC+;{1aJ{$|EsEAqny{%*#9MC9)*@Q*Nlo5**m zQ~=L+it&ew_{VJnh&d3d%pRHF zlZ6f_+Mi#7F9T$muzy;UfISHh*0)TUGbem2;An^I)7k|r$nYw>96+>YV2r|p@|7%f zw3Y!o#_*f$BGDQI>}`hMVe+)L0XqYa(|*pD!OxY!&jXJ8c?W+r0{NMrZ(;6a|0dv6 zo}G)Zb1NB7OQmpa>)3=GOLYTU*2JO--F@FdW>vtyK+^SfsZ% z-X-Y=%w&%Qb?C|HVO;{7qKA6)NWX-34wOKFct1%R`}IVEbPvEjb<&;CWosIkigpi@ zgzmJb#$G*=kUTY&8tLpwMEeeejd-{_YDnTONj27Q3`%Ga_EsD|2wWfNnnqU-xI}u8 zzU}V;{v9$qXVV7)zC^$;mciYSKO`)VYIwMv&jcLv%kf(RF3Qg_9LpH*HkV({>KX?u z9gf#99Q`gA@MZxQ{l)|wzj55oTLO+>e~y2_?lIaI?R+EPqWp{Oe&8V5Hw7GH&h4KQ za52ue1^gjFJ}2O!{Xfg#wd|fDTeSZQ!|~W+oD%|$(}&?f8W8M=asEh<7wwD)I8N77 zD};=ev9pr3cHHNq@bLI}nI7(wrHCSa3Fm!#uY~jdJS5?~51*EB-aj)E&inbeg!AtL zv@}Y5pYO1IcqN?oRqTUET%PyUy%Ns*>X3xIeIAV2@-1}_* zxIdA&J|DLMlg~xD@BiibJ3tA4?aBMU#q_|3Y}UKF`0CZ`AvQ30`L#!*asEjN Q1^oB`8TOEWOW`2@080O*CIA2c literal 0 HcmV?d00001 diff --git a/bakcup/obj/queue.o b/bakcup/obj/queue.o new file mode 100644 index 0000000000000000000000000000000000000000..d90fd61e607911345a7431d5a5ccc237b8b25e2e GIT binary patch literal 3544 zcmbVOO>7%Q6duQ=4W&&?#7`gyRtTXY=r%#U6ajLRtg}I><0LjJQY+)6o1_rOX1z;O zAW$i!U|A6n0;vZM9D3o#5fCB<4iOxX;E15g0i;Oj!H7$QD$M)l$DT}Vgm}`-y!qbG zym{~K*l#&wiH=BwDT=UXS#zgQ#?BsY@^Q|_SrZ*sM_ ztHJ$zU&-uBwQVv1AKU2@l6XuYw2+|`g0HZ(R0K>pw%#Hht{v}nSF7Q}Zsj(9bouKq z?k46dq|IG>1{jZHCn?YBL^^g(h+V3eR!UBs(9O@FT>nWRJZl@sv$*Zb@-7R%Zvt(? zY2I3osGHpUTSOIpS|dOajyPA`5#ee3W-5`PItPTV8^kVXqt7+$I4BMcS9pGr?&GD4Bf^xYFfB-Ac}DI+1Ab(zzBnH7+^l(eL#ku1{T%9-m52jwVN}Fq@5rIfb?UGO2*&^=F*#kas~tl}4|X`DA!JVjCtAnUkiXNA zp94AV;n3{S;^#HznCKtV;1~h?K{W&?xJ^X#4Dq}-XgwwIx_tC`O$kd#{06Nc z-Yc|D&}ilVY#Th=2A?Aw_sYw2d9M*xY@;7a{a*S|K)knTy+Q+i&Pkm26k!#Ke=c#} zON6mkLND~}8Mf$MngGkPBV*%(r^mA6iNutX&ZbWfjyYMD&n+wzW`uSsEX@mUwB+QA z!DR{i7Z(Fo3NCoQ&t@uEZ&79 zwBD)GQ zERY$`bqz;6I0N*F=0}g`2Mx#DsN%oT249nP$Gvp@A2s|Q&CjnIuIpQ*1AidrkTz!XC16O^&W#Fps)f1uORDI9v(&c=Ro2E7J#X7Gz-&@Gp zfwvSe`$8_rF?+gHVzyrpo0&pB?@@!>i-o|m={M?lDag&dEcbJZpfqv7AL3`N-T!yKS25KLtq0_taslFx+?jRvp^-}Xc zskDDo;^r^JBPKw4AoKhu2!l^k{lD4|NT0?vnX*TGI+^F=T?f{$D-r*k3<&Y*r0mr? zNJ7Qydas%nl0s8=l5nKjjDJbmThdM~D*tN#5;5>;+Fz6Qy~cs2J-V<}{Vn;^TO~ON z^#`QvRsCC?4gF8ylqfC(!&{BN?4~_@wn|k^HuQ%i*U7jJe~Vk$Z^`%r-I#dO{vW{H BU!(v4 literal 0 HcmV?d00001 diff --git a/bakcup/obj/water.o b/bakcup/obj/water.o new file mode 100644 index 0000000000000000000000000000000000000000..3bc6221227405c3eced187981e6a557517ef6427 GIT binary patch literal 1368 zcmbtT%}N7749<3I{i|BVgP=$~sbGgzDyRo3lv)p>AQZe5+19lMZ7aJ|tcpJ;!JCiZ zqX=Gn1Yf|r;zhh@vOCjG#}+{YnIvE4n`CyfSDDTAfMI|X1Jrj}I+rWdtGpgvVM!K`CF)+3xLl00c#-#$>p+?+zQBLY$OjgqF;3{0>IHND%kV-%SX`U!e?Zx@`tM7#83IHvUJ-JQ0aSlo74(YF9m z!ceI5w(gmGTH#g!n9CjCmZit-1_!opaSK?%b%7OYm5N>)+$tW5xKypP zW2bg(JNy)wV;@<}F7F*UR>k&8|7)2moO=Pb>F!fD89ZogE^Y2wztRl8kHpKt*u4>XY!b$ zGj;yGpeze3jn3c21Wj*BZV>iaG&&(-nrG@$@+ID>Hc_5wL3#BJ44|bmbUtDF+Y#kS V)c +#include +#include "../include/labyrinth.h" +#include "../include/bfs.h" +#include "../include/queue.h" +#include "../include/coor.h" + +void bfs(Labyrinth* labyrinth){ + int i, j; + int arr[4] = {0, 1, 2, 3}, tmp, tp; + coor* cor = (coor*)malloc(sizeof(coor)); + coor* test; + cor->x = labyrinth->start.x; + cor->y = labyrinth->start.y; + queue(q); + queuePush(q, cor); + + while(!queueIsEmpty(q)){ + test = (coor*)q->front->element; + i = test->x; + j = test->y; + queuePop(q); + + if(i==labyrinth->end.x && j==labyrinth->end.y){ + queueFree(q); + find_path(labyrinth); + return; + } + + if(i!=labyrinth->start.x || j!=labyrinth->start.y) + labyrinth->at[i][j].color = GREEN; + + printLab(labyrinth); + + labyrinth->at[i][j].visited = true; + + + for(int h=3; h>0; h--){ + tmp = rand()%h; + tp = arr[h]; + arr[h] = arr[tmp]; + arr[tmp] = tp; + } + + // goes in the direction if possible + for(int h=0; h<4; h++){ + coor* cor2 = (coor*)malloc(sizeof(coor)); + if(arr[h]==0){ + if(i>0 && labyrinth->at[i-1][j].south && !labyrinth->at[i-1][j].visited){ + if(i-1!=labyrinth->end.x && j!=labyrinth->end.y) + labyrinth->at[i-1][j].color = ORANGE; + labyrinth->at[i-1][j].direction = UP; + cor2->x = i-1; + cor2->y = j; + queuePush(q, cor2); + } + }else if(arr[h]==1){ + if(jy_size-1 && labyrinth->at[i][j].east && !labyrinth->at[i][j+1].visited){ + if(i!=labyrinth->end.x && j+1!=labyrinth->end.y) + labyrinth->at[i][j+1].color = ORANGE; + labyrinth->at[i][j+1].direction = RIGHT; + cor2->x = i; + cor2->y = j+1; + queuePush(q, cor2); + } + }else if(arr[h]==2){ + if(iy_size-1 && labyrinth->at[i][j].south && !labyrinth->at[i+1][j].visited){ + if(i+1!=labyrinth->end.x && j!=labyrinth->end.y) + labyrinth->at[i+1][j].color = ORANGE; + labyrinth->at[i+1][j].direction = DOWN; + cor2->x = i+1; + cor2->y = j; + queuePush(q, cor2); + } + }else if(arr[h]==3){ + if(j>0 && labyrinth->at[i][j-1].east && !labyrinth->at[i][j-1].visited){ + if(i!=labyrinth->end.x && j-1!=labyrinth->end.y) + labyrinth->at[i][j-1].color = ORANGE; + labyrinth->at[i][j-1].direction = LEFT; + cor2->x = i; + cor2->y = j-1; + queuePush(q, cor2); + } + } + } + } +} \ No newline at end of file diff --git a/bakcup/src/binaryTree.c b/bakcup/src/binaryTree.c new file mode 100644 index 0000000..ce352cf --- /dev/null +++ b/bakcup/src/binaryTree.c @@ -0,0 +1,70 @@ +#include +#include +#include +#include "../include/binaryTree.h" +#include "../include/labyrinth.h" + +Labyrinth* binaryTree_r(int n, int m, bool show); + +Labyrinth* binaryTree(int n, int m){ + return binaryTree_r(n, m, false); +} + +Labyrinth* binaryTreeShow(int n, int m){ + return binaryTree_r(n, m, true); +} + +// creates a labyrinth using the binaryTree algorithm +Labyrinth* binaryTree_r(int n, int m, bool show){ + int i, j, tmp; + Labyrinth* labyrinth = newLabyrinth(n, m); + + labyrinth->at[0][0].east = 1; + labyrinth->at[0][0].south = 1; + if(show){ + labyrinth->at[0][0].color = ORANGE; + printLab(labyrinth); + labyrinth->at[0][0].color = WHITE; + } + + for(i=1; iat[i-1][0].south = 1; + + if(show){ + labyrinth->at[i-1][0].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i-1][0].color = WHITE; + } + } + + for(j=1; jat[0][j-1].east = 1; + + if(show){ + labyrinth->at[0][j-1].color = ORANGE; + printLab(labyrinth); + labyrinth->at[0][j-1].color = WHITE; + } + + } + + for(i=1; iat[i][j].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][j].color = WHITE; + } + + tmp = rand()%2; + if(tmp) + labyrinth->at[i-1][j].south = 1; + else + labyrinth->at[i][j-1].east = 1; + } + } + + resetLabyrinth(labyrinth); + + return labyrinth; +} \ No newline at end of file diff --git a/bakcup/src/depthFirst.c b/bakcup/src/depthFirst.c new file mode 100644 index 0000000..5080fdb --- /dev/null +++ b/bakcup/src/depthFirst.c @@ -0,0 +1,77 @@ +#include +#include +#include +#include "../include/depthFirst.h" + +void depthFirst_r(int i, int j, Labyrinth* labyrinth, bool show); + +// dfs search algorithm +Labyrinth* depthFirst(int n, int m){ + Labyrinth* labyrinth = newLabyrinth(n, m); + + depthFirst_r(rand()%n, rand()%m, labyrinth, false); + + resetLabyrinth(labyrinth); + + return labyrinth; +} + +Labyrinth* depthFirstShow(int n, int m){ + Labyrinth* labyrinth = newLabyrinth(n, m); + + depthFirst_r(rand()%n, rand()%m, labyrinth, true); + + resetLabyrinth(labyrinth); + + return labyrinth; +} + +// ricursive function used by depthFirst +void depthFirst_r(int i, int j, Labyrinth* labyrinth, bool show){ + labyrinth->at[i][j].visited = 1; + labyrinth->at[i][j].dp = -1; + + if(show){ + labyrinth->at[i][j].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][j].color = WHITE; + } + + int arr[4] = {0, 1, 2, 3}, tmp, tp; + for(int h=3; h>0; h--){ + tmp = rand()%h; + tp = arr[h]; + arr[h] = arr[tmp]; + arr[tmp] = tp; + } + + for(int h=0; h<4; h++){ + if(arr[h]==0){ + if(i>0 && !labyrinth->at[i-1][j].visited){ + labyrinth->at[i-1][j].south = 1; + depthFirst_r(i-1, j, labyrinth, show); + } + }else if(arr[h]==1){ + if(jy_size-1 && !labyrinth->at[i][j+1].visited){ + labyrinth->at[i][j].east = 1; + depthFirst_r(i, j+1, labyrinth, show); + } + }else if(arr[h]==2){ + if(ix_size-1 && !labyrinth->at[i+1][j].visited){ + labyrinth->at[i][j].south = 1; + depthFirst_r(i+1, j, labyrinth, show); + } + }else if(arr[h]==3){ + if(j>0 && !labyrinth->at[i][j-1].visited){ + labyrinth->at[i][j-1].east = 1; + depthFirst_r(i, j-1, labyrinth, show); + } + } + } + + if(show){ + labyrinth->at[i][j].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][j].color = WHITE; + } +} \ No newline at end of file diff --git a/bakcup/src/dfs.c b/bakcup/src/dfs.c new file mode 100644 index 0000000..b0ad722 --- /dev/null +++ b/bakcup/src/dfs.c @@ -0,0 +1,67 @@ +#include +#include +#include "../include/labyrinth.h" +#include "../include/dfs.h" + +short dfs_r(Labyrinth* labyrinth, int i, int j); + +void dfs(Labyrinth* labyrinth){ + dfs_r(labyrinth, labyrinth->start.x, labyrinth->start.y); + find_path(labyrinth); +} + +short dfs_r(Labyrinth* labyrinth, int i, int j){ + if(i==labyrinth->end.x && j==labyrinth->end.y) + return 1; + + if(i!=labyrinth->start.x || j!=labyrinth->start.y) + labyrinth->at[i][j].color = GREEN; + + printLab(labyrinth); + + labyrinth->at[i][j].visited = 1; + + // randomly generates order of direction to try + int arr[4] = {0, 1, 2, 3}, tmp, tp; + for(int h=3; h>0; h--){ + tmp = rand()%h; + tp = arr[h]; + arr[h] = arr[tmp]; + arr[tmp] = tp; + } + + // goes in the direction if possible + for(int h=0; h<4; h++){ + if(arr[h]==0){ + if(i>0 && labyrinth->at[i-1][j].south && !labyrinth->at[i-1][j].visited){ + labyrinth->at[i-1][j].color = ORANGE; + labyrinth->at[i-1][j].direction = UP; + if(dfs_r(labyrinth, i-1, j)) + return 1; + } + }else if(arr[h]==1){ + if(jy_size-1 && labyrinth->at[i][j].east && !labyrinth->at[i][j+1].visited){ + labyrinth->at[i][j+1].color = ORANGE; + labyrinth->at[i][j+1].direction = RIGHT; + if(dfs_r(labyrinth, i, j+1)) + return 1; + } + }else if(arr[h]==2){ + if(iy_size-1 && labyrinth->at[i][j].south && !labyrinth->at[i+1][j].visited){ + labyrinth->at[i+1][j].color = ORANGE; + labyrinth->at[i+1][j].direction = DOWN; + if(dfs_r(labyrinth, i+1, j)) + return 1; + } + }else if(arr[h]==3){ + if(j>0 && labyrinth->at[i][j-1].east && !labyrinth->at[i][j-1].visited){ + labyrinth->at[i][j-1].color = ORANGE; + labyrinth->at[i][j-1].direction = LEFT; + if(dfs_r(labyrinth, i, j-1)) + return 1; + } + } + } + + return 0; +} \ No newline at end of file diff --git a/bakcup/src/dijkstra.c b/bakcup/src/dijkstra.c new file mode 100644 index 0000000..defb96f --- /dev/null +++ b/bakcup/src/dijkstra.c @@ -0,0 +1,117 @@ +#include +#include +#include +#include "../include/dijkstra.h" +#include "../include/priority_queue.h" + +typedef struct element{ + int dist; + int x; + int y; +} element; + +bool compare(element* e1, element* e2){ + return e1->dist > e2->dist; +} + +void toString(element* e){ + printf("(%d) %d %d\n", e->dist, e->x, e->y); +} + +void dijkstra_r(Labyrinth* labyrinth, int i, int j, int dist, priority_queue* queue); + +// dijkstra search algorithm +void dijkstra(Labyrinth* labyrinth){ + priority_queue(queue, compare); + queue->toString = toString; + + element* tmp = (element*)malloc(sizeof(element)); + tmp->dist = 0; + tmp->x = labyrinth->start.x; + tmp->y = labyrinth->start.y; + labyrinth->at[tmp->x][tmp->y].dp = 0; + priority_queuePush(queue, tmp); + + int a, b, c; + + while(!priority_queueIsEmpty(queue)){ + a = ((element*)priority_queueTop(queue))->dist; + b = ((element*)priority_queueTop(queue))->x; + c = ((element*)priority_queueTop(queue))->y; + + priority_queuePop(queue); + + dijkstra_r(labyrinth, b, c, a, queue); + printLab(labyrinth); + } + priority_queueFree(queue); + + find_path(labyrinth); + printf("test\n"); +} + +// ricursive function used by dijkstra +void dijkstra_r(Labyrinth* labyrinth, int i, int j, int dist, priority_queue* queue){ + + if(i==labyrinth->end.x && j==labyrinth->end.y){ + priority_queueClear(queue); + return; + } + + if(dist) + labyrinth->at[i][j].color = GREEN; + + // adds all four directions to the priority_queue + if(i>0 && labyrinth->at[i-1][j].south && labyrinth->at[i-1][j].dp<0){ + element* tmp = (element*)malloc(sizeof(element)); + tmp->dist = dist+1; + tmp->x = i-1; + tmp->y = j; + + priority_queuePush(queue, tmp); + + if(i-1!=labyrinth->end.x || j!=labyrinth->end.y) + labyrinth->at[i-1][j].color = ORANGE; + labyrinth->at[i-1][j].direction = UP; + labyrinth->at[i-1][j].dp = dist+1; + } + if(jy_size-1 && labyrinth->at[i][j].east && labyrinth->at[i][j+1].dp<0){ + element* tmp = (element*)malloc(sizeof(element)); + tmp->dist = dist+1; + tmp->x = i; + tmp->y = j+1; + + priority_queuePush(queue, tmp); + + if(i!=labyrinth->end.x || j+1!=labyrinth->end.y) + labyrinth->at[i][j+1].color = ORANGE; + labyrinth->at[i][j+1].direction = RIGHT; + labyrinth->at[i][j+1].dp = dist+1; + } + if(ix_size-1 && labyrinth->at[i][j].south && labyrinth->at[i+1][j].dp<0){ + element* tmp = (element*)malloc(sizeof(element)); + tmp->dist = dist+1; + tmp->x = i+1; + tmp->y = j; + + priority_queuePush(queue, tmp); + + if(i+1!=labyrinth->end.x || j!=labyrinth->end.y) + labyrinth->at[i+1][j].color = ORANGE; + labyrinth->at[i+1][j].direction = DOWN; + labyrinth->at[i+1][j].dp = dist+1; + } + if(j>0 && labyrinth->at[i][j-1].east && labyrinth->at[i][j-1].dp<0){ + element* tmp = (element*)malloc(sizeof(element)); + tmp->dist = dist+1; + tmp->x = i; + tmp->y = j-1; + + priority_queuePush(queue, tmp); + + if(i!=labyrinth->end.x || j-1!=labyrinth->end.y) + labyrinth->at[i][j-1].color = ORANGE; + labyrinth->at[i][j-1].direction = LEFT; + labyrinth->at[i][j-1].dp = dist+1; + } +} \ No newline at end of file diff --git a/bakcup/src/eller.c b/bakcup/src/eller.c new file mode 100644 index 0000000..bbc9e01 --- /dev/null +++ b/bakcup/src/eller.c @@ -0,0 +1,137 @@ +#include +#include +#include +#include "../include/eller.h" +#include "../include/queue.h" + +#define ELLER_COST 2 + +Labyrinth* eller_(int n, int m, bool show); + +Labyrinth* eller(int n, int m){ + return eller_(n, m, false); +} + +Labyrinth* ellerShow(int n, int m){ + return eller_(n, m, true); +} + +Labyrinth* eller_(int n, int m, bool show){ + int i, j, h, tmp, tp; + Labyrinth* labyrinth = newLabyrinth(n, m); + + int sets[m][m]; + int setSizes[m]; + + queue(freeSets); + + int arr[m]; + for(i=0; iat[i][j].dp < 0){ + int* tmp = (int*)freeSets->front->element; + labyrinth->at[i][j].dp = *tmp; + queuePop(freeSets); + } + + tmp = labyrinth->at[i][j].dp; + sets[tmp][setSizes[tmp]] = j; + setSizes[tmp]++; + } + + // randomizes order + for(j=m; j>0; j--){ + tmp = rand() % j; + tp = arr[tmp]; + arr[tmp] = arr[j-1]; + arr[j-1] = tp; + } + + // randomly merge cells + for(j=0; jat[i][tmp].dp != labyrinth->at[i][tmp+1].dp && (rand()%ELLER_COST || i==n-1)){ + labyrinth->at[i][tmp].east = 1; + + tp = labyrinth->at[i][tmp].dp; + tmp = labyrinth->at[i][tmp+1].dp; + for(h=0; hat[i][sets[tmp][h]].dp = tp; + } + setSizes[tmp] = 0; + + int* s = (int*)malloc(sizeof(int)); + *s = tmp; + queuePush(freeSets, s); + + if(show){ + labyrinth->at[i][tmp].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][tmp].color = WHITE; + } + } + } + + // randomly makes cells go down + for(j=0; j1; h--){ + tmp = rand()%h; + tp = sets[j][tmp]; + sets[j][tmp] = sets[j][h-1]; + + if(rand()%ELLER_COST){ + labyrinth->at[i][tp].south = 1; + labyrinth->at[i+1][tp].dp = labyrinth->at[i][tp].dp; + down[j] = 1; + + if(show){ + labyrinth->at[i][tp].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][tp].color = WHITE; + } + } + } + + // last cell + if(setSizes[j] && (!down[j] || rand()%ELLER_COST)){ + labyrinth->at[i][sets[j][0]].south = 1; + labyrinth->at[i+1][sets[j][0]].dp = labyrinth->at[i][sets[j][0]].dp; + + if(show){ + labyrinth->at[i][sets[j][0]].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][sets[j][0]].color = WHITE; + } + } + } + } + + resetLabyrinth(labyrinth); + queueFree(freeSets); + + return labyrinth; +} \ No newline at end of file diff --git a/bakcup/src/labyrith.c b/bakcup/src/labyrith.c new file mode 100644 index 0000000..1eb5a71 --- /dev/null +++ b/bakcup/src/labyrith.c @@ -0,0 +1,149 @@ +#include +#include +#include +#include "../include/labyrinth.h" + +void find_path_r(Labyrinth* labyrinth, int i, int j); + +Labyrinth* newLabyrinth(int n, int m){ + if(n<1 || m<1 || (n==1 && m==1)){ + printf("COGLIONE\n"); + exit(EXIT_FAILURE); + } + + Labyrinth* labyrinth = (Labyrinth* )malloc(sizeof(Labyrinth)); + labyrinth->x_size = n; + labyrinth->y_size = m; + + labyrinth->at = (Node** )malloc(n*sizeof(Node* )); + for(int i=0; iat[i] = (Node *)malloc(m*sizeof(Node)); + + for(int i=0; iat[i][j].dp = -1; + labyrinth->at[i][j].east = 0; + labyrinth->at[i][j].south = 0; + labyrinth->at[i][j].visited = 0; + } + } + + labyrinth->x_size = n; + labyrinth->y_size = m; + + labyrinth->start.x = rand()%n; + labyrinth->start.y = rand()%m; + + do{ + labyrinth->end.x = rand()%n; + labyrinth->end.y = rand()%m; + }while(labyrinth->start.x == labyrinth->end.x && labyrinth->start.y == labyrinth->end.y); + + return labyrinth; +} + +void resetLabyrinth(Labyrinth* labyrinth){ + for(int i=0; ix_size; i++){ + for(int j=0; jy_size; j++){ + labyrinth->at[i][j].color = WHITE; + labyrinth->at[i][j].visited = 0; + labyrinth->at[i][j].dp = -1; + } + } + + labyrinth->at[labyrinth->start.x][labyrinth->start.y].color = BLUE; + labyrinth->at[labyrinth->end.x][labyrinth->end.y].color = BLUE; +} + +void removeLabyrinth(Labyrinth* labyrinth){ + for(int i=0; ix_size; i++) + free(labyrinth->at[i]); + free(labyrinth->at); + free(labyrinth); +} + +void find_path(Labyrinth* labyrinth){ + find_path_r(labyrinth, labyrinth->end.x, labyrinth->end.y); +} + +void find_path_r(Labyrinth* labyrinth, int i, int j){ + labyrinth->at[i][j].color = BLUE; + // printLab(labyrinth); + + if(i==labyrinth->start.x && j==labyrinth->start.y) + return; + + if(labyrinth->at[i][j].direction == UP) + find_path_r(labyrinth, i+1, j); + else if(labyrinth->at[i][j].direction == RIGHT) + find_path_r(labyrinth, i, j-1); + else if(labyrinth->at[i][j].direction == DOWN) + find_path_r(labyrinth, i-1, j); + else if(labyrinth->at[i][j].direction == LEFT) + find_path_r(labyrinth, i, j+1); + else{ + printf("ERROR IN FIND_PATH\n"); + exit(EXIT_FAILURE); + } +} + +void printLab(Labyrinth* labyrinth){ + printLabWith(labyrinth, '|', '-', '+'); +} + +void printLabWith(Labyrinth* labyrinth, char wall, char floor, char corner){ + int i, j; + + system("clear"); + + for(j=0; jy_size; j++){ + printf("%c%c", corner, floor); + } + printf("%c\n", corner); + + for(i=0; ix_size; i++){ + printf("%c", wall); + + for(j=0; jy_size; j++){ + if(labyrinth->at[i][j].color == BLUE) + printf("\033[104m \033[49m"); + else if(labyrinth->at[i][j].color == GREEN) + printf("\033[102m \033[49m"); + else if(labyrinth->at[i][j].color == ORANGE) + printf("\033[103m \033[49m"); + else + printf(" "); + + if(labyrinth->at[i][j].east && jy_size-1){ + if(labyrinth->at[i][j+1].color == BLUE && labyrinth->at[i][j].color == BLUE) + printf("\033[104m \033[49m"); + else if((labyrinth->at[i][j+1].color == GREEN || labyrinth->at[i][j+1].color == BLUE) && (labyrinth->at[i][j].color == GREEN || labyrinth->at[i][j].color == BLUE)) + printf("\033[102m \033[49m"); + else if(!(labyrinth->at[i][j+1].color == WHITE) && !(labyrinth->at[i][j].color == WHITE)) + printf("\033[103m \033[49m"); + else + printf(" "); + }else + printf("%c", wall); + } + printf("\n"); + for(j=0; jy_size; j++){ + printf("%c", corner); + if(labyrinth->at[i][j].south && ix_size-1){ + if(labyrinth->at[i][j].color == BLUE && labyrinth->at[i+1][j].color == BLUE) + printf("\033[104m \033[49m"); + else if((labyrinth->at[i][j].color == GREEN || labyrinth->at[i][j].color == BLUE) && (labyrinth->at[i+1][j].color == GREEN || labyrinth->at[i+1][j].color == BLUE)) + printf("\033[102m \033[49m"); + else if(!(labyrinth->at[i][j].color == WHITE) && !(labyrinth->at[i+1][j].color == WHITE)) + printf("\033[103m \033[49m"); + else + printf(" "); + }else + printf("%c", floor); + } + printf("%c\n", corner); + } + printf("\n"); + + usleep(50000); +} \ No newline at end of file diff --git a/bakcup/src/main.c b/bakcup/src/main.c new file mode 100644 index 0000000..572d875 --- /dev/null +++ b/bakcup/src/main.c @@ -0,0 +1,30 @@ +#include +#include +#include +#include "../include/dijkstra.h" +#include "../include/dfs.h" +#include "../include/labyrinth.h" +#include "../include/binaryTree.h" +#include "../include/depthFirst.h" +#include "../include/prim.h" +#include "../include/eller.h" +#include "../include/water.h" +#include "../include/bfs.h" + +#define N 15 +#define M 15 + +int main(){ + srand(time(0)); + + int n = N, m = M; + + Labyrinth* labyrinth1 = prim(n, m); + + dijkstra(labyrinth1); + printLab(labyrinth1); + resetLabyrinth(labyrinth1); + + + removeLabyrinth(labyrinth1); +} diff --git a/bakcup/src/prim.c b/bakcup/src/prim.c new file mode 100644 index 0000000..d608d41 --- /dev/null +++ b/bakcup/src/prim.c @@ -0,0 +1,120 @@ +#include +#include +#include +#include "../include/coor.h" +#include "../include/prim.h" + +Labyrinth* prim_(int n, int m, bool show); + +Labyrinth* prim(int n, int m){ + return prim_(n, m, false); +} + +Labyrinth* primShow(int n, int m){ + return prim_(n, m, true); +} + +// creates a labyrinth using prim's algorithm +Labyrinth* prim_(int n, int m, bool show){ + int i, j, h, tmp, tp; + Labyrinth* labyrinth = newLabyrinth(n, m); + + int arr[4] = {0, 1, 2, 3}; + + coor frontier[n*m]; + coor current = {.x = rand()%n, .y = rand()%m}; + i = current.x; + j = current.y; + int frontierSize = 0; + + do{ + if(show){ + labyrinth->at[i][j].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][j].color = WHITE; + } + + + labyrinth->at[i][j].visited = 1; + + // adds frontier cells + if(i > 0 && labyrinth->at[i-1][j].dp < 0){ + frontier[frontierSize].x = i-1; + frontier[frontierSize].y = j; + frontierSize++; + labyrinth->at[i-1][j].dp = 1; + } + if(j < m-1 && labyrinth->at[i][j+1].dp < 0){ + frontier[frontierSize].x = i; + frontier[frontierSize].y = j+1; + frontierSize++; + labyrinth->at[i][j+1].dp = 1; + } + if(i < n-1 && labyrinth->at[i+1][j].dp < 0){ + frontier[frontierSize].x = i+1; + frontier[frontierSize].y = j; + frontierSize++; + labyrinth->at[i+1][j].dp = 1; + } + if(j > 0 && labyrinth->at[i][j-1].dp < 0){ + frontier[frontierSize].x = i; + frontier[frontierSize].y = j-1; + frontierSize++; + labyrinth->at[i][j-1].dp = 1; + } + + // randomly selects a frontier cell + tmp = rand()%frontierSize; + current = frontier[tmp]; + frontier[tmp] = frontier[frontierSize-1]; + frontierSize--; + + i = current.x; + j = current.y; + + // randomly joins the selected cell to another cell + for(h=3; h>0; h--){ + tmp = rand()%h; + tp = arr[h]; + arr[h] = arr[tmp]; + arr[tmp] = tp; + } + + tmp = 1; + for(h=0; h<4 && tmp; h++){ + if(arr[h]==0){ + if(i>0 && labyrinth->at[i-1][j].visited){ + labyrinth->at[i-1][j].south = 1; + tmp = 0; + } + }else if(arr[h]==1){ + if(jat[i][j+1].visited){ + labyrinth->at[i][j].east = 1; + tmp = 0; + } + }else if(arr[h]==2){ + if(iat[i+1][j].visited){ + labyrinth->at[i][j].south = 1; + tmp = 0; + } + }else if(arr[h]==3){ + if(j>0 && labyrinth->at[i][j-1].visited){ + labyrinth->at[i][j-1].east = 1; + tmp = 0; + } + } + + } + + }while(frontierSize); + + if(show){ + labyrinth->at[i][j].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][j].color = WHITE; + } + + resetLabyrinth(labyrinth); + + return labyrinth; +} \ No newline at end of file diff --git a/bakcup/src/priority_queue.c b/bakcup/src/priority_queue.c new file mode 100644 index 0000000..6830fee --- /dev/null +++ b/bakcup/src/priority_queue.c @@ -0,0 +1,127 @@ +#include +#include +#include +#include "../include/priority_queue.h" + + +void priority_queueFixheap(priority_queue* q, int i); +void priority_queueHeapify(priority_queue* queue, int i); +void priority_queueSwap(void** a, void** b); + +priority_queue* newPriority_queue(bool (*compare)()){ + priority_queue* pq = (priority_queue*)malloc(sizeof(priority_queue)); + pq->size = 0; + pq->capacity = 0; + pq->growthFactor = PRIORITY_QUEUE_INIT_GROWTH_FACT; + + pq->compare = compare; + pq->toString = NULL; + + return pq; +} + +void priority_queuePush(priority_queue* pq, void* element){ + if(pq->size == pq->capacity){ + if(pq->capacity) + priority_queueResize(pq, pq->capacity * pq->growthFactor); + else + priority_queueResize(pq, 1); + } + + pq->at[pq->size] = element; + pq->size++; + + priority_queueFixheap(pq, pq->size-1); +} + +void priority_queueFixheap(priority_queue* pq, int i){ + if(!i) + return; + if(pq->compare(pq->at[(i-1)/2], pq->at[i])) + priority_queueSwap(pq->at[i], pq->at[(i-1)/2]); + + priority_queueFixheap(pq, (i-1)/2); +} + +void priority_queuePop(priority_queue* pq){ + if(!pq->size){ + fprintf(stderr, "POP ON EMPTY PRIORITY_QUEUE\n"); + return; + } + + priority_queueSwap(&pq->at[0], &pq->at[pq->size-1]); + free(pq->at[pq->size-1]); + pq->size--; + priority_queueHeapify(pq, 0); +} + +void priority_queueHeapify(priority_queue* pq, int i){ + if(i >= (pq->size)/2) + return; + + int minson; + if(pq->size-1 == 2*i+1 || !pq->compare(pq->at[2*i+1], pq->at[2*i+2])) + minson = 2*i+1; + else + minson = 2*i+2; + + if(pq->compare(pq->at[i], pq->at[minson])){ + priority_queueSwap(&pq->at[i], &pq->at[minson]); + priority_queueHeapify(pq, minson); + } +} + +void priority_queueSwap(void** a, void** b){ + void* tmp = *a; + *a = *b; + *b = tmp; +} + +void priority_queueResize(priority_queue* pq, int capacity){ + for(int i=pq->size; i>capacity; i--) + free(pq->at[i-1]); + + void **at = realloc(pq->at, sizeof(void *) * capacity); + pq->at = at; + pq->capacity = capacity; +} + +void priority_queueClear(priority_queue* pq){ + priority_queueResize(pq, 0); + pq->size = 0; +} + +void priority_queueFree(priority_queue* pq){ + priority_queueClear(pq); + free(pq->at); + free(pq); +} + +void priority_queueShrink_to_fit(priority_queue* pq){ + priority_queueResize(pq, pq->size); +} + +bool priority_queueIsEmpty(priority_queue* pq){ + return pq->size > 0 ? false : true; +} + +void* priority_queueTop(priority_queue* pq){ + if(!pq->size){ + fprintf(stderr, "PRIORITY_QUEUE IS EMPTY\n"); + return NULL; + } + + return pq->at[0]; +} + +void priority_queuePrint(priority_queue* pq){ + if(pq->toString == NULL){ + fprintf(stderr, "TOSTRING NOT DEFINED\n"); + return; + } + + for(int i=0; isize; i++) + pq->toString(pq->at[i]); + + printf("\n"); +} \ No newline at end of file diff --git a/bakcup/src/queue.c b/bakcup/src/queue.c new file mode 100644 index 0000000..aa24f9e --- /dev/null +++ b/bakcup/src/queue.c @@ -0,0 +1,87 @@ +#include +#include +#include "../include/queue.h" + +queue* newQueue(){ + queue* tmp = (queue*)malloc(sizeof(queue)); + tmp->size = 0; + + tmp->toString = NULL; + tmp->front = NULL; + tmp->back = NULL; + + return tmp; +} + +void queuePush(queue* q, void* element){ + queue_element* qel = (queue_element*)malloc(sizeof(queue_element)); + qel->element = element; + qel->next = NULL; + + if(queueIsEmpty(q)){ + q->front = qel; + q->back = qel; + }else{ + q->back->next = qel; + q->back = qel; + } + + q->size++; +} + +void queuePrint(queue* q){ + if(q->toString == NULL){ + fprintf(stderr, "TOSTRING NOT DEFINED\n"); + return; + } + + queue_element* tmp = q->front; + while(tmp){ + q->toString(tmp->element); + tmp = tmp->next; + printf("\n"); + } + + printf("\n"); +} + +void queuePop(queue* q){ + if(queueIsEmpty(q)){ + fprintf(stderr, "QUEUE IS EMTPY\n"); + return; + } + + queue_element* tmp = q->front->next; + free(q->front->element); + free(q->front); + q->front = tmp; + q->size--; +} + +bool queueIsEmpty(queue* q){ + return q->size == 0; +} + +void queueMerge(queue* q1, queue* q2){ + q1->back->next = q2->front; + q1->size += q2->size; + q2->size = 0; +} + +void queueClear(queue* q){ + queue_element* tmp = q->front, *tp; + while(tmp){ + tp = tmp->next; + // free(tmp->element); + free(tmp); + tmp = tp; + } + + q->front = NULL; + q->size = 0; +} + +void queueFree(queue* q){ + queueClear(q); + free(q); +} \ No newline at end of file diff --git a/bakcup/src/water.c b/bakcup/src/water.c new file mode 100644 index 0000000..7ab4aae --- /dev/null +++ b/bakcup/src/water.c @@ -0,0 +1,17 @@ +#include +#include +#include "../include/labyrinth.h" +#include "../include/water.h" +#include "../include/priority_queue.h" + +bool compare(coor* c1, coor* c2){ + return c1->x < c2->x; +} + +void water(Labyrinth *labyrinth){ + int i, j, h, n = labyrinth->x_size, m = labyrinth->y_size; + + priority_queue(pq, compare); // DA METTERE RBTREE (mai) + + +} \ No newline at end of file diff --git a/include/bfs.h b/include/bfs.h new file mode 100644 index 0000000..90818fb --- /dev/null +++ b/include/bfs.h @@ -0,0 +1,6 @@ +#ifndef BFS_H +#define BFS_H + +void bfs(Labyrinth* labyrinth); + +#endif \ No newline at end of file diff --git a/include/binaryTree.h b/include/binaryTree.h new file mode 100644 index 0000000..e8abbf1 --- /dev/null +++ b/include/binaryTree.h @@ -0,0 +1,9 @@ +#ifndef BINARY_TREE_H +#define BINARY_TREE_H + +#include "labyrinth.h" + +Labyrinth* binaryTree(int n, int m); +Labyrinth* binaryTreeShow(int n, int m); + +#endif \ No newline at end of file diff --git a/include/coor.h b/include/coor.h new file mode 100644 index 0000000..95f801a --- /dev/null +++ b/include/coor.h @@ -0,0 +1,9 @@ +#ifndef COOR_H +#define COOR_H + +typedef struct coor{ + int x; + int y; +} coor; + +#endif \ No newline at end of file diff --git a/include/depthFirst.h b/include/depthFirst.h new file mode 100644 index 0000000..97da0f7 --- /dev/null +++ b/include/depthFirst.h @@ -0,0 +1,9 @@ +#ifndef DEPTH_FIRST_H +#define DEPTH_FIRST_H + +#include "labyrinth.h" + +Labyrinth* depthFirst(int n, int m); +Labyrinth* depthFirstShow(int n, int m); + +#endif \ No newline at end of file diff --git a/include/dfs.h b/include/dfs.h new file mode 100644 index 0000000..a9f8244 --- /dev/null +++ b/include/dfs.h @@ -0,0 +1,6 @@ +#ifndef DFS_H +#define DFS_H + +void dfs(Labyrinth* labyrinth); + +#endif \ No newline at end of file diff --git a/include/dijkstra.h b/include/dijkstra.h new file mode 100644 index 0000000..744fe8d --- /dev/null +++ b/include/dijkstra.h @@ -0,0 +1,8 @@ +#ifndef DIJKSTRA_H +#define DIJKSTRA_H + +#include "labyrinth.h" + +void dijkstra(Labyrinth* labyrinth); + +#endif \ No newline at end of file diff --git a/include/eller.h b/include/eller.h new file mode 100644 index 0000000..5b00125 --- /dev/null +++ b/include/eller.h @@ -0,0 +1,9 @@ +#ifndef ELLER_H +#define ELLER_H + +#include "labyrinth.h" + +Labyrinth* eller(int n, int m); +Labyrinth* ellerShow(int n, int m); + +#endif \ No newline at end of file diff --git a/include/labyrinth.h b/include/labyrinth.h new file mode 100644 index 0000000..ba09439 --- /dev/null +++ b/include/labyrinth.h @@ -0,0 +1,49 @@ +#ifndef LABYRINTH_H +#define LABYRINTH_H + +#include "coor.h" + +enum Color{ + WHITE, + GREEN, + ORANGE, + BLUE +}; + +enum Direction{ + UP, + RIGHT, + DOWN, + LEFT +}; + +typedef struct Node{ + short south; + short east; + + short visited; + int dp; + + enum Color color; + enum Direction direction; +} Node; + +typedef struct Labyrinth { + Node** at; + int x_size; + int y_size; + + coor start; + coor end; +} Labyrinth; + +Labyrinth* newLabyrinth(int n, int m); +void resetLabyrinth(Labyrinth* Labyrinth); +void removeLabyrinth(Labyrinth* labyrinth); + +void find_path(Labyrinth* labyrinth); + +void printLab(Labyrinth* labyrinth); +void printLabWith(Labyrinth* labyrinth, char wall, char floor, char corner); + +#endif \ No newline at end of file diff --git a/include/prim.h b/include/prim.h new file mode 100644 index 0000000..c70d30a --- /dev/null +++ b/include/prim.h @@ -0,0 +1,9 @@ +#ifndef PRIM_H +#define PRIM_H + +#include "labyrinth.h" + +Labyrinth* prim(int n, int m); +Labyrinth* primShow(int n, int m); + +#endif \ No newline at end of file diff --git a/include/priority_queue.h b/include/priority_queue.h new file mode 100644 index 0000000..5f5c3e9 --- /dev/null +++ b/include/priority_queue.h @@ -0,0 +1,40 @@ +#ifndef PRIORITY_QUEUE_H +#define PRIORITY_QUEUE_H + +#define PRIORITY_QUEUE_INIT_GROWTH_FACT 2 + +#define priority_queue(pq, compare) priority_queue* pq = newPriority_queue(compare); + +typedef struct priority_queue{ + void** at; + int capacity; + int size; + + int growthFactor; + + void (*toString)(); + bool (*compare)(); +} priority_queue; + + +priority_queue* newPriority_queue(bool (*compare)()); + +void priority_queueResize(priority_queue* v, int capacity); + +void priority_queueClear(priority_queue* pq); + +void priority_queuePush(priority_queue* pq, void* element); + +void priority_queueFree(priority_queue* pq); + +void priority_queueShrink_to_fit(priority_queue* pq); + +bool priority_queueIsEmpty(priority_queue* pq); + +void* priority_queueTop(priority_queue* pq); + +void priority_queuePop(priority_queue* pq); + +void priority_queuePrint(priority_queue* pq); + +#endif \ No newline at end of file diff --git a/include/queue.h b/include/queue.h new file mode 100644 index 0000000..d399486 --- /dev/null +++ b/include/queue.h @@ -0,0 +1,50 @@ +#ifndef QUEUE_H +#define QUEUE_H + +#include + +/* + * Macro to create a new queue. + */ +#define queue(q) queue* q = newQueue(); + +typedef struct queue_element{ + void* next; + void* element; +} queue_element; + +typedef struct queue{ + + int size; /* The number of at in use */ + queue_element* front; /* pointer to the first element of the queue */ + queue_element* back; /* pointer to the back element of the queue */ + + void (*toString)(); /* Pointer to toString function */ +} queue; + + +/* + * Creates new queue. + */ +queue* newQueue(); + +/* + * Adds a new element to the queue. + */ +void queuePush(queue* q, void* element); + +void queuePrint(queue* q); + +void queuePop(queue* q); + +bool queueIsEmpty(queue* q); + +void queueMerge(queue* q1, queue* q2); + +void queueClear(queue* q); + +void queueFree(queue* q); + +void* queueTop(queue* q); + +#endif \ No newline at end of file diff --git a/include/water.h b/include/water.h new file mode 100644 index 0000000..6f00882 --- /dev/null +++ b/include/water.h @@ -0,0 +1,6 @@ +#ifndef WATER_H +#define WATHER_H + +void water(Labyrinth* labyrinth); + +#endif \ No newline at end of file diff --git a/obj/bfs.o b/obj/bfs.o new file mode 100644 index 0000000000000000000000000000000000000000..2250d8213a3ffa547ebb2f3f18c7a940a38f2504 GIT binary patch literal 4072 zcmbtWL2nyH6rQ!+B!JU3C5K84$Q(c|YF7!gCcLCv9vv^_Z7A`Vr!pn#~9LJuGg4HZ&&Z)Rt+ws)O0j5IrM zKELnH+xOnQ^$lfwBp?Wc4}rW*4t5+Rq!K=mWh%;~lZ46N;!98Bs`)@Q9_3YYab-re zLa&?!1=UpcdN*py4l37_-_U4H*$vR;Q4p5zJK(Vk6LmLKOIfjE5m+`%e8Q%SZepQz z)ZvPosuf4&P1U@wnl%bP{H_g*AZE!ObehT*?6)jpDpe}TAyZjnG{ymW#gb3=E7j6D zCU^HMYo!+(b(}Nu>Ybec zLUh@z$zhBJCE0KAbOzEjIV3Bi8xP}B5yz8lpTK?t33RH} z*b9i|v4+4_#pN$Rsl_XJTvcAP6HQFxu5jo@cLFO?@1SPwU>;JlN3rc0*`pC7;0>!; zbm!2Ty$XSJg*GUbWk8I@HRuFy+Ce^Q^D}n4RAJL8*T&Z&*2ggA6oulQkL)royv zze20TZVOni9gwBOaBc+-5ck9yE2*q6!p zQ&@sNcm5v=@6D)hurI29f;Rde?vc@bWTO zo?|$HenYTFLC+v# z>TC#)cbl2cR>Q5Vvi9d=xFl@5^sNlG%EG_ zXyKI0Px|hFJqMHa`g(QpvJZaN2k-U4-}1qSeeek%{5>B$>4T?z@S+b+rqe|!g-?+#C87mbtwzQCE!bm~WNP0Fm zlgKCa49OQ}bNYC4niP_`8KyB-RI+*fI!PpodNMVaNM+^{>E!G@ct*$|ePXS#-2A)G z#)mE(|FUxYGZ)_J!oPLlCtdhYE?jis4_r9b1GhgUupiK$=UsT&g`aZa_gy&F7Ps@7 zeHGA-+fM@l7>)SPc(Fb3OZHW0)Sq( z*qY%|L7PuXx^_(`(o9lM5^1_vBvNW2o7HlFYbZd6pZ8c}H%{lw?Afe6U^0Dur%^sNU!Outg?!nLJ>j3=7Ww+kW5&gdcBvh@d zA=q<%6lC|{@#EMu2zY)Yp9i{+E81%#|9!x{@)yM>0fXlW^M_o{=eXzDpx0+B?%Bb? lyZnp?AF;;V0YrN2`dPw_Yc$3hdx{so&-Q=b#YM4^{~wTS>mvXF literal 0 HcmV?d00001 diff --git a/obj/binaryTree.o b/obj/binaryTree.o new file mode 100644 index 0000000000000000000000000000000000000000..e26ee707fa841fdb9e6fa145c8ae5d8142534ec2 GIT binary patch literal 2888 zcmbtV&1(}u6rWA1jkRBj2Sw4~K`iK!N(Hqdsb$+mqb;@pK_za|tr2ZnHXHi^RUsfQ z+k?mU;Kjc}JXv~3dr*Ri^w5I{LajYS?4d|8zBid^rqkV0@R8Yh@Ap3Ez1ht(E!GuK z6v9a%S4dUjC?TOxm5)+3N*YK#`Q3E-p7YXL7^It-CkYU2WqX+BhGb!ZI=o zbG~+%%-b&FOfEUOMW^^u`|QRSU2Vzv!s6+UwywLl2>b>M(SQO>RfZ!xpZrX0wF(xZ z^#Mpl0Ul-31C&^1L0iRgeoinqH@>Q;KIyaHf_i=>q$@?5j0f-C!OB0IS4@^Z59wWP zwOw0knwlt=%LT23<@}g|$L2vou2#}hMcpatvtI*P6K?tCL%K3wX#_p_z^)wp%hcVS z5^WY-f`Uu!+G5kx9a=E$-;YyJHZQ&ocv{gDR*}#EY^Zk{W!}HE-3Nfa5qke-W>-!q z#r#*LrRZpD`N=h6U)){}pRr#_g9RA<&kNff{m&uJB@g4|-CFruE{o&-2r`W;T+M|! z(%sp4DSSGf%w_Cc_@dgTM$We8sMPxOTttnusjV#)9FK}r1FIR<9$4Ks;{@*fd&GjU zkPcNgqD`j0Hh^V`aIFO(IZbeNRFd6p` z)&wgNm{QvCg4d8=WeKKY(DO@#XW^&W>J_A?--@9WBzw1m6tDHc@xZpZiYfaBa`x(e4Sxb-k&r^yIzAQH>S3=qrAnkX?P z)N&FQ65h=^SR3&9K)Qw?kc?XunBon))10%+$A)T~V>VF- z4BH@TGMgo8YItbK%m9`dwoMh@{j*uyNIhcmgG^2xv4%%X%N{2xjbNq|gO)L5vI_oh z3xhkhR({i>fFa$JURgGViV~hjVPP+$utXYT0T&sFcLjYzOg_wZe6J9f(va6O!0hGx zX8^~TviWZPTfrA&Mqr7={V~2sJU`zrfs*s0-GW>YQ_8mZ-r(0vymM$;Wd30k1mgYU zP!br7Df^e0{}?x9yX=1taIg9GvQMne{BVBg%l-NMymF&U8iN8&vjgu3ejhB^A2H8X avHOz)y-0HZ4uI0jf11_*Sab$n_WuVBFfalD literal 0 HcmV?d00001 diff --git a/obj/depthFirst.o b/obj/depthFirst.o new file mode 100644 index 0000000000000000000000000000000000000000..e98d45b834561f0698bf2deedb38c327dd54ee72 GIT binary patch literal 3736 zcmc&$UuauZ7(X|+?W(rBRfbF^BQI)&?b^;Mu85@TZhO(X72Du+jF2WbrmRg%a^qSd zZg9=;a>>|>P#**-iXcAdi+`X(x(yQ{4?(N;p^PF5Y2AavhZRxk_nmuAa(a_gyFK{9 z>G{s@e1CrTJKs6!1#NiHCrN~hM4ltH6-Nmx<&kdpYc_lHz#Il~f+aojoxb$5tV?Cx zX?L`u9x3Z~SzlW7Aw;KQtPp6C$nJa!f%YwsiIfHr{DVcah7d7^|C(ioXD=(+Nz_ifIgO8qo7R{M1rfRTT^Ap z%9P24d_h}=IAnbZf;-x>>z~al+4lgoG9{v1UVyFo3RoNMI~HB}BG3}UK#@Cgj}_n= zD4)N$=xC+f?3V5X^KiQMH}reg6_KsADJj_npo=7(K!;V4j%h_Dw*h6V=Ur`-c|A8G z)%8l1_9r`gH*PZ@=UmLqNG|6RYk~DM5U^TdYttukZl|0}O77{ptkzZOUmLti`ZlY= zZtjLyXU4f&=Z_$sz*$zZ@6fg=LR&by%w<*f=~9tVO^@twGIh0eUEvyw^<_Q5>uYJt z(9+AYa`~yh|KEFi1wL&vsz2#ISY|72*>A6rp@D%ue|K;^oiNk>W9m`0=WuVDu6o}* z(xdhqReK+Iaj0wyj4l|hFosSB2{e2jF}(FC``n30Z@fgL*)Hio$DZ~p&^&&?A7*+wr}yd_dqy>jT(BFz`IQ@&o{l@MoLg z{eWZq5(`9Y3;M|>_Gg(r=fUU6CidwjIEflFW_)lWnKIRgupptK;Zw)^heM|Z2S>HB z&{+TRVJ$=w#`)p!_*`-#Va7=^oQMi8p(IHfDZ{K8)MAgur_Ylabc0(Ww{TKuUX)$VaeS-e2;k+;79=ycXL`}_2na~qz%1pX*oNGyAGOU`$ ztVz^p*bEbOJe4A9WO{1KNC1|YHVqZtz{9ke*!s0ZTAfKw&lpK_j;J((5f8 zysOy{-gtCvo+tsf{+QK^Z+l<11F(T-65s}G{+&HVpE8Gg0Y{a;Q2UwPqYUToJ%h=H zCojjn`47Pc#=KMiUhu`3JupP!`7ypIJU^fNV3X^j-GknOvQ4k;^MK=PF7_On?q~jf zTnNJJ$DwghFs9f48RmbH8?xE!kMC}y^Lrl;3`BP)f=l$}{`~wJFUop-4MKd3TG^^Cq zY_)06kI+sFVP}1>S+xdIaK^`1Z{KoJ6`*cf#i|vnBsIJ5*-`Yi)MlgtoK0IfKA~2N zPdVe06KbV6bOV#T|LYMN6+A-d5p+C8z{5C;W6dUZtg0pMXg7ZnHKDHAgSJ}H5_Qe0 zYd3cS2+?k{rUWq}C3Vt0M1XWn=@Upz-GM03{fyCSY9m0qMzscyx# zZMCjlv(J@xEcKqPZo_z?yhA~Y4iJgm!?BsI3udWKE>~*m7Q`Xss5#sF39;W1O) zf~#&zl&+lmyVbe@B>2o?GpW5aPJbGVBlHTreT&S^%uI$yV~fR{Q4CMWV$Brr4Fp9cq+;=5N72b<}K2Y)Y4_B$T*Ro4STLr%Z9x?TVv`u-9l&a>Uk z66x3N#&9MQOsLyLGSCeIA`<+fZWF0$yK#*0q$^LV4PcKmoX@EyfIR_?Uf0mO?KznE z;gLP?$vyBl_P|LpU62#_#HQzoJ{LVdJr&i@&(6N9F6awW(@|9?>7`s!UyU0XvYKDY z8PWJ6$;Wd^qU!}Cp17bVG8go8d}*1C!a8VJJNT#3KP|_`5d=d#2#w=EAP9!|Ff@*z z#R33B{3tYze~uRnm^c1iw)I|I!h-hkSJ~Ek{nuQ$1U$ZO7=wV}@+<{9SLm~Y^L-_9 z;bPVRndE|zclrz;<&BF(rV&yZJ)MtdQ!Io3*M)(Ol6y~t0vOsQ&kMFa&P#ZnfQDKs(A@U&W6o@w zfmjpB`XM@$^N|F9&ye8jwa2M}p6$9bH%%&RrtpMHFW<-hFW;?T?g7ck^Xr~m)} literal 0 HcmV?d00001 diff --git a/obj/dijkstra.o b/obj/dijkstra.o new file mode 100644 index 0000000000000000000000000000000000000000..68723c4107bf5f51ba5159fde5553e6e50eb8f92 GIT binary patch literal 5160 zcmbtXU2GIp6u#4~utH%MLsdqtM)0LfX-Lyrwd zM`bl*{C?y%oaEYX+F&6L>v-`L9uZj0x=A#u?ofrWTf=r}#jHUMuDe>RF=1Ssix^79 zaG8Bt)ab7mP6gl=gz0p7N{h04Q>dk8I6oQA6jl7^5ChoGC60cr0nl0fciZq?AOjy>a~D$efd zgrk>Hg{!UY(r4_4*?L2lUa?ofx-8WF{^1frN~6=ndKy^_m$<1JqyIzxYH z^1O46Zfd$TsnCZ*!`n(#1#FLvzZ2+PS{I>l(OPI=`W6P9G z%HYk14Xo~qiHHVtdsZmO%L^r-fh}fTU`!T%DX_=?4kF-uWwI^ zK!%hNL#vS1u!$(I?IX&mxU#-&Y4j{4zy`qahx8~8`pWpbEj=riybKJm#k1{*18u`W zoS&FKe+6-%7qMH2^T-|rIZ*y}JOug~-n#SWKP+K4(4(dSuWBVXZZ#bM5DEOkLtH#< zqf~@?rxC+lgnBCoU)l^(e)`$ebQU4^Hem=v2tIHl;V0f|$$si{z|c>Ki#_!o5l zeY(Pq(X%iG;oX4aJqI}-jR~xGh43R^&^-eo_{k953Bf-G9PRlM0}4cQ0Orr&7o_)# z5d7N^d^QBX8iM~8f|G%vW5 zNbl|K-LD@=AK1~I(9=GgG1SYbUtH&D%&dhIC_T7OaUAMlwcF~ z4O$id-eU9u$FY~JfS-zVL3Ov15e3casNIR3*XaQx6jLOUOTpTIwo@CPOQQwd)y;paIn z{4YAq=Mw)qiT{R#KP2I0ya34W&zll1`|~Aa4B$T};WGbU_<{-Gf1I~E6qEVi=B?Ck z&({(z^S9&WKxi&EneH_@&f}s_9`fO$@4e;2MgJjc@$`rV6{JG3v-zl470ls`YMG}j zq7G!N3{ejki$pEt*ao@+?FMQ#XPGLzW49EoO#gAh_D8a|nlI$?W&!F@r8k*J(}RV~ zh{-Mae^Wb%W61q)6b&#WS0oJEQeM8K(|Q;&1{&SX4+a)B(0kn3SevLvT!%S|^cegQ z_rGDk7mUax5l>GKc@kF0dbjeOAd7d(IRRTD^kWXm{1 z4ToYa^F@PS{Y||4KnPRbZ@-XlmoJ62->t_0L;ZgFOCHk-{&jr`m7 zu1Km<9IbEb(e)NT)RK`3;)N=*_u4PS&HXioK~yow_sL36p@a;6ZKd79n=NE3sU@F> zzy3u#WgpVqClU7i4VGPY9$t3hH~xq+>`$z?fQ@&~`^w>D9&)iKVvon#V}}mXlb=wK zVUrJ*%Vl=D*&Jo|_`l0#XAH$0o2$&qHNe=Dh;kFo zBudcK+cdXez{p|IYh@Q=lel0QG4uD@qFIzeol=F__1G%f4NysuR`z!69JWn|kD5*% zM@@FIHGF#3WCf^-G+$eT&83g1@fXT2;{42x2xE7x7z2<9FeE`RhhnBPhGHhWWIAV2 z#B?T6M9i@a)s&cHMw?@nriwItdYb0z_=YATuuQ%sqx2@Wd93Kt=d`O7p{zuAkZZ6# z_5s~_p0X>n`9fwJM1g=P&5hi<90rxEiy*k83{AT8LZxXJGTSSi+(L*Nb2Jx%@IX}v z(5ZzQIyF}VyX%KFiy+a|wDj(Az_7>cYY;;4?lM#`6~qF;IRP$c;QIS1z<#Fb$@$8L z-lgn)+WemPhNe%>iygfOTC#0l%0$FI*Vs>dZ~_;~sSaEmc5K0}63zV$*wsEtQzgpA zN@5FFDqBFXAix;~j^9L>{$JY~FWM$V1^0IKnR7vHiv{Y$3(gphvIuqBu|G`NELDfi zi4Tflnz~dBj-m+=8LwbYp6k|*=J*tb!>jLd$Nl^_(t&KAvUkyU!i}#AH=Yq5n@}F( zzI|1IrxfVv#&a6mmuOeD8$YHyFH`o#|9~B*sKZl_a?XlZ7hAtVNYSRs$@hVez;D>E z^4lplmg73$H58RzJHKLR@duDH)vOMwc%4qo2dGh^PDp5ShnD!E1QgGvG2^s^?81o- z9#Cjgd{}&9L)P+j2H2T!2-^#WkRjqe*pM;4G-kKKj!pIvo%(x?@D>8#EvIf2%wlGt zsf*5-L?Q9bLb4V9V|ByTD#6h_#TA0jr94AMqEoAU8y-0g#1gDzeE4b?KkY9qO`YU(eIl)n8AA&LA>3mxm<{8Iz*1|gRB&^K1N+gepxRf{eQgVC}^1_G~;aotSC=@}v zI3d~;%Y=KanRmnaN4cn=pbr_uS|A^}$v`1){+f*rpMt_^YlB2rt$Yob(>xU(x>O@m zV{Xo{3)wrxz0B8#IUsER9t75!B_wCTgI+zw%&}rijj>T>Sf2>d%}nmOMLaCR=|%g8 zuop~oi=V>J!)&ed@3@6)wO9UZTclI+d?GoD4Me4p8~e z)VN+Dv9hO;SVF*@HMdk*md`R^rpvgDpt!iId=5w2;kLxh@5@&=1_)UU+{U#Zl+>MS64>|k_@#o?iEGf3s0>vscxw$0dcO<|V*dm@; zqU%Pvtew#qT$#cF`WeNbFW#XJ1!NEeLSC*DE;<5{EIrXNqo%Ytt&r{Jssq$2hvn0|0p8`+RWI2S4b8clhAPeDFRWJmZ7s zeDJ&vPOR>3D;-UVTKpzNb+EJVIg&VFKC(AvCLYp3%dygY;;6gU1m0dssSw3Yl;Nnw<~UBjhHZhzJX52CZ6xcBud4cF}$xHu2_*EJk-q4LjJ4Zl;v-`8+Ft4h8e+F0;C z7avtxWJBTVJRf%9ZL&|I11EYiK*8uhCN1ht)k<64$!Nwpo*~hr$xM<&j|>cuXsWNL z$La;Fw=ZKwA;<6Hq?G-i^k$>|>Arp|ojF0G+=A7aIF?TKSZc=qs;&oZ%+ZoI6J8reY_vM;x~hb1_~7w&xNR~^i}-4=0=qeCI=`Da$%ST@Gf=hBj%1BK%`Of Z=N0T|#qDdH#!EjU|KEZ+T`z9^{{U8qDa!x= literal 0 HcmV?d00001 diff --git a/obj/labyrith.o b/obj/labyrith.o new file mode 100644 index 0000000000000000000000000000000000000000..a3be9b200c1d8cf92f2f0ac9125f7320bfe9be66 GIT binary patch literal 7240 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 WQ+rF{5ES#$k1+?Wnx@;3_5Ta!(3)TX literal 0 HcmV?d00001 diff --git a/obj/main.o b/obj/main.o new file mode 100644 index 0000000000000000000000000000000000000000..998d501257e5ef56e0844c42bcf79c352a343af8 GIT binary patch literal 1992 zcmb`HL2DC16o6ln+Ez{4SUglJ5)h<<9TF{Kdyq6?lOVxjZNQ6$O}d(Bb`y3d+IY}| zAckE086Ld|-V{6p|A2Q7LJuAy_8=nE_jYHR$+`<7K6v}y`)1yo*_nO&R4W&vkqAhM zz*QJWk^;P#8v9w-%|Zg=@O}Qw&q}HPrS$A;@*VL#dh~~`8ET_>jE34inL%ZLppE*U z#9*nf{U{AkW&9WZTPptX0~GW5_0)2u*0p#ywZ>LidL`3!qs)_wX_j7Pne!f}1QObQ z67>jb@p=WK0Pl&#P)SaD1|pBQAhMf`EX8MLU*bWWMovo7rH3|`d>+jwrlT#KK_FP@ z45#4RLC|O{@PuhEayOG%F?aWqjG`D!{|Q|_6T*Wx9CJ@)GKFR?DEoBZ9a#dE&e1Pt z5d`t&5Y9sQr4YUr!gC?~MhFK}Z(6MG8mJb_o4Jj0b+b^oscl!cH*#gI3cP6=;Mlsg z10B0*!Xupou?q#~`Oipn;*;erSwiT$g0QGw#hDNB`G>C#Mu1SNLUx(;3V8 z1%=Nkd`scfTyp*$h0}dVeqZ4y6rK_s`+<65EX?Vd9AB3?-1clkdbZKh88>!0upOQ2 zz-o>ItllZ>Bxmv$WorLWHWtOknjpL-3*=&v*J4Pm?|a#F%dBhOF9HFT(^KYvy% zbVW`S)}MbHdC>jIU#Gk$xhw@Wn5= z_k8DfzJKRC-*yR_}nZ zgPOjLn?RWw%1qM~HLg+Pl6e|MOr42e<<3FiWL}xTIP%ID=r6Ba@UY<W}{YTZVLYO{VS zU89;G_6oz4mrl=m==3!Y?CdPd@2B^y3>6GzTmV+G4CS1uj2lYERL&VnI{wbVJM@f&ODEqt@?ymG8oVC@F-5T^JqcRCUGFg#`8>#-HOZ} zI3qVcfi@R5(7Zks&`-dE)r1LHg&jIBj>UQ;@Kw;)35GKAL#cP>;djXjmW4PAA=^XL z=A?jr3YN;7a2muaV=a}9dlQyI)gG)}Q4`V(Tvnd4ID-{&dPJP|7JRb8(^5L56zDIo z@ds?vHPG^W;%!x)Pj5ii0L1n?I=md?R_pQD)E&!LbtX|`mC0+?d#qNQ#F8cf{lGtP zi4A9gd+zUI@&E9vX8&0SFj$Yx%kg-hYp6?LhpnkZI{TNojbSJ zZwj{$B-MfXZSq#RadXoEn>8KX(kM4>m75wY91er{;K47A74YnNJxrjNrVztR0%@H! z5b1+Ah%{Iyt*=?-KMA$90dRbfHsMQIUH7qPXYI-e2*4EAUP2tmZT)$`53*H4?x2Fu zZ#m&T?#rzhU8$||{_3}kaXGgELV-QpDY~tBUB5hWZ(?`lT3(ioatvo)va%9n_^K*6 zZm5#HEX(CMO0KcR$#Ml)Eywq9ah4_CO23K&Vn`{T&)#Ym)IjmEkov99h&XY_Cngg~Cg7ZBF&qwvf_LnFP0AdnM3W5Eo^ zTnqV+u%LiY9{-{U{8SZu-iG7Xw~+T^LjgJMyjKOkjD^7E?RM5avVdcrg?-tEKW@Y8 zEphB)_V6hQI&e`phaC7mJ|}YjP(p>=%l&G~8oLCSiuXiiH9n{kxg)AZiQL}bPvlr{ zA`wplmh4sIGTbGb*(ve)yU78$FV))@PpLyhW)|XIki+(^wDMcofb~4FZM~ z;`y>>maO1$Tn`VPRS+IK4c1sQ_B{?P))xBV$3>p7mdUdmcit=`4!>O7*6|jC_aWMR zSp6o@#kd;bv6JwR_U**WwiL&9SQMCD?)(zt$3DZ`5bMrP6I{RE4gxRoC*XEq(7#i^ z!1c32kdIFNHo)D^FOAI&M6H3HALpg X;KWAGTw@Qr>Cf=^du+PMI`#hr^>^7j literal 0 HcmV?d00001 diff --git a/obj/priorityQueuePP.o b/obj/priorityQueuePP.o new file mode 100644 index 0000000000000000000000000000000000000000..6c8d99e62f8c4e6a32e714be7958fe908d8f5d3c GIT binary patch literal 3696 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 Q1^oB`8TOEWOW`2@080O*CIA2c literal 0 HcmV?d00001 diff --git a/obj/queue.o b/obj/queue.o new file mode 100644 index 0000000000000000000000000000000000000000..db67099ebf989492b1fb030b9a1d4a6df5e2c642 GIT binary patch literal 3800 zcmbtX&2Jk;6d%W>HKlD#_-G&%T5&){&`pAJpnSCN-jtd;b6oiLKWft=EI(>ZG^;=cIVCS zeaxHp-ptx>TjR;DNQ5bhuoqZ!rclOa?`iT0&L-FicAWj${m5TgyYj2O{(F4OAi)lV zcE#GW18c8_2?J->61^H9)A+dJzq_S*GwjORj$QG$w;(^@)ef@Tb|oDXeqoIzNV&$< z-l=*I^LdcnlWIF;0zSUmCnSluKxiOCDFh#|>*)xXN_?|TJX|}`Yj0HjNA2J)zI5g5 zFCQT0CemhKe;yc*V>cz&iXk1l{bH8xrIC`8Ahh-cl=puW2+!KqQDttgukA7a`zFvK zoaV0eh`PzmzeN=A)fxeca732H9ub~4Z>AC%+J|8!u0>Q?;{^}cMz#Bc>IJ=$ajGOG z->>s+HpA_qIbpJnRL|Y}xJJN>Ly~EV0R@5*MqWXT0Y?KC`35toQ%l5VHYK~Ydd>uYr?4lTArovjw$X}6fzK99bUQ1T&oJuaC- zEPdftW^yJoJ(e0ZQj;0uypNKM z4w(aI27NvoeCw$Jb706Ed|cqj4bdTbkQ=n_Xe!IP7^?z{(gV6*3@q}-G>cr0NBWK( ziEUD6pCTL&D211GB7UuF}5g@*q-QvQT4pKJO*B`?MYb@_ylOVgGC zCWqJ``z-W3LBgzfS<{bpr6}BL{AaVdxyre65p3O=QSrRDe>Dhf_N{{I7Lr8|Fa$NTnBuK zaO|rf*X6xLSgC`)FZFxrAc2(rRpR02bBXhwBP@{kNm*jvYlM9$@nMPc9wUss?mNC? z&a+kL(iB*h8y%k5+8+jyp@?CnXL)_iFfy8jjeM{!#~gL&NoWaOZ)-@qDV` zh)3=JGtG}4&kq`oyH&+=y8}KX`z4&8Uo>3zv)cjhmwg03=q0u8vl_1ZF-QjlchV)F zC-}RGt8@NJ2v_IvY6w^7=tc-v=eiog)j8S@;p!ZzD@Vnt&XJ+j1u}Jxm|4D3@bYss zdaf9k73VrDdDC+)d(2$OdwFKgmCMX@i()cgEEF6%Fy?B}b4>bHo+*3z`PbxpY1KDN zZn5OJbi7RN$yv@Vy7_`5BmaMcLFU*}_~uOz2AY+16f>c#c#M7Yp!NxRbP~T+82eV{ z3qR|@sxJcnkxui+BpzCZeG~>r4H!V82Aj^$5B+G zr$Y;d?a_tp>L0`Z3!ynw5d!&WFpeJ$$xH)eZTR$bh6K)YSGyHbdV zW?RF}%@Q7X-~pp=#$N#O#RU>tUQA<%?n56o8ga227k$|nV?E!@o!#l}UTN_pb7$t8 zbLO1;%{gD7RO=jQW`JLGB1|DTRF5lHn3^JLnFLK)~f8C-~ zX$FtePE@$G@ubN*__u|NX|AH-SNY9SkOyYC(}H!!Xy*Mh+@2x039#s3)GKmY zAjZslp~+?)l5b?J@4l7YKpRLs`DTu>i5Q+Zps7>T6v_T+Zhxai?Q-Dy@bDl}KQ3Bn zbH;P$ODuy(NEuy;+wF6q`kYvbg443Y^3iz=#7U4g(C^@lNQ4Mqgj(KBY zN-xvrl+iAjU3Rdwx-tun(V8mbv!T~y6&b|3UJ(teNa^ zBdws;b0Ef=7%Kn^QiH6M9SfX0%mU->fsL)JS}s#&Y$6;D@;n~q>h@2X_Oz{hhZJav zwby`?Y{x^bpRBLH3!LO*a#~vtjyFLA_8(x8E4FA?>+bkd{|zJ_q@|CXyP&Wy&d_~;uxc#jW$h;ZzG$E8S| zDPiyj{CngGiO2=&k5OwBXP*y#$_Ibn2haK7>`WqKr6c{Ue{>|3NLz6+XQ>p6_w*jz zy{k8VaPQtX%_H$6yLR`Qah6J-NM;6E(mHb}Yh^7qk{BKy?PsSkiDt)!*y)iINoI|w z63GEJn6@lw(VOU#I{U5kaZ3*OjhQ2<%vlzXk7W}5r{euXr{aT&6T=iKrN4MG)UT-J zzvrbKba9kW8#RSXE7SsG_|rt;=V%N84t^E>Ge8pH$OVP}0gwcKpQ5I4m5Sc|LnuHJ zuRebNL7=~un%d`64S!n0cVYt)=;Mx3`ulwFn1| zpRY7r=cfQg60iPm8m{Xoq(~ zV+iPQDG_r+JnOi+U*7ZJ>c05MgR6S}+=Hw7XOXe9BN?iK$XF&V`yn+-Tf>P+#v0GC z$Uq{KV3EGDF&0UW$_W+bh?S(Zl<&^K+HC>M8rJeiH8(xWLWO_dZ8J6S{V!E|E8 zawGYFU6{;~vfdloAPjQAbJe@)Ef?vzks8j%pr*^kRyjNB9s+6&wrV?^8DtAJ;BGns z5^_l?D!}c%{$C;-s*h{mMYh;e&lQ?7<=@MT*MGNb-w7j4uDJ0dK3$Z(>UYzk8tZz6 zCBFY*GD7Ki<5%`!eN!5Hw>?Q1{Cn+7uA=y_hqi~;9$DDv{7b8)(YR}i^T#(|*{kz! x +#include +#include "../include/labyrinth.h" +#include "../include/bfs.h" +#include "../include/queue.h" +#include "../include/coor.h" + +void bfs(Labyrinth* labyrinth){ + int i, j; + int arr[4] = {0, 1, 2, 3}, tmp, tp; + coor* cor = (coor*)malloc(sizeof(coor)); + coor* test; + cor->x = labyrinth->start.x; + cor->y = labyrinth->start.y; + queue(q); + queuePush(q, cor); + + while(!queueIsEmpty(q)){ + test = (coor*)q->front->element; + i = test->x; + j = test->y; + queuePop(q); + + if(i==labyrinth->end.x && j==labyrinth->end.y){ + queueFree(q); + find_path(labyrinth); + return; + } + + if(i!=labyrinth->start.x || j!=labyrinth->start.y) + labyrinth->at[i][j].color = GREEN; + + printLab(labyrinth); + + labyrinth->at[i][j].visited = true; + + + for(int h=3; h>0; h--){ + tmp = rand()%h; + tp = arr[h]; + arr[h] = arr[tmp]; + arr[tmp] = tp; + } + + // goes in the direction if possible + for(int h=0; h<4; h++){ + coor* cor2 = (coor*)malloc(sizeof(coor)); + if(arr[h]==0){ + if(i>0 && labyrinth->at[i-1][j].south && !labyrinth->at[i-1][j].visited){ + if(i-1!=labyrinth->end.x && j!=labyrinth->end.y) + labyrinth->at[i-1][j].color = ORANGE; + labyrinth->at[i-1][j].direction = UP; + cor2->x = i-1; + cor2->y = j; + queuePush(q, cor2); + } + }else if(arr[h]==1){ + if(jy_size-1 && labyrinth->at[i][j].east && !labyrinth->at[i][j+1].visited){ + if(i!=labyrinth->end.x && j+1!=labyrinth->end.y) + labyrinth->at[i][j+1].color = ORANGE; + labyrinth->at[i][j+1].direction = RIGHT; + cor2->x = i; + cor2->y = j+1; + queuePush(q, cor2); + } + }else if(arr[h]==2){ + if(iy_size-1 && labyrinth->at[i][j].south && !labyrinth->at[i+1][j].visited){ + if(i+1!=labyrinth->end.x && j!=labyrinth->end.y) + labyrinth->at[i+1][j].color = ORANGE; + labyrinth->at[i+1][j].direction = DOWN; + cor2->x = i+1; + cor2->y = j; + queuePush(q, cor2); + } + }else if(arr[h]==3){ + if(j>0 && labyrinth->at[i][j-1].east && !labyrinth->at[i][j-1].visited){ + if(i!=labyrinth->end.x && j-1!=labyrinth->end.y) + labyrinth->at[i][j-1].color = ORANGE; + labyrinth->at[i][j-1].direction = LEFT; + cor2->x = i; + cor2->y = j-1; + queuePush(q, cor2); + } + } + } + } +} \ No newline at end of file diff --git a/src/binaryTree.c b/src/binaryTree.c new file mode 100644 index 0000000..ce352cf --- /dev/null +++ b/src/binaryTree.c @@ -0,0 +1,70 @@ +#include +#include +#include +#include "../include/binaryTree.h" +#include "../include/labyrinth.h" + +Labyrinth* binaryTree_r(int n, int m, bool show); + +Labyrinth* binaryTree(int n, int m){ + return binaryTree_r(n, m, false); +} + +Labyrinth* binaryTreeShow(int n, int m){ + return binaryTree_r(n, m, true); +} + +// creates a labyrinth using the binaryTree algorithm +Labyrinth* binaryTree_r(int n, int m, bool show){ + int i, j, tmp; + Labyrinth* labyrinth = newLabyrinth(n, m); + + labyrinth->at[0][0].east = 1; + labyrinth->at[0][0].south = 1; + if(show){ + labyrinth->at[0][0].color = ORANGE; + printLab(labyrinth); + labyrinth->at[0][0].color = WHITE; + } + + for(i=1; iat[i-1][0].south = 1; + + if(show){ + labyrinth->at[i-1][0].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i-1][0].color = WHITE; + } + } + + for(j=1; jat[0][j-1].east = 1; + + if(show){ + labyrinth->at[0][j-1].color = ORANGE; + printLab(labyrinth); + labyrinth->at[0][j-1].color = WHITE; + } + + } + + for(i=1; iat[i][j].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][j].color = WHITE; + } + + tmp = rand()%2; + if(tmp) + labyrinth->at[i-1][j].south = 1; + else + labyrinth->at[i][j-1].east = 1; + } + } + + resetLabyrinth(labyrinth); + + return labyrinth; +} \ No newline at end of file diff --git a/src/depthFirst.c b/src/depthFirst.c new file mode 100644 index 0000000..5080fdb --- /dev/null +++ b/src/depthFirst.c @@ -0,0 +1,77 @@ +#include +#include +#include +#include "../include/depthFirst.h" + +void depthFirst_r(int i, int j, Labyrinth* labyrinth, bool show); + +// dfs search algorithm +Labyrinth* depthFirst(int n, int m){ + Labyrinth* labyrinth = newLabyrinth(n, m); + + depthFirst_r(rand()%n, rand()%m, labyrinth, false); + + resetLabyrinth(labyrinth); + + return labyrinth; +} + +Labyrinth* depthFirstShow(int n, int m){ + Labyrinth* labyrinth = newLabyrinth(n, m); + + depthFirst_r(rand()%n, rand()%m, labyrinth, true); + + resetLabyrinth(labyrinth); + + return labyrinth; +} + +// ricursive function used by depthFirst +void depthFirst_r(int i, int j, Labyrinth* labyrinth, bool show){ + labyrinth->at[i][j].visited = 1; + labyrinth->at[i][j].dp = -1; + + if(show){ + labyrinth->at[i][j].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][j].color = WHITE; + } + + int arr[4] = {0, 1, 2, 3}, tmp, tp; + for(int h=3; h>0; h--){ + tmp = rand()%h; + tp = arr[h]; + arr[h] = arr[tmp]; + arr[tmp] = tp; + } + + for(int h=0; h<4; h++){ + if(arr[h]==0){ + if(i>0 && !labyrinth->at[i-1][j].visited){ + labyrinth->at[i-1][j].south = 1; + depthFirst_r(i-1, j, labyrinth, show); + } + }else if(arr[h]==1){ + if(jy_size-1 && !labyrinth->at[i][j+1].visited){ + labyrinth->at[i][j].east = 1; + depthFirst_r(i, j+1, labyrinth, show); + } + }else if(arr[h]==2){ + if(ix_size-1 && !labyrinth->at[i+1][j].visited){ + labyrinth->at[i][j].south = 1; + depthFirst_r(i+1, j, labyrinth, show); + } + }else if(arr[h]==3){ + if(j>0 && !labyrinth->at[i][j-1].visited){ + labyrinth->at[i][j-1].east = 1; + depthFirst_r(i, j-1, labyrinth, show); + } + } + } + + if(show){ + labyrinth->at[i][j].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][j].color = WHITE; + } +} \ No newline at end of file diff --git a/src/dfs.c b/src/dfs.c new file mode 100644 index 0000000..b0ad722 --- /dev/null +++ b/src/dfs.c @@ -0,0 +1,67 @@ +#include +#include +#include "../include/labyrinth.h" +#include "../include/dfs.h" + +short dfs_r(Labyrinth* labyrinth, int i, int j); + +void dfs(Labyrinth* labyrinth){ + dfs_r(labyrinth, labyrinth->start.x, labyrinth->start.y); + find_path(labyrinth); +} + +short dfs_r(Labyrinth* labyrinth, int i, int j){ + if(i==labyrinth->end.x && j==labyrinth->end.y) + return 1; + + if(i!=labyrinth->start.x || j!=labyrinth->start.y) + labyrinth->at[i][j].color = GREEN; + + printLab(labyrinth); + + labyrinth->at[i][j].visited = 1; + + // randomly generates order of direction to try + int arr[4] = {0, 1, 2, 3}, tmp, tp; + for(int h=3; h>0; h--){ + tmp = rand()%h; + tp = arr[h]; + arr[h] = arr[tmp]; + arr[tmp] = tp; + } + + // goes in the direction if possible + for(int h=0; h<4; h++){ + if(arr[h]==0){ + if(i>0 && labyrinth->at[i-1][j].south && !labyrinth->at[i-1][j].visited){ + labyrinth->at[i-1][j].color = ORANGE; + labyrinth->at[i-1][j].direction = UP; + if(dfs_r(labyrinth, i-1, j)) + return 1; + } + }else if(arr[h]==1){ + if(jy_size-1 && labyrinth->at[i][j].east && !labyrinth->at[i][j+1].visited){ + labyrinth->at[i][j+1].color = ORANGE; + labyrinth->at[i][j+1].direction = RIGHT; + if(dfs_r(labyrinth, i, j+1)) + return 1; + } + }else if(arr[h]==2){ + if(iy_size-1 && labyrinth->at[i][j].south && !labyrinth->at[i+1][j].visited){ + labyrinth->at[i+1][j].color = ORANGE; + labyrinth->at[i+1][j].direction = DOWN; + if(dfs_r(labyrinth, i+1, j)) + return 1; + } + }else if(arr[h]==3){ + if(j>0 && labyrinth->at[i][j-1].east && !labyrinth->at[i][j-1].visited){ + labyrinth->at[i][j-1].color = ORANGE; + labyrinth->at[i][j-1].direction = LEFT; + if(dfs_r(labyrinth, i, j-1)) + return 1; + } + } + } + + return 0; +} \ No newline at end of file diff --git a/src/dijkstra.c b/src/dijkstra.c new file mode 100644 index 0000000..c2e5b85 --- /dev/null +++ b/src/dijkstra.c @@ -0,0 +1,117 @@ +#include +#include +#include +#include "../include/dijkstra.h" +#include "../include/priority_queue.h" + +typedef struct element{ + int dist; + int x; + int y; +} element; + +bool compare_element(element* e1, element* e2){ + return e1->dist > e2->dist; +} + +void toString(element* e){ + printf("(%d) %d %d\n", e->dist, e->x, e->y); +} + +void dijkstra_r(Labyrinth* labyrinth, int i, int j, int dist, priority_queue* queue); + +// dijkstra search algorithm +void dijkstra(Labyrinth* labyrinth){ + priority_queue(queue, compare_element); + queue->toString = toString; + + element* tmp = (element*)malloc(sizeof(element)); + tmp->dist = 0; + tmp->x = labyrinth->start.x; + tmp->y = labyrinth->start.y; + labyrinth->at[tmp->x][tmp->y].dp = 0; + priority_queuePush(queue, tmp); + + int a, b, c; + + while(!priority_queueIsEmpty(queue)){ + a = ((element*)priority_queueTop(queue))->dist; + b = ((element*)priority_queueTop(queue))->x; + c = ((element*)priority_queueTop(queue))->y; + + priority_queuePop(queue); + + dijkstra_r(labyrinth, b, c, a, queue); + printLab(labyrinth); + } + priority_queueFree(queue); + + find_path(labyrinth); + printf("test\n"); +} + +// ricursive function used by dijkstra +void dijkstra_r(Labyrinth* labyrinth, int i, int j, int dist, priority_queue* queue){ + + if(i==labyrinth->end.x && j==labyrinth->end.y){ + priority_queueClear(queue); + return; + } + + if(dist) + labyrinth->at[i][j].color = GREEN; + + // adds all four directions to the priority_queue + if(i>0 && labyrinth->at[i-1][j].south && labyrinth->at[i-1][j].dp<0){ + element* tmp = (element*)malloc(sizeof(element)); + tmp->dist = dist+1; + tmp->x = i-1; + tmp->y = j; + + priority_queuePush(queue, tmp); + + if(i-1!=labyrinth->end.x || j!=labyrinth->end.y) + labyrinth->at[i-1][j].color = ORANGE; + labyrinth->at[i-1][j].direction = UP; + labyrinth->at[i-1][j].dp = dist+1; + } + if(jy_size-1 && labyrinth->at[i][j].east && labyrinth->at[i][j+1].dp<0){ + element* tmp = (element*)malloc(sizeof(element)); + tmp->dist = dist+1; + tmp->x = i; + tmp->y = j+1; + + priority_queuePush(queue, tmp); + + if(i!=labyrinth->end.x || j+1!=labyrinth->end.y) + labyrinth->at[i][j+1].color = ORANGE; + labyrinth->at[i][j+1].direction = RIGHT; + labyrinth->at[i][j+1].dp = dist+1; + } + if(ix_size-1 && labyrinth->at[i][j].south && labyrinth->at[i+1][j].dp<0){ + element* tmp = (element*)malloc(sizeof(element)); + tmp->dist = dist+1; + tmp->x = i+1; + tmp->y = j; + + priority_queuePush(queue, tmp); + + if(i+1!=labyrinth->end.x || j!=labyrinth->end.y) + labyrinth->at[i+1][j].color = ORANGE; + labyrinth->at[i+1][j].direction = DOWN; + labyrinth->at[i+1][j].dp = dist+1; + } + if(j>0 && labyrinth->at[i][j-1].east && labyrinth->at[i][j-1].dp<0){ + element* tmp = (element*)malloc(sizeof(element)); + tmp->dist = dist+1; + tmp->x = i; + tmp->y = j-1; + + priority_queuePush(queue, tmp); + + if(i!=labyrinth->end.x || j-1!=labyrinth->end.y) + labyrinth->at[i][j-1].color = ORANGE; + labyrinth->at[i][j-1].direction = LEFT; + labyrinth->at[i][j-1].dp = dist+1; + } +} \ No newline at end of file diff --git a/src/eller.c b/src/eller.c new file mode 100644 index 0000000..bbc9e01 --- /dev/null +++ b/src/eller.c @@ -0,0 +1,137 @@ +#include +#include +#include +#include "../include/eller.h" +#include "../include/queue.h" + +#define ELLER_COST 2 + +Labyrinth* eller_(int n, int m, bool show); + +Labyrinth* eller(int n, int m){ + return eller_(n, m, false); +} + +Labyrinth* ellerShow(int n, int m){ + return eller_(n, m, true); +} + +Labyrinth* eller_(int n, int m, bool show){ + int i, j, h, tmp, tp; + Labyrinth* labyrinth = newLabyrinth(n, m); + + int sets[m][m]; + int setSizes[m]; + + queue(freeSets); + + int arr[m]; + for(i=0; iat[i][j].dp < 0){ + int* tmp = (int*)freeSets->front->element; + labyrinth->at[i][j].dp = *tmp; + queuePop(freeSets); + } + + tmp = labyrinth->at[i][j].dp; + sets[tmp][setSizes[tmp]] = j; + setSizes[tmp]++; + } + + // randomizes order + for(j=m; j>0; j--){ + tmp = rand() % j; + tp = arr[tmp]; + arr[tmp] = arr[j-1]; + arr[j-1] = tp; + } + + // randomly merge cells + for(j=0; jat[i][tmp].dp != labyrinth->at[i][tmp+1].dp && (rand()%ELLER_COST || i==n-1)){ + labyrinth->at[i][tmp].east = 1; + + tp = labyrinth->at[i][tmp].dp; + tmp = labyrinth->at[i][tmp+1].dp; + for(h=0; hat[i][sets[tmp][h]].dp = tp; + } + setSizes[tmp] = 0; + + int* s = (int*)malloc(sizeof(int)); + *s = tmp; + queuePush(freeSets, s); + + if(show){ + labyrinth->at[i][tmp].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][tmp].color = WHITE; + } + } + } + + // randomly makes cells go down + for(j=0; j1; h--){ + tmp = rand()%h; + tp = sets[j][tmp]; + sets[j][tmp] = sets[j][h-1]; + + if(rand()%ELLER_COST){ + labyrinth->at[i][tp].south = 1; + labyrinth->at[i+1][tp].dp = labyrinth->at[i][tp].dp; + down[j] = 1; + + if(show){ + labyrinth->at[i][tp].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][tp].color = WHITE; + } + } + } + + // last cell + if(setSizes[j] && (!down[j] || rand()%ELLER_COST)){ + labyrinth->at[i][sets[j][0]].south = 1; + labyrinth->at[i+1][sets[j][0]].dp = labyrinth->at[i][sets[j][0]].dp; + + if(show){ + labyrinth->at[i][sets[j][0]].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][sets[j][0]].color = WHITE; + } + } + } + } + + resetLabyrinth(labyrinth); + queueFree(freeSets); + + return labyrinth; +} \ No newline at end of file diff --git a/src/labyrith.c b/src/labyrith.c new file mode 100644 index 0000000..1eb5a71 --- /dev/null +++ b/src/labyrith.c @@ -0,0 +1,149 @@ +#include +#include +#include +#include "../include/labyrinth.h" + +void find_path_r(Labyrinth* labyrinth, int i, int j); + +Labyrinth* newLabyrinth(int n, int m){ + if(n<1 || m<1 || (n==1 && m==1)){ + printf("COGLIONE\n"); + exit(EXIT_FAILURE); + } + + Labyrinth* labyrinth = (Labyrinth* )malloc(sizeof(Labyrinth)); + labyrinth->x_size = n; + labyrinth->y_size = m; + + labyrinth->at = (Node** )malloc(n*sizeof(Node* )); + for(int i=0; iat[i] = (Node *)malloc(m*sizeof(Node)); + + for(int i=0; iat[i][j].dp = -1; + labyrinth->at[i][j].east = 0; + labyrinth->at[i][j].south = 0; + labyrinth->at[i][j].visited = 0; + } + } + + labyrinth->x_size = n; + labyrinth->y_size = m; + + labyrinth->start.x = rand()%n; + labyrinth->start.y = rand()%m; + + do{ + labyrinth->end.x = rand()%n; + labyrinth->end.y = rand()%m; + }while(labyrinth->start.x == labyrinth->end.x && labyrinth->start.y == labyrinth->end.y); + + return labyrinth; +} + +void resetLabyrinth(Labyrinth* labyrinth){ + for(int i=0; ix_size; i++){ + for(int j=0; jy_size; j++){ + labyrinth->at[i][j].color = WHITE; + labyrinth->at[i][j].visited = 0; + labyrinth->at[i][j].dp = -1; + } + } + + labyrinth->at[labyrinth->start.x][labyrinth->start.y].color = BLUE; + labyrinth->at[labyrinth->end.x][labyrinth->end.y].color = BLUE; +} + +void removeLabyrinth(Labyrinth* labyrinth){ + for(int i=0; ix_size; i++) + free(labyrinth->at[i]); + free(labyrinth->at); + free(labyrinth); +} + +void find_path(Labyrinth* labyrinth){ + find_path_r(labyrinth, labyrinth->end.x, labyrinth->end.y); +} + +void find_path_r(Labyrinth* labyrinth, int i, int j){ + labyrinth->at[i][j].color = BLUE; + // printLab(labyrinth); + + if(i==labyrinth->start.x && j==labyrinth->start.y) + return; + + if(labyrinth->at[i][j].direction == UP) + find_path_r(labyrinth, i+1, j); + else if(labyrinth->at[i][j].direction == RIGHT) + find_path_r(labyrinth, i, j-1); + else if(labyrinth->at[i][j].direction == DOWN) + find_path_r(labyrinth, i-1, j); + else if(labyrinth->at[i][j].direction == LEFT) + find_path_r(labyrinth, i, j+1); + else{ + printf("ERROR IN FIND_PATH\n"); + exit(EXIT_FAILURE); + } +} + +void printLab(Labyrinth* labyrinth){ + printLabWith(labyrinth, '|', '-', '+'); +} + +void printLabWith(Labyrinth* labyrinth, char wall, char floor, char corner){ + int i, j; + + system("clear"); + + for(j=0; jy_size; j++){ + printf("%c%c", corner, floor); + } + printf("%c\n", corner); + + for(i=0; ix_size; i++){ + printf("%c", wall); + + for(j=0; jy_size; j++){ + if(labyrinth->at[i][j].color == BLUE) + printf("\033[104m \033[49m"); + else if(labyrinth->at[i][j].color == GREEN) + printf("\033[102m \033[49m"); + else if(labyrinth->at[i][j].color == ORANGE) + printf("\033[103m \033[49m"); + else + printf(" "); + + if(labyrinth->at[i][j].east && jy_size-1){ + if(labyrinth->at[i][j+1].color == BLUE && labyrinth->at[i][j].color == BLUE) + printf("\033[104m \033[49m"); + else if((labyrinth->at[i][j+1].color == GREEN || labyrinth->at[i][j+1].color == BLUE) && (labyrinth->at[i][j].color == GREEN || labyrinth->at[i][j].color == BLUE)) + printf("\033[102m \033[49m"); + else if(!(labyrinth->at[i][j+1].color == WHITE) && !(labyrinth->at[i][j].color == WHITE)) + printf("\033[103m \033[49m"); + else + printf(" "); + }else + printf("%c", wall); + } + printf("\n"); + for(j=0; jy_size; j++){ + printf("%c", corner); + if(labyrinth->at[i][j].south && ix_size-1){ + if(labyrinth->at[i][j].color == BLUE && labyrinth->at[i+1][j].color == BLUE) + printf("\033[104m \033[49m"); + else if((labyrinth->at[i][j].color == GREEN || labyrinth->at[i][j].color == BLUE) && (labyrinth->at[i+1][j].color == GREEN || labyrinth->at[i+1][j].color == BLUE)) + printf("\033[102m \033[49m"); + else if(!(labyrinth->at[i][j].color == WHITE) && !(labyrinth->at[i+1][j].color == WHITE)) + printf("\033[103m \033[49m"); + else + printf(" "); + }else + printf("%c", floor); + } + printf("%c\n", corner); + } + printf("\n"); + + usleep(50000); +} \ No newline at end of file diff --git a/src/main.c b/src/main.c new file mode 100644 index 0000000..2e4de9f --- /dev/null +++ b/src/main.c @@ -0,0 +1,30 @@ +#include +#include +#include +#include "../include/dijkstra.h" +#include "../include/dfs.h" +#include "../include/labyrinth.h" +#include "../include/binaryTree.h" +#include "../include/depthFirst.h" +#include "../include/prim.h" +#include "../include/eller.h" +#include "../include/water.h" +#include "../include/bfs.h" + +#define N 15 +#define M 15 + +int main(){ + srand(time(0)); + + int n = N, m = M; + + Labyrinth* labyrinth1 = prim(n, m); + + water(labyrinth1); + printLab(labyrinth1); + resetLabyrinth(labyrinth1); + + + removeLabyrinth(labyrinth1); +} diff --git a/src/prim.c b/src/prim.c new file mode 100644 index 0000000..d608d41 --- /dev/null +++ b/src/prim.c @@ -0,0 +1,120 @@ +#include +#include +#include +#include "../include/coor.h" +#include "../include/prim.h" + +Labyrinth* prim_(int n, int m, bool show); + +Labyrinth* prim(int n, int m){ + return prim_(n, m, false); +} + +Labyrinth* primShow(int n, int m){ + return prim_(n, m, true); +} + +// creates a labyrinth using prim's algorithm +Labyrinth* prim_(int n, int m, bool show){ + int i, j, h, tmp, tp; + Labyrinth* labyrinth = newLabyrinth(n, m); + + int arr[4] = {0, 1, 2, 3}; + + coor frontier[n*m]; + coor current = {.x = rand()%n, .y = rand()%m}; + i = current.x; + j = current.y; + int frontierSize = 0; + + do{ + if(show){ + labyrinth->at[i][j].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][j].color = WHITE; + } + + + labyrinth->at[i][j].visited = 1; + + // adds frontier cells + if(i > 0 && labyrinth->at[i-1][j].dp < 0){ + frontier[frontierSize].x = i-1; + frontier[frontierSize].y = j; + frontierSize++; + labyrinth->at[i-1][j].dp = 1; + } + if(j < m-1 && labyrinth->at[i][j+1].dp < 0){ + frontier[frontierSize].x = i; + frontier[frontierSize].y = j+1; + frontierSize++; + labyrinth->at[i][j+1].dp = 1; + } + if(i < n-1 && labyrinth->at[i+1][j].dp < 0){ + frontier[frontierSize].x = i+1; + frontier[frontierSize].y = j; + frontierSize++; + labyrinth->at[i+1][j].dp = 1; + } + if(j > 0 && labyrinth->at[i][j-1].dp < 0){ + frontier[frontierSize].x = i; + frontier[frontierSize].y = j-1; + frontierSize++; + labyrinth->at[i][j-1].dp = 1; + } + + // randomly selects a frontier cell + tmp = rand()%frontierSize; + current = frontier[tmp]; + frontier[tmp] = frontier[frontierSize-1]; + frontierSize--; + + i = current.x; + j = current.y; + + // randomly joins the selected cell to another cell + for(h=3; h>0; h--){ + tmp = rand()%h; + tp = arr[h]; + arr[h] = arr[tmp]; + arr[tmp] = tp; + } + + tmp = 1; + for(h=0; h<4 && tmp; h++){ + if(arr[h]==0){ + if(i>0 && labyrinth->at[i-1][j].visited){ + labyrinth->at[i-1][j].south = 1; + tmp = 0; + } + }else if(arr[h]==1){ + if(jat[i][j+1].visited){ + labyrinth->at[i][j].east = 1; + tmp = 0; + } + }else if(arr[h]==2){ + if(iat[i+1][j].visited){ + labyrinth->at[i][j].south = 1; + tmp = 0; + } + }else if(arr[h]==3){ + if(j>0 && labyrinth->at[i][j-1].visited){ + labyrinth->at[i][j-1].east = 1; + tmp = 0; + } + } + + } + + }while(frontierSize); + + if(show){ + labyrinth->at[i][j].color = ORANGE; + printLab(labyrinth); + labyrinth->at[i][j].color = WHITE; + } + + resetLabyrinth(labyrinth); + + return labyrinth; +} \ No newline at end of file diff --git a/src/priority_queue.c b/src/priority_queue.c new file mode 100644 index 0000000..6830fee --- /dev/null +++ b/src/priority_queue.c @@ -0,0 +1,127 @@ +#include +#include +#include +#include "../include/priority_queue.h" + + +void priority_queueFixheap(priority_queue* q, int i); +void priority_queueHeapify(priority_queue* queue, int i); +void priority_queueSwap(void** a, void** b); + +priority_queue* newPriority_queue(bool (*compare)()){ + priority_queue* pq = (priority_queue*)malloc(sizeof(priority_queue)); + pq->size = 0; + pq->capacity = 0; + pq->growthFactor = PRIORITY_QUEUE_INIT_GROWTH_FACT; + + pq->compare = compare; + pq->toString = NULL; + + return pq; +} + +void priority_queuePush(priority_queue* pq, void* element){ + if(pq->size == pq->capacity){ + if(pq->capacity) + priority_queueResize(pq, pq->capacity * pq->growthFactor); + else + priority_queueResize(pq, 1); + } + + pq->at[pq->size] = element; + pq->size++; + + priority_queueFixheap(pq, pq->size-1); +} + +void priority_queueFixheap(priority_queue* pq, int i){ + if(!i) + return; + if(pq->compare(pq->at[(i-1)/2], pq->at[i])) + priority_queueSwap(pq->at[i], pq->at[(i-1)/2]); + + priority_queueFixheap(pq, (i-1)/2); +} + +void priority_queuePop(priority_queue* pq){ + if(!pq->size){ + fprintf(stderr, "POP ON EMPTY PRIORITY_QUEUE\n"); + return; + } + + priority_queueSwap(&pq->at[0], &pq->at[pq->size-1]); + free(pq->at[pq->size-1]); + pq->size--; + priority_queueHeapify(pq, 0); +} + +void priority_queueHeapify(priority_queue* pq, int i){ + if(i >= (pq->size)/2) + return; + + int minson; + if(pq->size-1 == 2*i+1 || !pq->compare(pq->at[2*i+1], pq->at[2*i+2])) + minson = 2*i+1; + else + minson = 2*i+2; + + if(pq->compare(pq->at[i], pq->at[minson])){ + priority_queueSwap(&pq->at[i], &pq->at[minson]); + priority_queueHeapify(pq, minson); + } +} + +void priority_queueSwap(void** a, void** b){ + void* tmp = *a; + *a = *b; + *b = tmp; +} + +void priority_queueResize(priority_queue* pq, int capacity){ + for(int i=pq->size; i>capacity; i--) + free(pq->at[i-1]); + + void **at = realloc(pq->at, sizeof(void *) * capacity); + pq->at = at; + pq->capacity = capacity; +} + +void priority_queueClear(priority_queue* pq){ + priority_queueResize(pq, 0); + pq->size = 0; +} + +void priority_queueFree(priority_queue* pq){ + priority_queueClear(pq); + free(pq->at); + free(pq); +} + +void priority_queueShrink_to_fit(priority_queue* pq){ + priority_queueResize(pq, pq->size); +} + +bool priority_queueIsEmpty(priority_queue* pq){ + return pq->size > 0 ? false : true; +} + +void* priority_queueTop(priority_queue* pq){ + if(!pq->size){ + fprintf(stderr, "PRIORITY_QUEUE IS EMPTY\n"); + return NULL; + } + + return pq->at[0]; +} + +void priority_queuePrint(priority_queue* pq){ + if(pq->toString == NULL){ + fprintf(stderr, "TOSTRING NOT DEFINED\n"); + return; + } + + for(int i=0; isize; i++) + pq->toString(pq->at[i]); + + printf("\n"); +} \ No newline at end of file diff --git a/src/queue.c b/src/queue.c new file mode 100644 index 0000000..c28e747 --- /dev/null +++ b/src/queue.c @@ -0,0 +1,99 @@ +#include +#include +#include "../include/queue.h" + +queue* newQueue(){ + queue* tmp = (queue*)malloc(sizeof(queue)); + tmp->size = 0; + + tmp->toString = NULL; + tmp->front = NULL; + tmp->back = NULL; + + return tmp; +} + +void queuePush(queue* q, void* element){ + queue_element* qel = (queue_element*)malloc(sizeof(queue_element)); + qel->element = element; + qel->next = NULL; + + if(queueIsEmpty(q)){ + q->front = qel; + q->back = qel; + }else{ + q->back->next = qel; + q->back = qel; + } + + q->size++; +} + +void queuePrint(queue* q){ + if(q->toString == NULL){ + fprintf(stderr, "TOSTRING NOT DEFINED\n"); + return; + } + + queue_element* tmp = q->front; + while(tmp){ + q->toString(tmp->element); + tmp = tmp->next; + printf("\n"); + } + + printf("\n"); +} + +void queuePop(queue* q){ + if(queueIsEmpty(q)){ + fprintf(stderr, "QUEUE IS EMTPY\n"); + return; + } + + queue_element* tmp = q->front->next; + free(q->front->element); + free(q->front); + q->front = tmp; + q->size--; +} + +bool queueIsEmpty(queue* q){ + return q->size == 0; +} + +void queueMerge(queue* q1, queue* q2){ + if(queueIsEmpty(q1)) + q1->front = q2->front; + else + q1->back->next = q2->front; + + q1->back = q2->back; + q1->size += q2->size; + + q2->front = NULL; + q2->back = NULL; + q2->size = 0; +} + +void queueClear(queue* q){ + queue_element* tmp = q->front, *tp; + while(tmp){ + tp = tmp->next; + free(tmp->element); + free(tmp); + tmp = tp; + } + + q->front = NULL; + q->size = 0; +} + +void queueFree(queue* q){ + queueClear(q); + free(q); +} + +void* queueTop(queue* q){ + return q->front; +} \ No newline at end of file diff --git a/src/water.c b/src/water.c new file mode 100644 index 0000000..c2e2263 --- /dev/null +++ b/src/water.c @@ -0,0 +1,163 @@ +#include +#include +#include +#include "../include/labyrinth.h" +#include "../include/water.h" +#include "../include/priority_queue.h" +#include "../include/queue.h" + +bool compare_water(coor* c1, coor* c2){ + return c1->x < c2->x; +} + +void pp(coor* c1){ + printf("%d %d", c1->x, c1->y); +} + +int qmin(queue* q); + +void expand(coor* c, Labyrinth* labyrinth, queue* pq); + +void water(Labyrinth *labyrinth){ + int i, min; + + queue(pq); // DA METTERE RBTREE (mai) + coor* tmp = (coor*)malloc(sizeof(coor)); + tmp->x = labyrinth->start.x; + tmp->y = labyrinth->start.y; + labyrinth->at[tmp->x][tmp->y].dp = 0; + + queuePush(pq, tmp); + pq->toString = pp; // TMP + + queue(q); + q->toString = pp; + + + while(!queueIsEmpty(pq)){ + printf("size: %d\n", pq->size); + queuePrint(pq); + + min = qmin(pq); + printf("min: %d\n", min); + queue_element* qelem = pq->front; + queue_element* prev = NULL; + + while(qelem){ + + printf("cons: "); + pp(qelem->element); + printf("\n"); + if(((coor*)qelem->element)->x == min){ + if(((coor*)(qelem->element))->x == labyrinth->end.x && ((coor*)(qelem->element))->y == labyrinth->end.y) + return; + + printf("in elem: "); + pp(qelem->element); + printf("\n"); + expand(qelem->element, labyrinth, q); + labyrinth->at[((coor*)qelem->element)->x][((coor*)qelem->element)->y].color = GREEN; + + if(prev) + prev->next = qelem->next; + else + pq->front = qelem->next; + + pq->size--; + + if(!qelem->next) + pq->back = prev; + + free(qelem->element); + free(qelem); + + }else{ + prev = qelem; + } + + if(prev) + qelem = prev->next; + else if(pq->front) + qelem = pq->front->next; + else + qelem = NULL; + + } + + printf("newqueue: %d\n", pq->size); + queuePrint(pq); + printf("p: %d\n", q->size); + queuePrint(q); + + queueMerge(pq, q); + printf("new: %d\n", pq->size); + queuePrint(pq); + + printLab(labyrinth); + scanf("%d", &i); + } +} + + +void expand(coor* c, Labyrinth* labyrinth, queue* q){ + int i = c->x, j = c->y; + + if(i>0 && labyrinth->at[i-1][j].south && labyrinth->at[i-1][j].dp<0){ + coor* tmp = (coor*)malloc(sizeof(coor)); + tmp->x = i-1; + tmp->y = j; + + queuePush(q, tmp); + + labyrinth->at[i-1][j].direction = UP; + labyrinth->at[i-1][j].color = ORANGE; + labyrinth->at[i-1][j].dp = 0; + } + if(jy_size-1 && labyrinth->at[i][j].east && labyrinth->at[i][j+1].dp<0){ + coor* tmp = (coor*)malloc(sizeof(coor)); + tmp->x = i; + tmp->y = j+1; + + queuePush(q, tmp); + + labyrinth->at[i][j+1].direction = UP; + labyrinth->at[i][j+1].color = ORANGE; + labyrinth->at[i][j+1].dp = 0; + } + if(ix_size-1 && labyrinth->at[i][j].south && labyrinth->at[i+1][j].dp<0){ + coor* tmp = (coor*)malloc(sizeof(coor)); + tmp->x = i+1; + tmp->y = j; + + queuePush(q, tmp); + + labyrinth->at[i+1][j].direction = UP; + labyrinth->at[i+1][j].color = ORANGE; + labyrinth->at[i+1][j].dp = 0; + } + if(j>0 && labyrinth->at[i][j-1].east && labyrinth->at[i][j-1].dp<0){ + coor* tmp = (coor*)malloc(sizeof(coor)); + tmp->x = i; + tmp->y = j-1; + + queuePush(q, tmp); + + labyrinth->at[i][j-1].direction = UP; + labyrinth->at[i][j-1].color = ORANGE; + labyrinth->at[i][j-1].dp = 0; + } +} + + +int qmin(queue* q){ + queue_element *tmp = q->front; + coor min = {.x = 0}; + while(tmp){ + if(compare_water(&min, tmp->element)) + min.x = ((coor*)tmp->element)->x; + + tmp = tmp->next; + } + + return min.x; +} \ No newline at end of file