Scribd
Upload
9 views

"Sheikh Fazilatunnesa Mujib University": Computer Science & Engineering (CSE)

This document contains Python code implementations of four graph search algorithms: Depth-First Search (DFS), Breadth-First Search (BFS), A* search algorithm, and Alpha-Beta pruning. It includes code snippets demonstrating how each algorithm traverses a sample graph data structure using a stack for DFS, queue for BFS, priority queue for A*, and game tree pruning for Alpha-Beta. The code is submitted as part of an Artificial Intelligence course assignment.

Uploaded by

ashraful islam shihab
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
9 views

"Sheikh Fazilatunnesa Mujib University": Computer Science & Engineering (CSE)

This document contains Python code implementations of four graph search algorithms: Depth-First Search (DFS), Breadth-First Search (BFS), A* search algorithm, and Alpha-Beta pruning. It includes code snippets demonstrating how each algorithm traverses a sample graph data structure using a stack for DFS, queue for BFS, priority queue for A*, and game tree pruning for Alpha-Beta. The code is submitted as part of an Artificial Intelligence course assignment.

Uploaded by

ashraful islam shihab
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 6

“Sheikh Fazilatunnesa Mujib University”

Computer Science & Engineering (CSE)

Course Title: Artificial Intelligence (Sessional)

Course Code : CSE–346

Report Title : BFS Algorithm, DFS Algorithm, A* Algorithm, Alpha-

Beta Pruning Algorithm implementation in Python (Codes).

Submitted To :
Afrin Jahan Chowdhury
Lecturer
Department of Computer Science and Engineering (CSE)
Sheikh Fazilatunnesa Mujib University, Jamalpur.

Submitted By :
Name : Md. Ashraful Islam
Id : 0742010005101021
Batch : 6th

Submission Date : 21/11/2022


DFS uses a STACK (LIFO)
graph = {
'A': ['B', 'C'],
'B': ['D', 'E'],
'C': ['F', 'G'],
'D': [],
'E': [],
'F': [],
'G': []
}
visited = []
stack = []
def dfs(visited, graph, node):
visited.append(node)
stack.append(node)
while stack:
s = stack.pop(0)
print(s, end=" ")
for neighbour in graph[s]:
if neighbour not in visited:
visited.append(neighbour)
stack.append(neighbour)
dfs(visited, graph, 'A')
BFS uses a QUEUE (FIFO)
graph = {
'A': ['B', 'C'],
'B': ['D', 'E'],
'C': ['F', 'G'],
'D': [],
'E': [],
'F': [],
'G': []
}
visited = []
queue = []
def BFS(visited, graph, node):
visited.append(node)
queue.append(node)
while queue:
s = queue.pop(0)
print(s, end=" ")
for neighbour in graph[s]:
if neighbour not in visited:
visited.append(neighbour)
queue.append(neighbour)
BFS(visited, graph, 'A')
Alpha-beta pruning Algorithm
MAX, MIN = 1000, -1000
def minimax(depth, nodeIndex, maximizingPlayer,
values, alpha, beta):
if depth == 3:
return values[nodeIndex]
if maximizingPlayer:
best = MIN
for i in range(0, 2):
val = minimax(depth + 1, nodeIndex * 2 + i,
False, values, alpha, beta)
best = max(best, val)
alpha = max(alpha, best)
# Alpha Beta Pruning
if beta <= alpha:
break
return best
else:
best = MAX
for i in range(0, 2):
val = minimax(depth + 1, nodeIndex * 2 + i,
True, values, alpha, beta)
best = min(best, val)
beta = min(beta, best)
# Alpha Beta Pruning
if beta <= alpha:
break
return best
if __name__ == "__main__":
values = [3, 5, 6, 9, 1, 2, 0, -1]
print("The optimal value is :", minimax(0, 0, True, values, MIN, MAX))
A* Algorithm
from collections import deque
class Graph:
def __init__(self, adjac_lis):
self.adjac_lis = adjac_lis
def get_neighbors(self, v):
return self.adjac_lis[v]
def h(self, n):
H={
'S': 5,
'A': 3,
'B': 4,
'C': 2,
'D': 6,
'G': 0
}
return H[n]
def a_star_algorithm(self, start, stop):
open_lst = set([start])
closed_lst = set([])
poo = {}
poo[start] = 0
par = {}
par[start] = start
while len(open_lst) > 0:
n = None
for v in open_lst:
if n == None or poo[v] + self.h(v) < poo[n] + self.h(n):
n = v;
if n == None:
print('Path does not exist!')
return None
if n == stop:
reconst_path = []
while par[n] != n:
reconst_path.append(n)
n = par[n]
reconst_path.append(start)
reconst_path.reverse()
print('Path found: {}'.format(reconst_path))
return reconst_path
for (m, weight) in self.get_neighbors(n):
if m not in open_lst and m not in closed_lst:
open_lst.add(m)
par[m] = n
poo[m] = poo[n] + weight
else:
if poo[m] > poo[n] + weight:
poo[m] = poo[n] + weight
par[m] = n
if m in closed_lst:
closed_lst.remove(m)
open_lst.add(m)
open_lst.remove(n)
closed_lst.add(n)
print('Path does not exist!')
return None
## DRiver code
adjac_lis = {
'S': [('A', 1), ('G', 10)],
'A': [('B', 2), ('C', 1)],
'C': [('D', 3), ('G', 0)],
'B': [('D', 5)],
'D': [('G', 2)]
}
graph1 = Graph(adjac_lis)
graph1.a_star_algorithm('S', 'G')

You might also like