I faced these problems in this algorithm while implementing this.

Traceback (most recent call last):

File “D:/BSSE/5th Semester/AI/Labs/GBFS.py”, line 192, in

GBFS(p)

File “D:/BSSE/5th Semester/AI/Labs/GBFS.py”, line 177, in GBFS

explored.enqueue(node.state)

AttributeError: ‘list’ object has no attribute ‘enqueue’

```
class Priority_Queue:
def __init__(self):
self.back = list()
self.count = 0
def enqueue(self, value):
self.back.append(value)
self.count += 1
def dequeue(self):
if self.count > 0:
self.count -= 1
min_index = 0
min_value = 0
for i in range(len(self.back)):
if min_value>self.back(i).f:
min_value = self.back(i).f
min_index = i
return self.back.pop(min_index)
else:
return None
def contains(self, value):
for val in self.back:
if val == value:
return True
return False
def to_string(self):
return str(self.back)
# Priority Queue ends here
class Problem(object):
def __init__(self, init_state, goal_state):
self.initial_state = init_state
self.goal_state = goal_state
self.state_space = {}
self.state_space('Arad') = {'R1': 'Zerind', 'R2': 'Sibiu', 'R3': 'Timisoara'}
self.state_space('Zerind') = {'R1': 'Oradea', 'R2': 'Arad'}
self.state_space('Oradea') = {'R1': 'Sibiu', 'R2': 'Zerind'}
self.state_space('Timisoara') = {'R1': 'Lugoj', 'R2': 'Arad'}
self.state_space('Lugoj') = {'R1': 'Timisoara', 'R2': 'Mehandia'}
self.state_space('Drobeta') = {'R1': 'Mehandia', 'R2': 'Craiova'}
self.state_space('Craiova') = {'R1': 'Drobeta', 'R2': 'Rimnicu Vilcea', 'R3': 'Pitesti'}
self.state_space('Rimnicu Vilcea') = {'R1': 'Sibiu', 'R2': 'Pitesti', 'R3': 'Craiova'}
self.state_space('Sibiu') = {'R1': 'Arad', 'R2': 'Fagaras', 'R3': 'Oradea', 'R4': 'Rimnicu Vilcea'}
self.state_space('Fagaras') = {'R1': 'Sibiu', 'R2': 'Bucharest'}
self.state_space('Pitesti') = {'R1': 'Rimnicu Vilcea', 'R2': 'Craiova', 'R3': 'Bucharest'}
self.state_space('Bucharest') = {'R1': 'Fagaras', 'R2': 'Pitesti', 'R3': 'Giurgiu', 'R4': 'Urziceni'}
self.state_space('Giurgiu') = {'R1': 'Bucharest'}
self.state_space('Urziceni') = {'R1': 'Bucharest', 'R2': 'Valsui', 'R3': 'Hirsova'}
self.state_space('Hirsova') = {'R1': 'Eforie', 'R2': 'Urziceni'}
self.state_space('Eforie') = {'R1': 'Hirsova'}
self.state_space('Valsui') = {'R1': 'Urziceni', 'R2': 'Iasi'}
self.state_space('Iasi') = {'R1': 'Valsui', 'R2': 'Neamt'}
self.state_space('Neamt') = {'R1': 'Iasi'}
self.state_space('Mehandia') = {'R1': 'Lugoj', 'R2': 'Drobeta'}
self.step_cost = {}
self.step_cost('Arad') = {'R1': 75, 'R2': 140, 'R3': 118}
self.step_cost('Zerind') = {'R1': 71, 'R2': 75}
self.step_cost('Oradea') = {'R1': 152, 'R2': 71}
self.step_cost('Timisoara') = {'R1': 111, 'R2': 118}
self.step_cost('Lugoj') = {'R1': 111, 'R2': 70}
self.step_cost('Drobeta') = {'R1': 75, 'R2': 120}
self.step_cost('Craiova') = {'R1': 120, 'R2': 146, 'R3': 138}
self.step_cost('Rimnicu Vilcea') = {'R1': 80, 'R3': 97, 'R4': 146}
self.step_cost('Sibiu') = {'R1': 140, 'R2': 99, 'R3': 151, 'R4': 80}
self.step_cost('Fagaras') = {'R1': 99, 'R2': 211}
self.step_cost('Pitesti') = {'R1': 97, 'R2': 138, 'R3': 101}
self.step_cost('Bucharest') = {'R1': 211, 'R2': 101, 'R3': 90, 'R4': 85}
self.step_cost('Giurgiu') = {'R1': 90}
self.step_cost('Urziceni') = {'R1': 85, 'R2': 142, 'R3': 98}
self.step_cost('Hirsova') = {'R1': 86, 'R2': 98}
self.step_cost('Eforie') = {'R1': 86}
self.step_cost('Valsui') = {'R1': 142, 'R2': 92}
self.step_cost('Iasi') = {'R1': 92, 'R2': 87}
self.step_cost('Neamt') = {'R1': 87}
self.step_cost('Mehandia') = {'R1': 70, 'R2': 75}
self.heuristic = {}
self.heuristic('Arad') = 366
self.heuristic('Zerind') = 374
self.heuristic('Oradea') = 380
self.heuristic('Timisoara') = 329
self.heuristic('Lugoj') = 244
self.heuristic('Drobeta') = 242
self.heuristic('Craiova') = 160
self.heuristic('Rimnicu Vilcea') = 193
self.heuristic('Sibiu') = 253
self.heuristic('Fagaras') = 176
self.heuristic('Pitesti') = 100
self.heuristic('Bucharest') = 0
self.heuristic('Giurgiu') = 77
self.heuristic('Urziceni') = 80
self.heuristic('Hirsova') = 151
self.heuristic('Eforie') = 161
self.heuristic('Valsui') = 199
self.heuristic('Iasi') = 226
self.heuristic('Neamt') = 234
self.heuristic('Mehandia') = 241
def Actions(self, state):
lst = self.state_space(state).keys()
return lst
def Result(self, state, action):
return self.state_space(state)(action)
def Goal_test(self, state):
return state == self.goal_state
def Path_cost(self, state, action):
return self.step_cost(state)(action)
def h(self, state):
return self.heuristic(state)
# ______________________________________________________________________________
class Node:
def __init__(self, state, parent=None, action=None, path_cost=0, heuristic=0):
"""Create a search tree Node, derived from a parent by an action."""
self.state = state
self.parent = parent
self.action = action
self.path_cost = path_cost
self.h = heuristic
self.f = self.h
def __repr__(self):
return "<Node {} {} {}>".format(self.state, self.path_cost, self.f)
def __lt__(self, node):
return isinstance(node, Node) and self.state < node.state
def __eq__(self, other):
return isinstance(other, Node) and self.state == other.state
# -----------------------------------------------------------------------------
def child_node(problem, parent, action):
next_state = problem.Result(parent.state, action)
step_cost = problem.Path_cost(parent.state, action)
heuristic_cost = problem.h(next_state)
next_node = Node(next_state, parent, action, parent.path_cost + int(step_cost), heuristic_cost)
return next_node
# Problem ends here
def solution(node):
path_back = ()
while node:
path_back.append(node)
node = node.parent
for n in reversed(path_back):
print(n)
# ______________________________________________________________________________
def GBFS(problem):
heuristic_cost = problem.h(problem.initial_state)
node=Node(problem.initial_state, heuristic_cost)
if problem.Goal_test(node.state): return solution(node)
frontier = Priority_Queue()
frontier.enqueue(node)
explored=()
while True:
if not frontier: return print('Failure')
node=frontier.dequeue()
print(node)
explored.enqueue(node.state)
for action in problem.Actions(node.state):
child=child_node(problem,node,action)
if child.state not in explored and child not in frontier:
if problem.Goal_test(child.state):
return solution(child)
frontier.enqueue(child)
#End of if
#End of for
#End of while
# ____________________________________________________________________________
p=Problem('Lugoj','Bucharest')
GBFS(p)
```