A

Avijit Mohan 08617704423(MCA 3B)

AI/ML LAB PRACTICALS

Q1. Write a program to implement Breadth first search and Depth first search.
Sol.
CODE
from collections import deque

class Graph:
def init (self):
# Dictionary to store the graph as an adjacency list
self.graph = {}

def add_edge(self, node, neighbor):

# Add edge from node to neighbor
if node not in self.graph:
self.graph[node] = []
self.graph[node].append(neighbor)

def bfs(self, start_node):

# Breadth-First Search (BFS) algorithm
visited = set()
queue = deque([start_node])
bfs_order = []

while queue:
node = queue.popleft() # Dequeue a node from the front
if node not in visited:
visited.add(node)
bfs_order.append(node)

# Add all unvisited neighbors to the queue

for neighbor in self.graph.get(node, []):
A
Avijit Mohan 08617704423(MCA 3B)

if neighbor not in visited:

queue.append(neighbor)

return bfs_order

def dfs(self, start_node):

# Depth-First Search (DFS) algorithm (iterative)
visited = set()
stack = [start_node]
dfs_order = []

while stack:
node = stack.pop() # Pop a node from the stack
if node not in visited:
visited.add(node)
dfs_order.append(node)

# Add all unvisited neighbors to the stack

for neighbor in reversed(self.graph.get(node, [])): # Reverse for correct DFS order
if neighbor not in visited:
stack.append(neighbor)

return dfs_order

# Example usage
if name == " main ":
g = Graph()

# Add edges to the graph

g.add_edge(0, 1)
A
Avijit Mohan 08617704423(MCA 3B)

g.add_edge(0, 2)
g.add_edge(1, 2)
g.add_edge(2, 0)
g.add_edge(2, 3)
g.add_edge(3, 3)

# Perform BFS and DFS

print("BFS starting from node 2:", g.bfs(2))
print("DFS starting from node 2:", g.dfs(2))
OUTPUT
A
Avijit Mohan 08617704423(MCA 3B)

Q2. Write a program to implement Best first search and A* algorithm.

Sol.
Best first search
CODE
import heapq

class Graph:
def init (self):
# Dictionary to store the graph as an adjacency list
self.graph = {}

def add_edge(self, node, neighbor, cost):

# Add edge with a cost from node to neighbor
if node not in self.graph:
self.graph[node] = []
self.graph[node].append((neighbor, cost))

def best_first_search(self, start_node, target_node):

# Best First Search algorithm using a priority queue (min-heap)
visited = set()
priority_queue = []
heapq.heappush(priority_queue, (0, start_node)) # (heuristic cost, node)

bfs_order = []

while priority_queue:
cost, node = heapq.heappop(priority_queue)

if node not in visited:

visited.add(node)
A
Avijit Mohan 08617704423(MCA 3B)

bfs_order.append(node)

# If target node is found, return the path

if node == target_node:
return bfs_order

# Explore all neighbors

for neighbor, edge_cost in self.graph.get(node, []):
if neighbor not in visited:
heapq.heappush(priority_queue, (edge_cost, neighbor))

return bfs_order

# Example usage
if name == " main ":
g = Graph()

# Add edges to the graph (node, neighbor, cost)

g.add_edge(0, 1, 1)
g.add_edge(0, 2, 4)
g.add_edge(1, 2, 2)
g.add_edge(1, 3, 5)
g.add_edge(2, 3, 1)

# Perform Best First Search from node 0 to node 3

print("Best First Search Path:", g.best_first_search(0, 3))
OUTPUT
A
Avijit Mohan 08617704423(MCA 3B)

A* Algorithm
CODE
import heapq

class Graph:
def init (self):
# Dictionary to store the graph as an adjacency list
self.graph = {}

def add_edge(self, node, neighbor, cost):

# Add edge with a cost from node to neighbor
if node not in self.graph:
self.graph[node] = []
self.graph[node].append((neighbor, cost))

def heuristic(self, node, target_node):

# Example heuristic: using a dummy heuristic (0 for all nodes)
# You can modify this based on the specific problem, e.g., Euclidean distance,
Manhattan distance, etc.
return 0 # Replace this with an appropriate heuristic for your problem

def a_star(self, start_node, target_node):

# A* Search Algorithm
priority_queue = []
heapq.heappush(priority_queue, (0, start_node)) # (f(n), node)

came_from = {} # To store the path

g_score = {start_node: 0} # Stores the cost from start to each node
f_score = {start_node: self.heuristic(start_node, target_node)} # f(n) = g(n) + h(n)

came_from[start_node] = None
A
Avijit Mohan 08617704423(MCA 3B)

