Shortest Path Finding

Using A* Algorithm
AMIT KUMAR SINGH
INTRODUCTION
• Importance of A Algorithm*
• The A* algorithm holds significant importance in the realm of
pathfinding and optimization.
• It is widely utilized in diverse fields such as robotics, video game
development, logistics, and even artificial intelligence.
• The algorithm's efficiency in finding the shortest path between two
points has made it a staple in navigation systems and real-time
decision-making processes.
PROJECT OBJECTIVE AND GOAL
• The goal of this presentation is to showcase the A* pathfinding
visualization project.
• We aim to provide an engaging demonstration of the A* algorithm in
action through an interactive and visually appealing platform.
• By visualizing the algorithm, we intend to enhance the understanding
of its functionality and its applications in various domains.
Purpose of the A Pathfinding Visualization Project

Our project aims to:

• Educate: Provide a clear understanding of the A* algorithm's mechanics.

• Visualize: Create an interactive tool that demonstrates the algorithm's execution.
• Bridge Theory and Practice: Showcase how the algorithm's principles translate into real-
world scenarios.
• Engage: Offer an intuitive learning experience for a diverse audience.
• Promote Problem-Solving: Highlight the algorithm's applications in pathfinding and
navigation.
• Interactive Visualization:
• Users set start and end points, add obstacles, and watch the algorithm adapt in real-time.
• Facilitates deeper comprehension through visual and experiential learning.
• By achieving these objectives, our project contributes to algorithmic understanding, practical
knowledge, and interactive education.
 Code Implementation
1. Spot Class:
class Spot:
def __init__(self, row, col, width, total_rows):
# Initialize cell properties and position
# ...

def get_pos(self):
# Return the row and column position of the cell
# ...

# Methods for checking cell attributes (e.g., is_closed, is_open)

# ...

def update_neighbors(self, grid):

# Update the list of neighboring cells
# ...

def draw(self, win):

# Draw the cell on the screen
# ...
Algorithm Function:
• def algorithm(draw, grid, start, end):
• # Initialize data structures
• # ...
•
• while not open_set.empty():
• # ...
•
• for neighbour in current.neighbours:
• # Evaluate neighbors, update scores, and prioritize exploration
• # ...

• # ...
•
• return None
Visualization and Interaction:

• def draw(win, grid, rows, width):

• # Clear the screen and draw cells
• # ...

• def main(win, width):

• # Initialize the grid, Pygame window, and user interactions
• # ...

• # Run the main function

• main(WIN, WIDTH)
Exploring the Spot Class

Attributes:
•row and col: Represent the spot's position within the grid.
•x and y: Store the pixel coordinates of the spot for rendering.
•color: Specifies the color of the spot, indicating its status (e.g., open, closed, barrier).
•neighbours: A list that contains neighboring spots for efficient traversal.
•width: Defines the width of the spot.
•total_rows: Indicates the total number of rows in the grid.
Methods:
•get_pos(): Returns the row and column position of the spot.
•is_closed(), is_open(), is_barrier(): Determine the status of the spot (closed, open, barrier).
•update_neighbors(grid): Updates the list of neighboring spots based on the grid layout.
•draw(win): Renders the spot on the screen with the appropriate color.
Exploring the Algorithm Function
• The heart of our A* pathfinding visualization lies within the algorithm
function. This function orchestrates the process of finding the shortest
path while efficiently navigating through the grid.
• Purpose: The primary purpose of the algorithm function is to
implement the A* algorithm, a heuristic search method that effectively
balances the exploration of potential paths and the minimization of
total cost.
Key Components:
•open_set and closed_set: These sets keep track of spots to explore and already explored spots, respectively.
•g_score and f_score: These dictionaries store the cost of reaching a spot and the estimated total cost from start to end through that spot.
•PriorityQueue: Utilized for efficient exploration, ensuring that spots with lower f-scores are explored first.
• Algorithm Execution:
1.Initialize sets and scores for spots.
2.Start with the initial spot and iteratively explore neighboring spots.
3.Calculate scores, update paths, and manage sets accordingly.
4.Continue until the end spot is reached or all possible paths are
explored.
5.Reconstruct the shortest path by backtracking from the end to the
start.
• Efficiency Enhancement: The algorithm's efficiency is bolstered by
its utilization of heuristics, prioritizing exploration of paths that are
likely to be shorter based on estimated costs. This "best-first"
approach contributes to A*'s reputation for speed and effectiveness.
• Incorporating the PriorityQueue data structure further optimizes the
algorithm's performance, as it ensures spots with lower total costs are
processed first, minimizing unnecessary exploration.
• In summary, the algorithm function takes center stage by skillfully
implementing the A* algorithm, offering a balance of speed, accuracy,
and optimality in finding the shortest path within the grid.