INDEX

Sr Aim Date Signature

No.
1 Write a program to implement prim's
algorithm using Python language.

2 Write a program to implement linear search

using Python language

3 Write a program to implement Divide and

Concur algorithm using Python language.

4 Write a program to implement DFS algorithm

using Python language.

5 Write a program to implement BFS algorithm

using Python language.

6 Write a program to implement Dijkstra’s

shortest path algorithm using Python
language.
7 Implementation of convolutional neural
network to predict numbers

8 Implementing regularization to avoid

overfitting in binary classification.
 Practical No. 01
Aim :- Write a program to implement prim's algorithm using Python language.

CODE:

import sys

def prims_algorithm(graph):

num_vertices = len(graph)

key = [sys.maxsize] * num_vertices # Initialize all keys as infinite

parent = [-1] * num_vertices # To store the MST

key[0] = 0 # Start from the first vertex

mst_set = [False] * num_vertices # Track vertices included in MST

for _ in range(num_vertices):

# Find the vertex with the minimum key value not yet included in MST

u = min((key[v], v) for v in range(num_vertices) if not mst_set[v])[1]

mst_set[u] = True

# Update key values of adjacent vertices

for v in range(num_vertices):

if graph[u][v] and not mst_set[v] and graph[u][v] < key[v]:

key[v] = graph[u][v]

parent[v] = u

# Print the MST

print("Edge \tWeight")
 for i in range(1, num_vertices):

print(f"{parent[i]} - {i} \t{graph[i][parent[i]]}")

# Example graph represented as an adjacency matrix

