PATH FINDING VISUALIZER
Deva Kumari Maddukuri Dhara Lakshmi Kusumanchi
dept.of computer science and engineering
Amrita vishwa vidyapeetham
Amrita school of computing,Banglore,India Amrita school of computing,Banglore,India
maddukurideva@gmail.com
Harsha Vardhan Ramisetty
dept.of computer science and engineering dept.of computer science and engineering
Amrita vishwa vidyapeetham
Amrita school of computing,Banglore,India Amrita school of computing,Banglore,India
harshavardhanramisetty@gmail.com
Abstract—NeoRoute is an algorithm visualizer tool that assists in
finding the path.present complex pathfinding algorithms dynamically
through an interactive display.enjoyable way. The pathfinding
technique is mainly used in the field of computer science.and
designing the most optimal route through the use of algorithms and
engineering.the two ends of a line in a network or graph.Gaming,
robotics, transportation,path finding applications can be seen in
education, transportation, etc.for instance, Google Maps utilizes
Dijkstra’s and A* algorithms in order to find the shortest path. In
addition to the algorithms employed by Google Maps,The NeoRoute
app has BFS and DFS algorithms for visualization as well.User is
presented with a grid, which contains a start node and a target.station
that can be relocated flexibly. Users can as well add blobs or a
bomb.which behave as the dynamic inputs or the ones that take
patterns directly from the templates.time. Afterwards, the users can
have pathfinding algorithms from the list.implementable algorithms.
Then, the grid is filled in with some.the engaging animations
illustrating the least direct route.start and target nodes. Such tool has
the ability to be used by students and teachers.and introduces
newbies to the fundamentals of coding about how pathing algorithms
work. These devices are also able to discriminate between what is real
and what isn’t.multiple routing algorithms and hence adopt an
appropriate one for the future projects. BFS and DFS Algorithm BFS
(Breadth-First Search) and DFS(Depth-First Search) are graph traversal
algorithms that help to check all parts of a graph.nodes that make up
the graph or maze at hand. BFS begins with the root node.go through
the graph first and visit all the nodes that are neighbors before getting
on.next-node on the graph. It employs a queue data structure for
monitoring the underexplored nodes to further the search. Index
Terms—Path finding visualizer,BFS,DFS
Index Terms—component, formatting, style, styling, insert
I. INTRODUCTION
In[1] It was expected that algorithm visualization would
completely change the way algorithms are taught. Many
algorithm animations had appeared, mostly for simple
problems like primary tree data structures and sorting. There
were even
Identify applicable funding agency here. If none, delete this.
attempts to robotize development of animated algorithms and
algorithm visualization. In[2] Finding a route is closely related
dept.of computer science and engineering
Amrita vishwa vidyapeetham
dharalakshmi436@gmail.com
Tanvi Yelakanti
Amrita vishwa vidyapeetham
yelakantitanvi@gmail.com
to the problem of the short route, within the theory of the
graph, which explores the method of identifying the route. We
are also adding A* algorithm approach here. Which is different
from dijkastra approach. Sometimes A* faces conflict in the
short path between source and destination because of
multiple agents.In[3] The shortest path problem can be solved
using a variety of approaches. We have implemented Graphical
interface based A* Heuristic Path finding algorithm and
Dijkstra Algorithm In[4]Pathfinding or pathing is the plotting,
by a computer application, of the shortestroute between two
points. It is a more practical variant on solving mazes.This field
of research is based heavily on Dijkstra’s algorithm for finding
theshortest path on a weighted graph. In[5]At present, e-
learning is being promoted at a very high rate among learners
in different areas. Modern technologies allows the
development of visualization tools for topics like different
algorithms of graph theory and their explanation. The
implementation of e-learning tools like this is one of the most
important requirement for applying e-learning system
successfully. In[6]Data Structures and Algorithms are one of
the most vital concepts of Computer Science. However, due to
its level of abstraction and complexity, an absolute
understanding of this concept can be a challenging task.
Textbooks and PowerPoint slides are the mainstream sources
of teaching algorithms in schools/colleges today which lacks a
potent environment for the students to truly grasp the
conceptual understanding of the world of algorithms.
In[7]They offered a novel way to comprehend sorting,
searching problems, and the application of different data
structures, such as trees, hash maps, and graphs, through the
visual representation of animated algorithms. The
development of animation tools and libraries facilitated
research and advancement in the realm of computer
graphics.In[8]NeoRoute is a pathfinding visualizer tool that
helps visualize complex pathfinding algorithms in a
fun way. Due to their complexity, these algorithms are not well
understood by beginners in programming. There is an ample
amount of theoretical knowledge available over the internet
and in academic books about pathfinding algorithms but an
algorithm has to be seen in action to be believed and
understood effectively. In[9]In pathfinding when a new
algorithm or data structure is proposed it is tested on set of
different maps. Therefore, the main focus of this thesis is to
study the various aspects of maps, generated in pathfinding
experiments, like the path length, the density of obstacles,
map size and so on as the performance of newly built algorithm
is tested on these maps thus it is an important aspect of
pathfinding experiments.In[10]Pathfinding is also known as
plotting or pathing. this work use a computer program that
particularly finds a shortest path connecting two locations. It
can also be used as a more useful maze-solving method. This
study is primarily centred on Dijkstra’s algorithm (weighted or
non-weighted graph) for determining the shortest path that
best meets some conditions. A pathfinding approach
fundamentally searches the adjacent nodes of the current
node. It begins at one vertex in a graph, and looks nearby
nodes till it reaches the destination node, typically with the
least expensive path. Although, if a route is needed, some
graph searching techniques like BFS or DFS can be used.
In[11]“Design and Analysis of Algorithms”, is one of those
important subjects in the field of computer science. Besides
the requisite of being skilled in computational thinking and
programming skills, the topic of algorithms is often perceived
as complicated and difficult to understand. Motivated by the
age-old saying, “a picture speaks more than a thousand
words”, many researchers and educators assume that students
would learn an algorithm faster and more thoroughly using
algorithm visualization techniques. Pathfinding or pathing is
defined as plotting the shortest route between two points
using computations. For this purpose, computers use various
algorithms such as BFS, DFS, and many more. These algorithms
widely known as pathfinding or pathing algorithms are used for
network routing, mapping locations, telecommunication, and
navigation. NeoRoute is a pathfinding visualizer tool that helps
visualize complex pathfinding algorithms in a fun way. Due to
their complexity, these algorithms are not well understood by
beginners in programming. There is an ample amount of
theoretical knowledge available over the internet and in
academic books about pathfinding algorithms but an algorithm
has to be seen in action to be believed and understood
effectively. NeoRoute does the same by visually representing
how the above mentioned algorithms work. It currently
supports BFS, and DFS algorithms. This tool provides an
interactive GUI where users can provide input in the form of
adding blocks, or/and adding a bomb (an object that acts as a
checkpoint). The start node and the target node can be easily
relocated over the grid. The purpose of this web application is
to assist students and young programming enthusiasts in
understanding the difference between various pathing
algorithms and provide them with a platform to aid their
learning. The best way to learn any algorithm is to visualize it.
Since it is a tedious task to visualize complex algorithms such
as pathfinding algorithms there is a need for some modern
tools to help lecturers and students simplify these
concepts.using high and new technologies.[12]In order to
more closely resemble human navigation, this work provides a
novel approach to path discovery for intelligent agents using
methods borrowed from human brain research. The idea
behind the method is the ’GPS of the brain’. By means of user
research, we demonstrate that the generated paths are
perceived as consistent with the agents’ assigned degree of
proficiency. The study solely deals with path finding within a
navigation mesh, since collision avoidance may be handled
with any local movement approach. This method is unique in
that it takes into account human characteristics like as
memory, mental maps, and visibility, all of which contribute to
the overall realism of autonomous agents and video
games.[13]A study on the use of machine learning to forecast
traffic accidents and enhance public health worldwide is
presented in this article. To find relationships in the data, the
study employs a classic Association Rule Mining methodology,
the Apriorist algorithm, and the Road Accident Dataset.
Information is categorized and driving advise is given using a
probability-based classification technique called the Naive
Bayes Technique. The project aims to decrease the amount of
fatalities and injuries on the world’s highways and increase the
prediction accuracy of traffic accidents. In this situation,
machine learning could improve institutional ability to address
public health issues related to mobility and ultimately increase
overall road safety.[14]This paper proposes a faster version of
the FastMap approach that can incorporate edge-weighted
undirected graphs in near-linear time. FastMap, a conventional
and effective data-mining technique, has been used to
generate algorithms for shortest path computations. However,
the original FastMap method assumed that it could always
determine the (dis)similarities between the input elements. It
is necessary to apply shortest path algorithms, such as
Dijkstra’s algorithm, to determine the distance between two
nodes in a graph.The arrangement of the study is as follows:
First, the work’s foundation—the shortest path FastMap
algorithm—is described. After that, the SPFA is presented and
combined with FastMap to produce FMS. The analysis and
experimental results are then presented, followed by a
discussion of the conclusions and next steps.[15]The paper
aims to summarize the widelyused off-road pathfinding
algorithms and optimize the off-road environment in a wide
range. Additionally, the study highlights problems with off-road
pathfinding and considers its future direction while contrasting
local and global pathfinding.Off-road pathfinding enables
people to travel through locations without main roads or
designated routes, whereas on-road pathfinding is restricted to
driving on designated roads. This work aims to identify the use
of pathfinding in the off-road environment and give new
researchers a knowledge of the particular problem area. Along
with identifying problems and outlining future directions for
off-road pathfinding, the paper provides a summary of popular
off-road pathfinding algorithms.[16]This paper proposes a
faster version of the FastMap approach that can incorporate
edge-weighted undirected graphs in nearlinear time. FastMap,
a conventional and effective data-mining technique, has been
used to generate algorithms for shortest path computations.
However, the original FastMap method assumed that it could
always determine the (dis)similarities between the input
elements. It is necessary to apply shortest path algorithms,
such as Dijkstra’s algorithm, to determine the distance
between two nodes in a graph.The arrangement of the study is
as follows: First, the work’s foundation—the shortest path
FastMap algorithm—is described. After that, the SPFA is
presented and combined with FastMap to produce FMS. The
analysis and experimental results are then presented, followed
by a discussion of the conclusions and next steps.[17]The
paper aims to summarize the widely-used off-road pathfinding
algorithms and optimize the off-road environment in a wide
range. Additionally, the study highlights problems with off-road
pathfinding and considers its future direction while contrasting
local and global pathfinding.Off-road pathfinding enables
people to travel through locations without main roads or
designated routes, whereas on-road pathfinding is restricted to
driving on designated roads. This work aims to identify the use
of pathfinding in the off-road environment and give new
researchers a knowledge of the particular problem area. Along
with identifying problems and outlining future directions for
off-road pathfinding, the paper provides a summary of popular
off-road pathfinding algorithms.
II. LITERATURE SURVEY
[1]This is a project where I made a pathfinding pathfinding
visualizer using graph theory and algorithms to find a path
whenever a user selects the source and target. The project
uses Pygame for the front end and Different pathfinding
algorithms like BFS, A*, DFS, and Dijkstra’s. The goal behind this
project is to find the cheapest path between two points on a
huge network. In this paper, we will be focusing on A* and its
heuristic function that allows us to easily change how we
compute the shortest path. However, as A* is an uninformed
search, it will not always provide the correct result. This project
is written in Python which has lots of features and it is cross-
platform. The pathfinding application is made using some basic
tools from Pygame that makes it really easy for the user to
interact with. He/She can select the end and the start points
themselves, also they can place any sort of wall to prevent the
shortest path. This application is ready to use. And, the code is
also pretty modular, that you can just plug and play it with any
project. You can also tune these with other Graphs as well. In
this paper, we will attempt to analyze compare their response
time due to different number of iterations and at a time when
they get the best shortest path.[2]Pathfinding algorithms play
a fundamental role in the navigation by a robot through huge
terrains, they help it to find the most favourable way from a
starting point to a destination. Not only time but also cost,
distance, etc. are the factors considered to decide the best
path. Various algorithms like BFS, DFS, Dijkstra, A* Search, IDA*
Search, Jump Point Search, etc. are available to accomplish this
functionality. The research project will simulate the execution
of these algorithms. The report will contain test simulations
and comparisons between the various algorithms. There might
be different situations like finding time to reach, distance to
reach, cost of reaching, etc., but the goal is to find the best path
possible. This approach once used can be applied to various
areas like traffic management, digital mapping, social
networking, robotics and game development. Methodology
The 2D Grid is taken and each turn and node to node
movement will have a cost of 1. We will add the project
interface to clear the path, add or remove obstacles, reset the
grid and control the visualization speed.[3]This paper
showcases a pathfinding visualizer which uses graph theory
and the Pygame library for finding an optimal path between a
source node and a target node. The project implements several
data structures and algorithms such as BFS, DFS, A*, Dijkstra’s
and provides wall and maze generation features to create
multivariate graphs. The visualizer offers a userfriendly
interface to present the path with the use of red, blue, orange
and green nodes making it easier to analyze paths in a large
multivariate graph. This project can be used in various real-
world applications like social networks, computer networks,
etc. Some future work includes path exploration, path analysis,
and customizable real-time aggregate set and graph visualizer
to combine several real-time updates. The visualizer gives real-
time updates about the path information, so the user can
directly visualize the change in the graph properties and
algorithms. The modularity of the project allows the
integration of more algorithms and features in the future for
further development and research in the pathfinding and
graph analysis areas.[4]Using visuals to show how algorithms
work helps in teaching computer science. But, schools and
colleges don’t use it much. This paper shows two crucial factors
for successful algorithm visualization: easyto-get software and
showing why an algorithm works. Using invariants, which don’t
change, can help explain the main ideas of an algorithm. This
paper also talks about how scripting languages like JavaScript
can make complex visualizations, even 3D animations.
Although today’s hardware is strong, algorithm visualization
tools often need compilers and runtime machines which can
make them harder to get. Lastly, the paper discusses the
software needs for algorithm visualization systems, like how
fast animations go, how hard they are to program, and how
many people can use them.[5]This paper introduces the
development of an e-Learning tool named PathFinding
Visualizer, which can visually represent shortest path-related
algorithms including Dijkstra’s algorithm, A*, and DFS. This tool
will be helpful to understand the concepts of these algorithms
more effectively with an improved userfriendly interface. The
algorithm was implemented in a webbased platform using
HTML, CSS, JavaScript, along with React Framework. The initial
test results show that the developed e-Learning tool gives
positive results to the students learning the algorithms. The
tool has several practical applications such as on maps, road
networks, or robot navigation. Different external or internal
pathways can be used to help different students remember the
steps, or let everyone find their own way. They can also add
some obstacles in the path. Thanks to the visual display and
the effect of animation, the final effect of the e-Learning
PathFinding Visualizer is good in terms of memorization and
the enhancement of More active learning situations.
[6]NeoRoute pathfinding algorithm visualizer. An interactive
way to understand pathfinding algorithms. It can visualize
Dijkstra’s algorithm, A* algorithm, Bidirectional algorithm, BFS,
and DFS algorithms. Web Page of NeoRoute The web page
contains visualization of Dijkstra’s algorithm, A* algorithm,
Bidirectional algorithm, BFS, and DFS. You can interact with the
application by clicking, dragging and scrolling. Click and drag to
add blocks or bomb over the grid, the GUI also has next pattern
generators to make it easy. A start or target node can be
created directly by dragging and dropping over the grid The
web page is largely aimed towards students, teachers,
beginners in programming. It allows them to study how the
pathing algorithms work and also to compare pathing
algorithms. It can help you to choose the right algorithm for
your upcoming projects. The tool is accurate in the
visualization of the provided pathfinding algorithms. A*
algorithm is the most efficient of all. It can also generate the
shortest path in less time. NeoRoute works better in Graphical
User Interface as it is interactive to use than other available
pathfinding algorithm visualizers.[7]The project is an incredible
visual exploration of the BFS and Dijkstra’s Algorithm. The
project utilizes a 2D grid with nodes as walls or cells and uses
two algorithms to traverse the 2D grid and find the shortest
path between a starting point and an ending point. The project
was developed in six steps - building the graph matrix; adding
walls and some event listeners; embedding the algorithms;
running the algorithms; media queries; and a little design and
UI improvements. BFS algorithm goes through a grid one layer
at a time and exhibits laziness. Dijkstra’s algorithm, on the
other hand, uses a priority queue to find the shortest path
earlier than BFS. The project visualized the performance of the
algorithms and also demonstrated the time to work of the
algorithms which can help us determine the effectiveness of
the algorithms in particular scenarios. Finally, this can be a
good and easily understandable project for either an educator
to demonstrate the concepts of graph pathfinding or for some
students.[8]The PDF is a study of pathfinding algorithms:
Implementation and Visualization Pathfinding is defined as
finding a shortest or optimal path between two points in a map
or a graph. Algorithm visualization is found more effective in
learning. Dijkstra’s algorithm is a pathfinding algorithm that is
extensively used in the field. It assigns distance value to each
vertex and is widely used algorithm. A* (A-star) algorithm is
another well known graph traversal and path search algorithm.
It evaluates a node using three values. Breadth-first search
(BFS) and depth-first search (DFS) are two other algorithms
used for graph traversal and path finding. Our review of
pathfinding research papers indicate that: A lot of research in
the field has been conducted, but none of the paper’s setups
are ideal. The majority of the papers use randome map or
game maps, which do not give a good basis for making
comparisons between them and give enough evidence to
generalize for real world. A visual very tool named Pathfinder,
is presented. It is a visual solution for path analysis. it provides
an easy way for user to find an optimal path between two
points. It can be used to serve most of pathfinding needs, but
special care has been taken to present a tool for path
exploration and path analysis. [9]This research
paper”Performance Evaluation of Pathfinding Algorithms” by
Harinder Kaur Sidhu, from the University of Windsor, 2019.
Pathfinding algorithms are used in countless applications, such
as computer games, robotics, networks, and navigation
systems. In this thesis, the author investigates whether or not
common weaknesses in the experimental design and data
analysis found in pathfinding algorithm research can be
detected, and methods devised to remedy these weaknesses.
It also describes various types of map representation, and
evaluates their impact on the performance of pathfinding
algorithms. I look forward to reading it and to learning what
the author has discovered about how to design and analyze
experiments in pathfinding research.[10]The proposed system
enhances e-learning tools and supports the visualization of
complex algorithms, particularly pathfinding algorithms. By
offering self-explanatory animations and a user-friendly
interface, the system promotes autonomy in learning, fosters
active learning, and enhances knowledge retention. This tool
is valuable in various fields, including e-learning, computer
graphics, and software development. Future improvements
may include incorporating sophisticated algorithms,
interactive simulations, and more extensive support for data
analysis models. The development of this tool is greatly aided
by the guidance of Prof. Sayali Haldavanekar and the support
of teachers, friends, and colleagues. The system effectively
combines interactive visualizations with an accessible and
intuitive interface, ensuring the engagement and success of
users across a wide range of educational applications. Overall,
this system significantly advances the potential of e-learning
tools and offers valuable insights into complex algorithms and
their associated functions.[11]This context tells us about
Imagining and understanding something which is not
physically visible to us can be difficult at times. Visualization of
the processes based on their overall time required for CPU
execution (i.e., burst time) and selection of various processes
on the basis of the algorithm one by one, can be used to
provide a clear understanding of how the algorithm is working
in the actual scenario. Thus, we can add this feature of
scheduling algorithm visualization and other topics to expand
the knowledge base of our application. [12] In this paper, a
novel approach that minimizes both elevation and distance
between any two points on specific area data set is introduced.
In this context the heuristic-based method is a modification of
Dijkstra’s algorithm, which determines the cost of traversing
the SN from one node to another. The paper also proposes a
visualization tool that enables the users to navigate through
various steps in the algorithm and, consequently, observe the
construction of the smoothest trajectory. The idea behind this
application is to base it on a concept that will be very beneficial
for students who are studying artificial intelligence, graphics,
and computers. [13] These challenges include the type of
surface, steepness, and obstacles encountered while off-
roading; this file discusses off-road pathfinding algorithms,
especially global and local off-road methods. The authors
overview several off-road pathfinding algorithms that worked
effectively in the game environment: A* algorithm, Dijkstra’s
algorithm, and Ant Colony Optimization and identify their
strengths and weaknesses. They also distinguish and discuss
how global and local pathfinding algorithms work, pertaining
to these aspects: offline/online computation,
mapbased/sensor-based operation, and data pre-processing.
To sum up, this study indicated that a way of pathfinding
utilized by an off-road model is effective in the various
disciplines such as robotics, the military, archeology, forestry,
and search and rescue. It also outlines the future directions of
off-road pathfinding challenges that are still unsettled which
include the absence of benchmarks to measure off-road
pathfinding performance, memory intensiveness, and path
optimality. The former observations have implications for
improving heuristics for the off-road path planning problem.
[14] New heuristic search algorithm, called focused D* (delta-
star), which can ensure the necessary accuracy of the results
and acceptable level of number of calculations to solve the
pathfinding problems in dynamic environment, were
introduced by the authors of this study. D* algorithm can thus
be seen as an improvement of the A* algorithm, since by using
an upper constraint to elimitate suboptimal search paths the
algorithm performs two functions. The lower bound function
is then employed to adjust this upper bound in order to
minimize the number of entities enlarged and distance.
Research has demonstrated effectiveness of the focused D*
method in several experiments with problem solving tasks
consisting of memory based heuristics for explicit state, real
time navigation in unknown environment and eight neighbor
grid setting. In a comparison with Dijkstra’s algorithm for
pathfinding in dynamic conditions, the presented algorithm is
more precise and effective in general. [15] In this paper, the
author introduces a new algorithm for path finding of
autonomous agents based on the current theoretical findings
concerning the neural structure and learning capability of the
human brain. The program is based on the results of studies
that investigated the neuron activity in the memory and
visualizes the space as a set of counters put in a hexagonal grid.
The path finder also integrates an A* referencing in line with
this cognitive map with a method of searching new settings
while constructing such a map in the mind. This is done by
several generated paths depicting how the paths are
shortened and become an ideal A* search the more the agent
gains its environs. Further, the authors run perceptual analysis
to explain that expected level of understanding of the viewers
could be identified by the viewers in question at the level of
probability. [16] From the authors of this study, a pathfinding
algorithm based on triangulation for Any-Angle from and to is
available. They test it against other methods, applicable to
modern state-of-art algorithms such as Dijkstra’s and Jump
Point Search (JPS). In the best-case scenario, which
corresponds to the Optimal Any-Angle Pathfinding (OAPF)
algorithm, their algorithm performs as well as the best and is
faster than JPS and Dijkstra’s algorithm in the 3D-GRA
benchmark. It also cites a study of the factors which can
influence the algorithm performance measure including path
quality order, triangulation size and the geometry input. Their
approach operates more efficiently on this triangulation
because it does not re-triangulate the navigation mesh while
searching for paths and bypasses the computation of costly
derivatives. [17] This paper develops an empirical research in
relations to the use of Big data analytics in decision support
and Traffic accident study for enhanced safety. Data of traffic
accident was collected and analyzed in this study with the help
of using databases of Finnish Road Administration. The
machine learning the method taken in this research work is a
form of frequency counting that groups the sites based on the
incidence of accident. Subsequently, frequent item sets that
characterise the weather conditions were determined through
association rule mining. With regards to risk variables related
to driving while high, different outcomes were included in the
rules as well as different incidences for each variable. It is
worth to recall that according to the analysis presented above
there is a higher frequency of all types of fatal incidents near
highway crossings. The literature review is a key element of the
process of developing a new system based on the fact that
previous studies should be carefully reviewed and analyzed.
The IEEEtran class file is used to format your paper and style
the text. All margins, column widths, line spaces, and text fonts
are prescribed; please do not alter them. You may note
peculiarities. For example, the head margin measures
proportionately more than is customary. This measurement
and others are deliberate, using specifications that anticipate
your paper as one part of the entire proceedings, and not as
an independent document. Please do not revise any of the
current designations.
III. METHODOLGY
A. Breadth-First Search (BFS)
1) Concept:: The algorithm BFS is graph searching
algorithm it searches level by level. This is a systematic
traversal of all node’s neighbors beginning from a particular
prescribed initial node, often called the start vertex. Then it
proceeds to identify the neighbors of the aforementioned
neighbors and the process continues in a similar manner. This
goes on until the terminal node of the search space has been
located or else all the accessible nodes in the search space are
visited.
2) Initialization:: Create a queue that has to contain a
node that has been visited or has to be visited in the future for
further iterations of the algorithm. In this case one of the
nodes, for example the starting node, must add a visited status
to it. Start with the starting node pushed to the queue to get
the iteration going
3) Exploration:: Implement the pop front method from
the queue data structure interface.Next, clean the neighbor as
completed. Path Reconstruction: get the actual path, either
keep track of a reference to the parent node for each node that
you visit, or if you are using the stack or queue data structure
for your implementation, record the path as you unwind the
call stack. The link between the target node and the start node
is not lost, as the parent node pointers can easily restore the
path.
B. Depth-First Search (DFS):
1) Concept:: In worse case, DFS has to go down the tree
as far as it can and then come up again. Starting from the given
start node and choosing an unconstrained adjacent vertex. It
then proceeds as far as it possibly can through this neighbor
and if at any one time there are no other neighbors, which
have not been visited then stops. It then proceeds to the next
neighbor of the previous node that has not been visited before
then follows the To steps shown above.
2) Initialization:: Start with the node of initial interest
and explore each of the nodes connected to this node and
make this node also visited. From the above sequence, go to
the unvisited neighbors of the starting node then perform the
above operation on any of the nodes.
3) Recursive Exploration:: For each unvisited neighbor of
the current node:For each unvisited neighbor of the current
node: To be specific, the two categories are: But before listing
them, let’s mark the ‘neighbor’ element as ‘visited’. Call the
DFS function to the neighboring vertex.
4) Target Found:: If the target node is encountered, then
one is done with searching process.
5) Path Reconstruction:: It is also worth mentioning that
a search algorithms like BFS, one can store parent nodes during
the search to reconstruct the path.
C. Applying to a Grid:
1) Nodes:: In the grid, each point or spot is a node that
can be compared to a cell in excel.
2) Edges:: Two cells are connected if and only if they are
in the neighboring cells above, below, to the left or to the right
or even on the diagonals if the think mentioned it. Obstacles:
The walls are the cells that do not have neighboring cells
sharing its sides, which makes it as an obstacle needed for the
paths.
D. Advantages and Disadvantages:
E. BFS:
1) Advantages:: The shortest path algorithms ensure the
reader that the path shown from the source node to the target
node takes the least number of hops.
2) Disadvantages:: Can be slow for larger grids and may
require significant amount of memory when executed.
F. DFS:
1) Advantages:: Does not necessarily have to be slower
than BFS for a certain problem, and can sometimes even be
faster.
2) Disadvantages:: It may not identify the shortest path
from the source node to the destination node. Very time
consuming: the worst case time complexity is very large if
there is a very dense graph or if it contains loops.

IV. CONCLUSION:
The tool is simple to use because it directly demonstrates
the idea of pathfinding algorithms including BFS and it guides
the user through a maze while showing how the program does
it.
A. Future Scope:
1) Dynamic Obstacles: : Some changes that should be
introduced into the application: Make it possible to add or
delete some obstacles while pathfinding in order to hedge a
real life situation.
2) Multi-Agent Pathfinding:: Check the procedures for
finding the path for multple agents at a time, possibility of
collisions and over all efficiency of the obtained solution.
3) Path Smoothing:: Lastly, a final refinement to add to
the problem is to ensure that the path looks more natural to
follow and easily to be negotiated by the agents.
4) Path Repair:: Suggest how it is possible to fix the path
when an environment changes, or when other obstacles
appear so that the agents would be able to recognise the
change.
5) Pathfinding on Different Grid Types:: However, in the
process of using the tool, it becomes apparent that
incorporating different types of grids such as hexagonal/
triangular based grids could be possible and as a result it
modifies the algorithms of path finding.
6) Support for Continuous Spaces:: Further develop the
tool for both discrete and continuous environments by given
pathfinding algorithms for continuous environments.
7) Comparative Analysis:: One new feature would be to
compare the movement with path finding strategies in terms
of time, space, and quality.
8) Data Visualization:: Introduce more representations
of the work done to represent the explorations of nodes, the
time taken and the path length.
9) Exporting Results:: Allow the generated mazes, paths
and other visualization data to be downloaded in a chosen
format by the users for analysis or presentation.
10) Educational Resources: : Some of the pathfinder
specific documents that should be accompanied with the
software include:articles, manuals, guidelines and examples
that can help potential users of the software in the
understanding of how pathfinder works.
REFERENCES
[1] Singh, Lukesh, et al. ”Research Paper on Path-finding Algorithm
Visualizer.” 2022 International Conference on Cyber Resilience (ICCR).
IEEE, 2022.
[2] Surti, Rohan, et al. ”NeoRoute: A Pathfinding Algorithm Visualizer.” 2023
International Conference on Advanced Computing Technologies and
Applications (ICACTA). IEEE, 2023.
[3] Korhonen, Ari, Erkki Sutinen, and Jorma Tarhio. ”Understanding
algorithms by means of visualized path testing.” Software Visualization:
International Seminar Dagstuhl Castle, Germany, May 20–25, 2001
Revised Papers. Berlin, Heidelberg: Springer Berlin Heidelberg, 2002.
[4] Singh, Deep, et al. ” Path Visualizer Using Shortest Path Algorithms.”
(2022)
[5] Yadav, Nikhil, Karishma Dhameja, and Prakhar Chaubey. ”Path finding
visualizer application for shortest path algorithm.” 2021 3rd
International Conference on Advances in Computing, Communication
Control and Networking (ICAC3N). IEEE, 2021.
[6] Satyanandam, N., Varsha Nippuleti, and Sneha Sreelata. ”PATH FINDING
VISUALIZER.”
[7] Sharma, Meenakshi, and Himanshu Jindal. ”Pathfinding Visualizer.”
(2022).
[8] Paul, Enosh Raj, et al. ”Pathfinding Visualizer of Shortest Path
Algorithms.” International Journal for Research Publication and
Seminar. Vol. 13. No. 3. 2022.
[9] Maurya, Ananya, Aayushi Yadav, and Ashish Baiswar. ”Pathfinding
Visualizer.” Journal on Software Engineering 16.4 (2022)
[10] Bhatt, Chandradeep, et al. ”Implementation and Visualization of Path
Finding Algorithms.” 2023 5th International Conference on Inventive
Research in Computing Applications (ICIRCA). IEEE, 2023.
[11] Dube, Raghav, et al. ”Pathfinding Visualizer: A Survey of the StateofArt.”
International Conference on Information and Communication
Technology for Intelligent Systems. Singapore: Springer Nature
Singapore, 2023.
[12] Roles, J. A., ElAarag, H. (2013, April). A smoothest path algorithm and its
visualization tool. In 2013 Proceedings of IEEE Southeastcon (pp. 1-6).
IEEE.
[13] Rahmani, V., Pelechano, N. (2022). Towards a human-like approach to
path finding. Computers Graphics, 102, 164-174.
[14] Kumar, R. N., Ramakrishna, D. G., Aishwarya, R., Amarnath, P. (2023,
March). RFA and RAA: Optimal Path finding. In 2023 9th International
Conference on Advanced Computing and Communication Systems
(ICACCS) (Vol. 1, pp. 230-233). IEEE.
[15] Hu, C., Yin, Q., Hu, Y., Zeng, J., Qin, L. (2019, August). Speeding up
FastMap for Pathfinding on Grid Maps. In 2019 IEEE International
Conference on Mechatronics and Automation (ICMA) (pp. 2501-2506).
IEEE.
[16] Kapi, A. Y., Sunar, M. S., Abd Algfoor, Z. (2020, December). Summary of
Pathfinding in Off-Road Environment. In 2020 6th International
Conference on Interactive Digital Media (ICIDM) (pp. 1-4). IEEE.
[17] Cui, M., Harabor, D. D., Grastien, A., Data61, C. (2017, August).
Compromise-free Pathfinding on a Navigation Mesh. In IJCAI (pp.
496502).