while priority_queue:
current_f_score, current_node = heapq.heappop(priority_queue)

if current_node == target_node:
return self.reconstruct_path(came_from, current_node)

for neighbor, cost in self.graph.get(current_node, []):

tentative_g_score = g_score[current_node] + cost

if neighbor not in g_score or tentative_g_score < g_score[neighbor]:

# Update the path and scores
came_from[neighbor] = current_node
g_score[neighbor] = tentative_g_score
f_score[neighbor] = tentative_g_score + self.heuristic(neighbor, target_node)
heapq.heappush(priority_queue, (f_score[neighbor], neighbor))

return None # If no path is found

def reconstruct_path(self, came_from, current_node):

# Reconstruct the path from the start to the target node
path = []
while current_node is not None:
path.append(current_node)
current_node = came_from[current_node]
path.reverse() # Reverse the path to get it from start to goal
return path

# Example usage
if name == " main ":
A
Avijit Mohan 08617704423(MCA 3B)

g = Graph()

# Add edges to the graph (node, neighbor, cost)

g.add_edge(0, 1, 1)
g.add_edge(0, 2, 4)
g.add_edge(1, 2, 2)
g.add_edge(1, 3, 5)
g.add_edge(2, 3, 1)

# Perform A* search from node 0 to node 3

path = g.a_star(0, 3)
if path:
print("A* Path:", path)
else:
print("No path found")
OUTPUT
A
Avijit Mohan 08617704423(MCA 3B)

Q3. Write a program to implement water jug problem.

Sol.
CODE
from collections import deque

# Function to check if the goal is achievable

def is_solvable(x, y, z):
if z > max(x, y):
return False
return z % gcd(x, y) == 0

# Function to find the Greatest Common Divisor

def gcd(a, b):
while b:
a, b = b, a % b
return a

# BFS function to solve the water jug problem

def water_jug_bfs(x, y, z):
# Initialize the queue for BFS
queue = deque()
queue.append((0, 0)) # Starting state with both jugs empty

visited = set()
visited.add((0, 0))

# To store the sequence of steps

path = []

while queue:
A
Avijit Mohan 08617704423(MCA 3B)

a, b = queue.popleft()
path.append((a, b))

# If we reach the solution (either jug contains exactly z liters)

if a == z or b == z:
return path

# Explore all possible moves (fill, empty, pour)

possible_moves = [
(x, b), # Fill jug 1
(a, y), # Fill jug 2
(0, b), # Empty jug 1
(a, 0), # Empty jug 2
(a - min(a, y - b), b + min(a, y - b)), # Pour jug 1 into jug 2
(a + min(b, x - a), b - min(b, x - a)) # Pour jug 2 into jug 1
]

for move in possible_moves:

if move not in visited:
visited.add(move)
queue.append(move)

return None # If no solution is found

# Main function to run the water jug problem

if name == " main ":
X = 4 # Capacity of Jug 1
Y = 3 # Capacity of Jug 2
Z = 2 # The target amount of water
A
Avijit Mohan 08617704423(MCA 3B)

# Check if the solution is possible

if not is_solvable(X, Y, Z):
print("No solution possible")
else:
# Solve the water jug problem
result = water_jug_bfs(X, Y, Z)
if result:
print("Steps to achieve the target:")
for step in result:
print(f"Jug 1: {step[0]} liters, Jug 2: {step[1]} liters")
else:
print("No solution found")
OUTPUT
A
Avijit Mohan 08617704423(MCA 3B)

Q4. Write a program to implement 4 – Queen problem.

Sol.
CODE
# Function to check if a queen can be placed at (row, col)
def is_safe(board, row, col, N):
# Check for queens in the same column
for i in range(row):
if board[i][col] == 1:
return False

# Check upper left diagonal

for i, j in zip(range(row, -1, -1), range(col, -1, -1)):
if board[i][j] == 1:
return False

# Check upper right diagonal

for i, j in zip(range(row, -1, -1), range(col, N)):
if board[i][j] == 1:
return False

return True

# Recursive utility function to solve the 4-queen problem

def solve_n_queen(board, row, N):
# Base case: If all queens are placed
if row >= N:
return True

# Consider each column and try to place a queen

for col in range(N):
A
Avijit Mohan 08617704423(MCA 3B)

if is_safe(board, row, col, N):

board[row][col] = 1 # Place the queen

# Recur to place the rest of the queens

if solve_n_queen(board, row + 1, N):
return True

# If placing the queen doesn't lead to a solution, backtrack

board[row][col] = 0

# If no column can accommodate a queen, return False

return False

# Function to print the board

def print_board(board, N):
for row in range(N):
print(" ".join(str(board[row][col]) for col in range(N)))
print("\n")

# Main function to solve the 4-queen problem

def solve_4_queen_problem():
N = 4 # Size of the board (4x4)
board = [[0 for _ in range(N)] for _ in range(N)] # Initialize the board

if solve_n_queen(board, 0, N):
print("Solution for 4-Queen problem:")
print_board(board, N)
else:
print("No solution exists")
A
Avijit Mohan 08617704423(MCA 3B)

# Run the program

if name == " main ":
solve_4_queen_problem()
OUTPUT
A
Avijit Mohan 08617704423(MCA 3B)

Q5. Write a program to implement AO* algorithm.

Sol.
CODE
import math

class Graph:
def init (self):
# Dictionary to store graph as an adjacency list
# Each node can have AND/OR branches with cost
self.graph = {}

def add_edge(self, parent, children, is_and_node, cost):

# Add edges to the graph (parent -> children with a specified cost)
self.graph[parent] = {'children': children, 'is_and': is_and_node, 'cost': cost}

def get_heuristic(self, node):

# Heuristic function (you can define this according to your problem)
# For simplicity, we'll return a constant heuristic (usually derived from domain
knowledge)
return 0

def ao_star(self, node, backtrack=False):

open_list = {node} # Nodes that need to be processed
solution_graph = {} # Final solution graph
status = {} # Status of each node (SOLVED or not)

while open_list:
current_node = open_list.pop()
children_info = self.graph.get(current_node)

# Base case: If the node has no children, mark it as solved

A
Avijit Mohan 08617704423(MCA 3B)

if children_info is None:
status[current_node] = "SOLVED"
continue

children = children_info['children']
is_and_node = children_info['is_and']
cost = children_info['cost']

# Evaluate the cost of the current node

min_cost = math.inf
selected_children = []

# If this is an AND node, all children must be solved

if is_and_node:
total_cost = sum(self.get_heuristic(child) for child in children) + cost
if total_cost < min_cost:
min_cost = total_cost
selected_children = children
else: # OR node, select the child with the minimum cost
for child in children:
child_cost = self.get_heuristic(child) + cost
if child_cost < min_cost:
min_cost = child_cost
selected_children = [child]

# If no valid children were found, continue (to avoid NoneType error)

if not selected_children:
continue

# Update the solution graph with the best children

A
Avijit Mohan 08617704423(MCA 3B)

solution_graph[current_node] = selected_children

# Add children to open list for further exploration if they are not solved
for child in selected_children:
if status.get(child) != "SOLVED":
open_list.add(child)

# If all children are solved, mark the current node as solved

if all(status.get(child) == "SOLVED" for child in selected_children):
status[current_node] = "SOLVED"

return solution_graph

# Example usage of the AO* algorithm

if name == " main ":
# Creating a graph for the AO* algorithm
g = Graph()

# Add edges in the form (parent, [children], is_and_node, cost)

# For example, node A has children B and C with a cost, and it is an AND node.
g.add_edge('A', ['B', 'C'], True, 1)
g.add_edge('B', ['D', 'E'], True, 2)
g.add_edge('C', ['F'], False, 3)
g.add_edge('D', [], False, 0) # Terminal node
g.add_edge('E', [], False, 0) # Terminal node
g.add_edge('F', [], False, 0) # Terminal node

# Run AO* algorithm starting from node 'A'

solution = g.ao_star('A')
A
Avijit Mohan 08617704423(MCA 3B)

print("Solution Graph:")
for node in solution:
print(f"{node} -> {solution[node]}")
OUTPUT
A
Avijit Mohan 08617704423(MCA 3B)

Q6. Write a program to implement hill climbing & steepest ascent hill climbing algorithm.
Sol.
Hill climbing
CODE
import random

# Define the function to maximize

def objective_function(x):
return -(x ** 2) + 10 * x + 5

# Define the Hill Climbing algorithm

def hill_climbing(start, step_size, max_iterations):
current_solution = start
current_value = objective_function(current_solution)

for i in range(max_iterations):
# Generate neighboring solutions
neighbor_solution = current_solution + random.uniform(-step_size, step_size)
neighbor_value = objective_function(neighbor_solution)

# If the neighbor is better, move to the neighbor

if neighbor_value > current_value:
current_solution = neighbor_solution
current_value = neighbor_value
print(f"Iteration {i}: Moved to better solution at x = {current_solution}, f(x) =
{current_value}")
else:
print(f"Iteration {i}: No improvement at x = {current_solution}, f(x) =
{current_value}")
# Stop if no improvement
break
A
Avijit Mohan 08617704423(MCA 3B)

return current_solution, current_value

# Example usage of the Hill Climbing algorithm

if name == " main ":
# Starting point for hill climbing
start = random.uniform(-10, 10)

# Parameters for hill climbing

step_size = 0.1
max_iterations = 100

# Run hill climbing

best_solution, best_value = hill_climbing(start, step_size, max_iterations)
print(f"Best solution found: x = {best_solution}, f(x) = {best_value}")
OUTPUT

Steepest ascent hill climbing

CODE
import random

# Define the function to maximize

def objective_function(x):
return -(x ** 2) + 10 * x + 5

# Generate neighboring solutions

def generate_neighbors(solution, step_size, num_neighbors=10):
A
Avijit Mohan 08617704423(MCA 3B)

neighbors = []
for _ in range(num_neighbors):
# Generate a neighbor by making a small step
neighbor = solution + random.uniform(-step_size, step_size)
neighbors.append(neighbor)
return neighbors

# Define the Steepest Ascent Hill Climbing algorithm

def steepest_ascent_hill_climbing(start, step_size, max_iterations):
current_solution = start
current_value = objective_function(current_solution)

for i in range(max_iterations):
# Generate neighbors of the current solution
neighbors = generate_neighbors(current_solution, step_size)

# Evaluate all neighbors and find the best one

best_neighbor = current_solution
best_value = current_value

for neighbor in neighbors:

neighbor_value = objective_function(neighbor)
if neighbor_value > best_value:
best_value = neighbor_value
best_neighbor = neighbor

# If the best neighbor is better than the current solution, move to the best neighbor
if best_value > current_value:
current_solution = best_neighbor
current_value = best_value
A
Avijit Mohan 08617704423(MCA 3B)

print(f"Iteration {i}: Moved to better solution at x = {current_solution}, f(x) =

{current_value}")
else:
# If no better neighbor is found, stop
print(f"Iteration {i}: No better neighbor found, stopping at x = {current_solution},
f(x) = {current_value}")
break

return current_solution, current_value

# Example usage of the Steepest Ascent Hill Climbing algorithm

if name == " main ":
# Starting point for hill climbing
start = random.uniform(-10, 10)

# Parameters for hill climbing

step_size = 0.5
max_iterations = 100

# Run Steepest Ascent Hill Climbing

best_solution, best_value = steepest_ascent_hill_climbing(start, step_size, max_iterations)
print(f"Best solution found: x = {best_solution}, f(x) = {best_value}")
A
Avijit Mohan 08617704423(MCA 3B)

OUTPUT
A
Avijit Mohan 08617704423(MCA 3B)

Q7. Write a program to implement travelling salesman problem.

Sol.
CODE
from itertools import permutations

# Define a function to calculate the total distance of a given tour

def calculate_total_distance(tour, distance_matrix):
total_distance = 0
num_cities = len(tour)

# Sum the distances between consecutive cities in the tour

for i in range(num_cities - 1):
total_distance += distance_matrix[tour[i]][tour[i+1]]

# Add the distance to return to the starting city

total_distance += distance_matrix[tour[-1]][tour[0]]

return total_distance

# Brute Force method to solve TSP

def tsp_brute_force(distance_matrix):
num_cities = len(distance_matrix)
cities = list(range(num_cities)) # Cities are labeled 0, 1, 2, ...

# Generate all possible permutations of cities (except the starting city)

all_possible_tours = permutations(cities)

# Track the shortest tour and its distance

shortest_tour = None
shortest_distance = float('inf')
A
Avijit Mohan 08617704423(MCA 3B)

# Evaluate each possible tour

for tour in all_possible_tours:
current_distance = calculate_total_distance(tour, distance_matrix)

# Update if the current tour is shorter than the best found so far
if current_distance < shortest_distance:
shortest_tour = tour
shortest_distance = current_distance

return shortest_tour, shortest_distance

# Example usage of TSP solver

if name == " main ":
# Example distance matrix for 4 cities (symmetric matrix)
# Each element distance_matrix[i][j] represents the distance between city i and city j
distance_matrix = [
[0, 10, 15, 20],
[10, 0, 35, 25],
[15, 35, 0, 30],
[20, 25, 30, 0]
]

# Solve TSP using brute force

shortest_tour, shortest_distance = tsp_brute_force(distance_matrix)

# Print the result

print("Shortest tour:", shortest_tour)
print("Shortest distance:", shortest_distance)
A
Avijit Mohan 08617704423(MCA 3B)

OUTPUT