graph = [

[0, 2, 0, 6, 0],

[2, 0, 3, 8, 5],

[0, 3, 0, 0, 7],

[6, 8, 0, 0, 9],

[0, 5, 7, 9, 0]

prims_algorithm(graph)

Output
 Practical No. 02
Aim :- Write a program to implement linear search using Python language.

CODE:

def linear_search(a, n, val):

# Going through array sequentially
for i in range(n):
if a[i] == val:
return i + 1 # Returning position (1-based index)
return -1 # Element not found

# Main function
if __name__ == "__main__":
a = [70, 40, 30, 11, 57, 41, 25, 14, 52] # Given array
val = 41 # Value to be searched
n = len(a) # Size of the array

res = linear_search(a, n, val) # Store result

# Display the array

print("The elements of the array are -", ' '.join(map(str, a)))

# Display the element to be searched

print("Element to be searched is -", val)

# Display the search result

if res == -1:
print("Element is not present in the array")
else:
print(f"Element is present at {res} position of the array")

Output
 Practical No. 03
Aim :- Write a program to implement Divide and Concur algorithm using Python

CODE:

def merge_sort(arr):
# Base case: if the array has one or no elements, it's
already sorted
if len(arr) <= 1:
return arr

# Divide: split the array into two halves

mid = len(arr) // 2
left_half = arr[:mid]
right_half = arr[mid:]

# Conquer: recursively sort both halves

left_half = merge_sort(left_half)
right_half = merge_sort(right_half)

# Combine: merge the sorted halves

return merge(left_half, right_half)

def merge(left, right):

result = []
i=j=0

# Merge the two sorted lists

while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1

# Add remaining elements (if any)

result.extend(left[i:])
result.extend(right[j:])

return result

# Example usage
arr = [38, 27, 43, 3, 9, 82, 10]
print("Original Array:", arr)
sorted_arr = merge_sort(arr)
print("Sorted Array:", sorted_arr)

Output :
 Practical No. 04
Aim :- Write a program to implement DFS algorithm using Python.

CODE:

# Python program to print DFS traversal for

complete graph from collections import defaultdict:

Graph represented as an adjacency list

graph = {
'A': ['B', 'C'],
'B': ['D', 'E'],
'C': ['F'],
'D': [],
'E': ['F'],
'F': []
}

def dfs_recursive(graph, node, visited=None):

if visited is None:
visited = set()

# Visit the node if it's not visited yet

if node not in visited:
print(node, end=' ')
visited.add(node)

# Recursively visit all neighbors

for neighbor in graph[node]:
dfs_recursive(graph, neighbor, visited)

# Starting DFS from node 'A'

print("DFS Traversal (Recursive):")
dfs_recursive(graph, 'A')
def dfs_iterative(graph, start):
visited = set()
stack = [start]

while stack:
node = stack.pop()
if node not in visited:
print(node, end=' ')
visited.add(node)
# Add neighbors to the stack (reversed to maintain order)
 stack.extend(reversed(graph[node]))

# Starting DFS from node 'A'

print("\nDFS Traversal (Iterative):")
dfs_iterative(graph, 'A')

Output:
 Practical No. 05
Aim :- Write a program to implement BFS algorithm using Python language.

CODE:

from collections import deque

# Graph represented as an adjacency list

graph = {
'A': ['B', 'C'],
'B': ['D', 'E'],
'C': ['F'],
'D': [],
'E': ['F'],
'F': []
}

def bfs(graph, start):

visited = set() # To keep track of visited nodes
queue = deque([start]) # Queue for BFS

while queue:
node = queue.popleft() # Dequeue the front node

if node not in visited:

print(node, end=' ') # Visit the node
visited.add(node)

# Enqueue all unvisited neighbors

for neighbor in graph[node]:
if neighbor not in visited:
queue.append(neighbor)

# Starting BFS from node 'A'

print("BFS Traversal:")
bfs(graph, 'A')
OUTPUT :
 Practical No. 06
Aim : Write a program to implement Dijkstra’s shortest path algorithm using
Python language

CODE:

import heapq

def dijkstra(graph, start):

# Distance to all nodes is initially set to infinity

shortest_distances = {node: float('inf') for node in graph}

shortest_distances[start] = 0 # Distance to the start node is 0

# Priority queue to select the node with the smallest distance

priority_queue = [(0, start)]

while priority_queue:

current_distance, current_node = heapq.heappop(priority_queue)

# Skip if we've already found a better path

if current_distance > shortest_distances[current_node]:

continue

# Explore neighbors

for neighbor, weight in graph[current_node].items():

 distance = current_distance + weight

# If a shorter path is found

if distance < shortest_distances[neighbor]:

shortest_distances[neighbor] = distance

heapq.heappush(priority_queue, (distance, neighbor))

return shortest_distances

# Example graph represented as an adjacency list with weights

graph = {

'A': {'B': 1, 'C': 4},

'B': {'C': 2, 'D': 5},

'C': {'D': 1},

'D': {}

# Find shortest paths from node 'A'

shortest_paths = dijkstra(graph, 'A')

# Display the shortest distances

print("Shortest distances from node 'A':")

OUTPUT:
 Practical No. 07
Aim : Implementation of convolutional neural network to predict numbers

CODE:
from number images from keras.datasets import
mnist from keras.utils import to_categorical from
keras.models import Sequential from
keras.layers import Dense,Conv2D,Flatten
import matplotlib.pyplot as plt
#download mnist data and split into train and test sets
(X_train,Y_train),(X_test,Y_test)=mnist.load_data()
#plot the first image in the dataset
plt.imshow(X_train[0]) plt.show()
print(X_train[0].shape)
X_train=X_train.reshape(60000,28,28,1)
X_test=X_test.reshape(10000,28,28,1)
Y_train=to_categorical(Y_train)
Y_test=to_categorical(Y_test)
Y_train[0]
print(Y_train[0])
model=Sequential()
#add model layers #learn
image features
model.add(Conv2D(64,kernel_size=3,activation='relu',input_shape=(28,28,1)))
model.add(Conv2D(32,kernel_size=3,activation='relu')) model.add(Flatten())
model.add(Dense(10,activation='softmax'))
model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])
#train
model.fit(X_train,Y_train,validation_data=(X_test,Y_test),epochs=3)
print(model.predict(X_test[:4]))
#actual results for 1st 4 images in the test set print(Y_test[:4])
OUTPUT:

Pridicted Numbers Are (28, 28)

Neaural Network Series Of 28 & 29 Are [0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
 Practical No. 08
Aim : Implementing regularization to avoid overfitting in binary classification.

CODE:
from matplotlib import pyplot from
sklearn.datasets import make_moons from
keras.models import Sequential from
keras.layers import Dense
X,Y=make_moons(n_samples=100,noise=0.2,random_state=1) n_train=30
trainX,testX=X[:n_train,:],X[n_train:] trainY,testY=Y[:n_train],Y[n_train:]
#print(trainX)
#print(trainY)
#print(testX) #print(testY)
model=Sequential()
model.add(Dense(500,input_dim=2,activation='relu'))
model.add(Dense(1,activation='sigmoid'))
model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])
history=model.fit(trainX,trainY,validation_data=(testX,testY),epochs=4000)
pyplot.plot(history.history['accuracy'],label='train')
pyplot.plot(history.history['val_accuracy'],label='test') pyplot.legend()
pyplot.show()
OUTPUT :