Scribd
Upload
12 views3 pages

AIML Exp 1.1 Adarsh

Uploaded by

Pranay Raj
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
12 views3 pages

AIML Exp 1.1 Adarsh

Uploaded by

Pranay Raj
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

DEPARTMENT OF

COMPUTER SCIENCE & ENGINEERING

Experiment-1
Student Name: Adarsh Upadhyay UID: 21BCS3999
Branch: CSE Section/Group: 21BCS_IOT-621 A
Semester: 5th Date of Performance: 10/08/23
Subject Name: AIML Subject Code: 21CSH-316

Aim: Evaluate the performance and effectiveness of the A* algorithm implementation in Python.

Objective: Implement the A* algorithm to efficiently find the shortest path in a graph while considering
both the cost to reach a node and a heuristic estimate of its potential to reach the goal.

Advantages of A* algorithm
• A* search algorithm is the best algorithm than other search algorithms.
• A* search algorithm is optimal and complete. • This algorithm can solve very complex
problems.

Disadvantages of A* algorithm
• It does not always produce the shortest path as it mostly based on heuristics and
approximation.
• A* search algorithm has some complexity issues.
• The main drawback of A* is memory requirement as it keeps all generated nodes in the
memory, so it is not practical for various large-scale problems.

Source Code:
import heapq

class Node:
def init (self, position, parent=None):
self.position = position self.parent = parent
self.g = 0 # Cost from start node to current node self.h = 0 # Heuristic
(estimated cost) from current node to goal node self.f = 0 # Total cost (g +
h)

def lt (self, other):


return self.f < other.f
Name:Adarsh Upadhyay UID: 21BCS3999
DEPARTMENT OF
COMPUTER SCIENCE & ENGINEERING
def heuristic(node, goal):
# Manhattan distance heuristic (can be changed to Euclidean distance or others)
return abs(node.position[0] - goal[0]) + abs(node.position[1] - goal[1])
def astar(grid, start, goal): open_list = [] closed_set = set()

start_node = Node(start) goal_node = Node(goal)


heapq.heappush(open_list, start_node)

while open_list:
current_node = heapq.heappop(open_list)

if current_node.position == goal_node.position:
path = [] while current_node is not None:
path.append(current_node.position) current_node
= current_node.parent
return path[::-1]

closed_set.add(current_node.position)

for next_position in [(0, -1), (0, 1), (-1, 0), (1, 0)]: # Possible adjacent
positions node_position = (current_node.position[0] + next_position[0],
current_node.position[1] + next_position[1])

if node_position[0] < 0 or node_position[0] >= len(grid) or node_position[1]


< 0 or node_position[1] >= len(grid[0]): continue

if grid[node_position[0]][node_position[1]] == 1:
continue

if node_position in closed_set:
continue

new_node = Node(node_position, current_node) new_node.g


= current_node.g + 1

new_node.h = heuristic(new_node, goal_node.position) new_node.f


= new_node.g + new_node.h
for node in open_list:
if new_node.position == node.position and new_node.f >= node.f: break
else:

Name:Adarsh Upadhyay UID: 21BCS3999


DEPARTMENT OF
COMPUTER SCIENCE & ENGINEERING
heapq.heappush(open_list, new_node) return
None # No path found

# Example usage:
grid = [
[0, 0, 0, 0],
[0, 1, 1, 0],
[0, 0, 0, 0],
[0, 0, 1, 0]
]

start_point = (0, 0) goal_point


= (3, 3)
path = astar(grid, start_point, goal_point) print(path)

Output:

Name:Adarsh Upadhyay UID: 21BCS3999

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy