import matplotlib.pyplot as plt

import random

from collections import deque

# Maze Generator

def generate$\_$maze$($width$,$ height$)$:

maze $=[[\text{'}$#$\text{'}$ for $\_$ in range$($width$)]$ for $\_$ in range$($height$)]$

def carve$\_$path$($x$,$ y$)$:

directions $=[(0,1),(1,0),(0,-1),(-1,0)]$ # Right, Down, Left, Up

random.shuffle$($directions$)$

for dx$,$ dy in directions:

nx$,$ ny $=$ x $+$ dx $*2,$ y $+$ dy $*2$

if $0<$ nx $<$ width $-1$ and $0<$ ny $<$ height $-1$ and maze$[$ny$][$nx$]==\text{'}$#$\text{'}$:

maze$[$y $+$ dy$][$x $+$ dx$]=\text{'}\text{'}$ # Carve path

maze$[$ny$][$nx$]=\text{'}\text{'}$ # Move to the next cell

carve$\_$path$($nx$,$ ny$)$

if width $\%2==0$: width $+=1$

if height $\%2==0$: height $+=1$

maze$[1][1]=\text{'}\text{'}$ # Start point

carve$\_$path$(1,1)$

return maze

# BFS Search $($used to find the optimal path$)$

def bfs$\_$search$($maze$,$ start, end$)$:

queue $=$ deque$([$start$])$

visited $=$ set$()$

path $=\{\}$

while queue:

current $=$ queue.popleft$()$

if current $==$ end:

break

if current not in visited:

visited.add$($current$)$

for dx$,$ dy in $[(0,1),(1,0),(0,-1),(-1,0)]$:

nx$,$ ny $=$ current$[0]+$ dx$,$ current$[1]+$ dy

if $0<=$ nx $<$ len$($maze$)$ and $0<=$ ny $<$ len$($maze$[0])$ and maze$[$nx$][$ny$]==\text{'}\text{'}$:

if $($nx$,$ ny$)$ not in visited:

queue.append$(($nx$,$ ny$))$

path$[($nx$,$ ny$)]=$ current

return reconstruct$\_$path$($path$,$ start, end$)$

# DFS Search

def dfs$\_$search$($maze$,$ start, end$)$:

stack $=[$start$]$

visited $=$ set$()$

path $=\{\}$

while stack:

current $=$ stack.pop$()$

if current $==$ end:

break

if current not in visited:

visited.add$($current$)$

for dx$,$ dy in $[(0,1),(1,0),(0,-1),(-1,0)]$:

nx$,$ ny $=$ current$[0]+$ dx$,$ current$[1]+$ dy

if $0<=$ nx $<$ len$($maze$)$ and $0<=$ ny $<$ len$($maze$[0])$ and maze$[$nx$][$ny$]==\text{'}\text{'}$:

if $($nx$,$ ny$)$ not in visited:

stack.append$(($nx$,$ ny$))$

path$[($nx$,$ ny$)]=$ current

return reconstruct$\_$path$($path$,$ start, end$)$

# Path Reconstruction

def reconstruct$\_$path$($path$,$ start, end$)$:

reverse$\_$path $=[]$

current $=$ end

while current $!=$ start:

reverse$\_$path.append$($current$)$

current $=$ path.get$($current$,$ start$)$

reverse$\_$path.append$($start$)$

reverse$\_$path.reverse$()$

return reverse$\_$path

# Accuracy Metric

def calculate$\_$accuracy$($dfs$\_$path, bfs$\_$path$)$:

# Length of DFS path and BFS path

dfs$\_$len $=$ len$($dfs$\_$path$)$

bfs$\_$len $=$ len$($bfs$\_$path$)$

# Calculate accuracy as the ratio of DFS path length to BFS path length

accuracy $=$ dfs$\_$len $/$ bfs$\_$len

print$($f$"$DFS Path Length: $\{$dfs$\_$len$\}")$

print$($f$"$BFS Optimal Path Length: $\{$bfs$\_$len$\}")$

print$($f$"$Accuracy $($DFS Path $/$ Optimal Path$)$: $\{$accuracy:$\mathrm{.}2$f$\}")$

return accuracy

# $2$D Maze Visualization

def plot$\_$maze$($maze$,$ path$=$None, title$="$DFS Maze Solution"$)$:

height $=$ len$($maze$)$

width $=$ len$($maze$[0])$

fig, ax $=$ plt$.$subplots$($figsize$=(6,6))$

for y in range$($height$)$:

for x in range$($width$)$:

if maze$[$y$][$x$]==\text{'}$#$\text{'}$: # Wall

ax$.$add$\_$patch$($plt$.$Rectangle$(($x$,$ height $-$ y $-1),1,1,$ color$=$"black"$))$

else: # Path

ax$.$add$\_$patch$($plt$.$Rectangle$(($x$,$ height $-$ y $-1),1,1,$ color$=$"white"$))$

# Plot the solution path $($if provided$)$

if path:

for px$,$ py in path:

ax$.$add$\_$patch$($plt$.$Circle$(($py $+0\mathrm{.}5,$ height $-$ px $-0\mathrm{.}5),0\mathrm{.}3,$ color$=$"blue"$))$

# Add start and end markers

ax$.$add$\_$patch$($plt$.$Circle$((1\mathrm{.}5,$ height $-1\mathrm{.}5),0\mathrm{.}3,$ color$=$"green", label$=$"Start"$))$

ax$.$add$\_$patch$($plt$.$Circle$(($width $-2\mathrm{.}5,0\mathrm{.}5),0\mathrm{.}3,$ color$=$"red", label$=$"End"$))$

ax$.$set$\_$xlim$(0,$ width$)$

ax$.$set$\_$ylim$(0,$ height$)$

ax$.$set$\_$aspect$(\text{'}$equal$\text{'})$

ax$.$axis$(\text{'}$off$\text{'})$

plt$.$title$($title$)$

plt$.$legend$()$

plt$.$show$()$

# Main Function

if $\_$name$\_=="\_$main$\_"$:

width, height $=11,11$

maze $=$ generate$\_$maze$($width$,$ height$)$

start $=(1,1)$

end $=($height $-2,$ width $-2)$

# BFS to get the optimal path

bfs$\_$path $=$ bfs$\_$search$($maze$,$ start, end$)$

# DFS to get the DFS path

dfs$\_$path $=$ dfs$\_$search$($maze$,$ start, end$)$

# Calculate and print the accuracy of the DFS algorithm

accuracy $=$ calculate$\_$accuracy$($dfs$\_$path, bfs$\_$path$)$

# Plot the DFS path

plot$\_$maze$($maze$,$ dfs$\_$path, title$="$DFS Solution"$)$ Please explain the results of the code in boring detail in an academic way because it will be put in a report. Please explain what is the best treatment to work on the Inverse or Forward code. Please write the equation and explain it in detail.