how to calculate the time and space complexity of below python code.

# Initial State

graph $=\{$

$\text{'}$A$\text{'}$: $\{\text{'}$B$\text{'}$: $2,\text{'}$C$\text{'}$: $1\},$

$\text{'}$B$\text{'}$: $\{\text{'}$F$\text{'}$: $1,\text{'}$G$\text{'}$: $1,\text{'}$A$\text{'}$:$2\},$

$\text{'}$C$\text{'}$: $\{\text{'}$D$\text{'}$: $2,\text{'}$E$\text{'}$: $2,\text{'}$A$\text{'}$: $1,\text{'}$J$\text{'}$: $1\},$

$\text{'}$D$\text{'}$: $\{\text{'}$E$\text{'}$: $1,\text{'}$K$\text{'}$: $1,\text{'}$C$\text{'}$:$2\},$

$\text{'}$E$\text{'}$: $\{\text{'}$F$\text{'}$: $3,\text{'}$S$\text{'}$: $2,\text{'}$C$\text{'}$: $2,\text{'}$D$\text{'}$: $1,\text{'}$K$\text{'}$: $1\},$

$\text{'}$F$\text{'}$: $\{\text{'}$G$\text{'}$: $1,\text{'}$B$\text{'}$: $1,\text{'}$E$\text{'}$: $3\},$

$\text{'}$G$\text{'}$: $\{\text{'}$H$\text{'}$: $1,\text{'}$B$\text{'}$: $1,\text{'}$F$\text{'}$: $1\},$

$\text{'}$H$\text{'}$: $\{\text{'}$S$\text{'}$: $1,\text{'}$G$\text{'}$: $1\},$

$\text{'}$I$\text{'}$: $\{\text{'}$A$\text{'}$: $2\},$

$\text{'}$J$\text{'}$: $\{\text{'}$C$\text{'}$: $1\},$

$\text{'}$K$\text{'}$: $\{\text{'}$E$\text{'}$: $1,\text{'}$D$\text{'}$: $1\},$

$\text{'}$S$\text{'}$:$\{\text{'}$E$\text{'}$: $2,\text{'}$H$\text{'}$: $1\}$

$\}$

$[36]$: #Code Block : Set the matrix for transition & cost $($as relevant for the given

#Matrix and Cost for Hill Climbing Algorithm

import random

import numpy as np

def dict$\_$to$\_$matrix$($graph$)$:

nodes sorted$($graph$.$keys$())$

matrix $=$ np$.$zeros$(($len$($nodes$),$ len$($nodes$)))$

#changes by me

#a$=0$

for i$,$ node in enumerate $($nodes$)$:

for neighbor, cost in graph $[$node$].$items$()$:

j $=$ nodes.index$($neighbor$)$

matrix$[$i$,$ j$]=$ cost

#a $+=1$

return matrix, nodes #$,$ a

def hill$\_$climbing$($graph$,$ start, goal$)$:

path $=[$start$]$

while set$($path$)!=$ set$($graph$.$keys$())$:

neighbors $=$ graph$[$start$]$

if not neighbors:

return path

next$\_$node $=$ min$($neighbors$,$ key$=$neighbors.get$)$

if next$\_$node in path:

unvisited$\_$nodes $=$ list$($set$($graph$.$keys$())-$ set$($path$))$

start $=$ random.choice$($unvisited$\_$nodes$)$

path.append$($start$)$

else:

path.append$($next$\_$node$)$

start $=$ next$\_$node

return path

def path$\_$cost$($graph$,$ path$)$:

cost $=0$

for i in range$($len$($path$)1)$:

if path$[$i$+1]$ in graph $[$path$[$i$]]$:

cost $+=$ graph $[$path$[$i$]][$path$[$i$+1]]$

else:

I

return cost

cost $+=$ float$(\text{'}$inf$\text{'})$ # If there is no direct path, assign infinite cost

# Random Restart Hill Climbing Algorithm dynamic Input start$\_$node $=$ random.choice $($list$($graph$.$keys$()))$

matrix, nodes $=$ dict$\_$to$\_$matrix$($graph$)$

path $=$ hill$\_$climbing$($graph$,$ start$\_$node, $\text{'}$S$\text{'})$ cost $=$ path$\_$cost$($graph$,$ path$)$

print$("$Matrix representation of the graph:"$)$

print$($matrix$)$

print$("$Nodes in the graph:"$)$

print$($nodes$)$

print$("$Path found by the hill climbing algorithm:"$)$

print$($path$)$

print$("$Cost of the path:"$)$

print$($cost$)$