JUSTIN VARGHESE 710723104037

Ex.no: 4 Floyd’s Algorithm for All-Pairs Shortest

Date:
Paths

AIM:
To develop a Python program that implements Floyd’s algorithm for solving the All-Pairs Shortest
Paths problem and measures its execution time.

ALGORITHM:
Step 1: Start the program.
Step 2: Import required modules: time, numpy, and ThreadPoolExecutor for parallelism.
Step 3: Define a function to perform the Floyd-Warshall algorithm sequentially.
Step 4: Define a function to perform the Floyd-Warshall algorithm in parallel using threads.
Step 5: Generate a random weighted graph with a given number of vertices.
Step 6: Run the sequential Floyd-Warshall function and record execution time.
Step 7: Run the parallel Floyd-Warshall function and record execution time.
Step 8: Calculate the speed-up achieved by parallel execution over sequential.
Step 9: Display the sequential time, parallel time, and speed-up.
Step 10: End the program.

PROGRAM:
import time import numpy as np from multiprocessing
import Pool, cpu_count, Manager

INF = float('inf')

# Floyd-Warshall Sequential def

floyd_warshall_seq(graph): n
= len(graph)
dist = [row[:] for row in graph]
for k in range(n): for i in
range(n): for j in
range(n):

22UCS404-DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY

JUSTIN VARGHESE 710723104037

dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])

return dist

# Helper for multiprocessing

def update_row(args): i,
k, shared_dist, n = args
for j in range(n):
shared_dist[i][j] = min(shared_dist[i][j], shared_dist[i][k] + shared_dist[k][j])
return i

# Floyd-Warshall with multiprocessing def

floyd_warshall_parallel(graph):
n = len(graph)
manager = Manager()
shared_dist = manager.list([manager.list(row) for row in graph])

for k in range(n):
args = [(i, k, shared_dist, n) for i in range(n)]
with Pool(cpu_count()) as pool:
pool.map(update_row, args)

return [list(row) for row in shared_dist]

# Random Graph Generator def generate_graph(n,

edge_prob=0.3, max_weight=10):
graph = [[INF if i != j else 0 for j in range(n)] for i in range(n)]
for i in range(n): for j in range(n): if i != j and
np.random.rand() < edge_prob:
graph[i][j] = np.random.randint(1, max_weight)
return graph

# Main Execution if
__name__ == "__main__":
N = 50

22UCS404-DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY

JUSTIN VARGHESE 710723104037

graph = generate_graph(N)

start_seq = time.time()
floyd_warshall_seq(graph) end_seq
= time.time() start_par =
time.time()
floyd_warshall_parallel(graph)
end_par = time.time()

time_seq = end_seq - start_seq

time_par = end_par - start_par
speedup = time_seq / time_par if time_par > 0 else float('inf')

print(f"Sequential Time: {time_seq:.4f} s")

print(f"Parallel Time: {time_par:.4f} s") print(f"Speed-
up: {speedup:.2f}x")

OUTPUT:

22UCS404-DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY

JUSTIN VARGHESE 710723104037

RESULT:
Thus, the Python program that implements Floyd’s algorithm to solve the all-pairs shortest paths
problem has been successfully executed.

Ex.no: 5
Date:
N Queen's problem using Back Tracking

AIM:
To write a Python program that implements N Queen’s problem using Back Tracking.

ALGORITHM:
Step 1: Start the program
Step 2: Read the input value N, representing the size of the chessboard.
Step 3: Initialize a board representation to track queen positions column-wise.
Step 4: Create a function to check if placing a queen at a given row and column is safe.
Step 5: Use a recursive function to attempt placing a queen in each row of the current column.
Step 6: If a safe position is found, place the queen and recursively try to solve for the next
column.
Step 7: If all columns are filled, record the current configuration as a valid solution.
Step 8: After exploring all options, display the total number of valid solutions and print them.
Step 9: End the Program.

PROGRAM:
def print_solution(board, N):
for row in board:
line = "" for
col in range(N):
line += "Q " if row == col else ". "
print(line) print()

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

for i in range(col):

22UCS404-DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY

JUSTIN VARGHESE 710723104037

if board[i] == row or \
abs(board[i] - row) == abs(i - col):
return False
return True

def solve_n_queens_util(board, col, N, solutions):

if col == N:
solutions.append(board[:])
return

for row in range(N): if

is_safe(board, row, col, N):
board[col] = row
solve_n_queens_util(board, col + 1, N, solutions)

def solve_n_queens(N):
board = [-1] * N solutions
= []
solve_n_queens_util(board, 0, N, solutions)

print(f"Total solutions for {N}-Queens: {len(solutions)}\n")

for sol in solutions: for r in sol: line = ['.'] * N
line[r] = 'Q' print(" ".join(line)) print()
# Driver if __name__ ==
"__main__":
N = int(input("Enter value of N: "))
solve_n_queens(N)

OUTPUT:

22UCS404-DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY

JUSTIN VARGHESE 710723104037

22UCS404-DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY

JUSTIN VARGHESE 710723104037

RESULT:
Thus, the Python program that implements N Queen’s problem using Back Tracking has been
successfully executed.

Ex.no: 6
Date:
AVL Tree Construction

AIM:
To construct an AVL tree using Python, demonstrating self-balancing through LL, RR, LR, and RL
rotations

ALGORITHM:
Step 1: Start the program
Step 2: Define an empty AVL tree.
Step 3: Read the number of elements and the list of input values.
Step 4: For each element, insert it into the AVL tree.
Step 5: During each insertion, update the height of affected nodes.
Step 6: Calculate the balance factor of each node after insertion.
Step 7: Identify the type of imbalance (LL, RR, LR, or RL).
Step 8: Perform appropriate rotations to restore AVL balance.
Step 9: After all insertions, perform an inorder traversal to print elements.
Step 10: Display the total time taken for all insertions.
Step 11: End the Program.

PROGRAM:
import time

class Node: def

__init__(self, k):
self.k = k; self.l = self.r = None; self.h = 1

22UCS404-DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY

JUSTIN VARGHESE 710723104037

def ht(n): return n.h if n else 0

def bal(n): return ht(n.l) - ht(n.r)

def r_rot(y): print(f"Right

Rotation on {y.k}") x, T = y.l,
y.l.r
x.r, y.l = y, T
y.h = 1 + max(ht(y.l), ht(y.r))
x.h = 1 + max(ht(x.l), ht(x.r))
return x

def l_rot(x): print(f"Left

Rotation on {x.k}") y, T = x.r,
x.r.l
y.l, x.r = x, T
x.h = 1 + max(ht(x.l), ht(x.r))
y.h = 1 + max(ht(y.l), ht(y.r))
return y

def insert(n, k):

if not n:
print(f"Inserting
{k}") return Node(k)
if k < n.k:
n.l = insert(n.l, k)
else:
n.r = insert(n.r, k)

n.h = 1 + max(ht(n.l), ht(n.r))

b = bal(n)

# Rotations with step info if b > 1 and

k < n.l.k: print(f"Imbalance at {n.k}

22UCS404-DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY

JUSTIN VARGHESE 710723104037

(LL case)") return r_rot(n) if b < -1

and k > n.r.k: print(f"Imbalance at
{n.k} (RR case)") return l_rot(n) if
b > 1 and k > n.l.k: print(f"Imbalance
at {n.k} (LR case)")
n.l = l_rot(n.l) return r_rot(n)
if b < -1 and k < n.r.k:
print(f"Imbalance at {n.k} (RL case)")
n.r = r_rot(n.r)
return l_rot(n) return n

def inorder(n):
if n:
inorder(n.l)
print(n.k, end=' ')
inorder(n.r)

# Main n = int(input("Enter number of elements:

")) a = list(map(int, input("Enter elements:
").split()))

start =
time.perf_counter() root
= None for x in a: root
= insert(root, x) end =
time.perf_counter()

print("\nAVL Inorder Traversal:") inorder(root)

print(f"\nTime taken: {end - start:.6f} seconds")

OUTPUT:

22UCS404-DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY

JUSTIN VARGHESE 710723104037

22UCS404-DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY

JUSTIN VARGHESE 710723104037

RESULT:
Thus, the Python program that implements AVL tree construction and the speed-up time has been
successfully executed.

22UCS404-DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY