Modify the program below, to get the best path which are connected as per diagram. Currently program below gives me best path where one node to next as no straight connection. For example, one such Best Path my program giving is: $[\text{'}$pu$\text{'},\text{'}$pe$\text{'},\text{'}$t$\text{'},\text{'}$v$\text{'},\text{'}$g$\text{'},\text{'}$n$\text{'}]$ where t$($ tambaram$)$ has no straight connection with v$($velachery$)$ Please correct my genetic algorithm given

Genetic Algorithm for the attached problem is as follow $($It will run without error$),$

import random

# Node coordinates as provided

node$\_$coordinates $=\{$

$\text{'}$pu$\text{'}$: $(0,0),$

$\text{'}$pe$\text{'}$: $(1,1),$

$\text{'}$t$\text{'}$: $(2,2),$

$\text{'}$v$\text{'}$: $(3,3),$

$\text{'}$g$\text{'}$: $(4,4),$

$\text{'}$n$\text{'}$: $(5,5)$

$\}$

# Function to calculate Manhattan distance between two points

def manhattan$\_$distance$($point$1,$ point$2)$:

x$1,$ y$1=$ node$\_$coordinates$[$point$1]$

x$2,$ y$2=$ node$\_$coordinates$[$point$2]$

return abs$($x$1-$ x$2)+$ abs$($y$1-$ y$2)$

# Function to generate the initial population of paths

def generate$\_$initial$\_$population$($graph$,$ population$\_$size$)$:

initial$\_$population $=[]$

for $\_$ in range$($population$\_$size$)$:

path $=$ list$($graph$.$keys$())$

random.shuffle$($path$)$

initial$\_$population.append$($path$)$

return initial$\_$population

# Function to calculate fitness of a path

def calculate$\_$fitness$($path$)$:

total$\_$distance $=$ sum$($manhattan$\_$distance$($path$[$i$],$ path$[$i$+1])$ for i in range$($len$($path$)-1))$

return $1/$ total$\_$distance if total$\_$distance $>0$ else float$(\text{'}$inf$\text{'})$

# Genetic Algorithm components

def roulette$\_$wheel$\_$selection$($population$,$ fitnesses$)$:

total$\_$fitness $=$ sum$($fitnesses$)$

pick $=$ random.uniform$(0,$ total$\_$fitness$)$

current $=0$

for individual, fitness in zip$($population$,$ fitnesses$)$:

current $+=$ fitness

if current $>$ pick:

return individual

def crossover$($parent$1,$ parent$2,$ split$=$'single'$)$:

if split $==$ 'single':

point $=$ random.randint$(1,$ len$($parent$1)-2)$

child$1=$ parent$1[$:point$]+[$gene for gene in parent$2$ if gene not in parent$1[$:point$]]$

child$2=$ parent$2[$:point$]+[$gene for gene in parent$1$ if gene not in parent$2[$:point$]]$

else: # Two$-$point crossover

point$1,$ point$2=$ sorted$($random$.$sample$($range$(1,$ len$($parent$1)-1),2))$

child$1=$ parent$1[$:point$1]+[$gene for gene in parent$2[$point$1$:point$2]$ if gene not in parent$1[$:point$1]]+$ parent$1[$point$2$:$]$

child$2=$ parent$2[$:point$1]+[$gene for gene in parent$1[$point$1$:point$2]$ if gene not in parent$2[$:point$1]]+$ parent$2[$point$2$:$]$

return child$1,$ child$2$

def mutate$($path$,$ mutation$\_$rate$=0\mathrm{.}01)$:

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

if random.random$()$ mutation$\_$rate:

swap$\_$with $=$ random.randint$(0,$ len$($path$)-1)$

path$[$i$],$ path$[$swap$\_$with$]=$ path$[$swap$\_$with$],$ path$[$i$]$

return path

# Main Genetic Algorithm function

def genetic$\_$algorithm$($graph$,$ population$\_$size, generations, mutation$\_$rate$=0\mathrm{.}01)$:

population $=$ generate$\_$initial$\_$population$($graph$,$ population$\_$size$)$

for $\_$ in range$($generations$)$:

fitnesses $=[$calculate$\_$fitness$($individual$)$ for individual in population$]$

new$\_$population $=[]$

while len$($new$\_$population$)$ population$\_$size:

parent$1=$ roulette$\_$wheel$\_$selection$($population$,$ fitnesses$)$

parent$2=$ roulette$\_$wheel$\_$selection$($population$,$ fitnesses$)$

child$1,$ child$2=$ crossover$($parent$1,$ parent$2)$

new$\_$population.extend$([$mutate$($child$1,$ mutation$\_$rate$),$ mutate$($child$2,$ mutation$\_$rate$)])$

population $=$ new$\_$population$[$:population$\_$size$]$

return max$($population$,$ key$=$calculate$\_$fitness$)$

# Example graph as provided

graph $=\{$

$\text{'}$pu$\text{'}$: $[(\text{'}$pe$\text{'},8),(\text{'}$t$\text{'},9)],$

$\text{'}$pe$\text{'}$: $[(\text{'}$pu$\text{'},8),(\text{'}$t$\text{'},11),(\text{'}$v$\text{'},6),(\text{'}$g$\text{'},7)],$

$\text{'}$v$\text{'}$: $[(\text{'}$g$\text{'},14),(\text{'}$pe$\text{'},6)],$

$\text{'}$g$\text{'}$: $[(\text{'}$pe$\text{'},7),(\text{'}$t$\text{'},10),(\text{'}$n$\text{'},12),(\text{'}$v$\text{'},14)],$

$\text{'}$n$\text{'}$: $[(\text{'}$g$\text{'},12),(\text{'}$t$\text{'},15)],$

$\text{'}$t$\text{'}$: $[(\text{'}$n$\text{'},15),(\text{'}$g$\text{'},10),(\text{'}$pe$\text{'},11),(\text{'}$pu$\text{'},9)]$

$\}$

# Running the Genetic Algorithm

best$\_$path $=$ genetic$\_$algorithm$($graph$,$ population$\_$size$=10,$ generations$=100)$

print$("$Best Path:", best$\_$path$)$

print$("$Fitness:$",$ calculate$\_$fitness$($best$\_$path$))$