我试图实施最佳优先算法作为一个解决方案，以建筑物疏散项目。
该建筑物有4层，屋顶和0层。我们使用go_to_roof等函数在每次重复中移动电梯，直到达到目标。
我们的目标是让电梯留在屋顶上，让所有的居民都撤离。
主要的看起来像这样

def main():

initial_state = [0, 9, 4, 12, 7, 0]
goal = [5, 0, 0, 0, 0, 0]

""" ----------------------------------------------------------------------------
**** starting search
**** έναρξη αναζήτησης
"""

print('____BEGIN__SEARCHING____')
method = input("Enter the search method (BFS / DFS / BEFS): ").upper()
if method not in ['BFS', 'DFS', 'BEFS']:
    print("Error: Invalid method.")
    return

find_solution(make_front(initial_state), make_queue(initial_state), [], goal, method)

字符串
所以基本上，使用BFS，DFS和最佳优先，我应该遍历每一个产生的所有情况。当我运行BFS时，我得到：GOAL_FOUND [5，0，0，0，0，0] [[0，9，4，12，7，0]，[4，9，4，12，0，7]，[1，8，4，12，0，8]，[5，8，4，12，0，0]，[3，8，4，4，0，8]，[5，8，4，4，0，0]、[3，8，4，0，0，4]、[2，8，0，0，0，8]、[5，8，0，0，0，0]、[1，0，0，0，0，8]、[5，0，0，0，0，0，0]]
对于最佳优先，我必须使用启发式标准。
当使用best first时，你应该在路径的前面添加孩子，因此插入（0，child），然后根据启发式标准对它们进行排序。
作为标准，我选择了最小的状态和[1：5]状态[-1]是电梯在任何时候的楼层，状态[1] -状态[5]是每个楼层和屋顶上的居民数量。
例如，一个状态看起来像这样

def go_to_floor1(state):
    if state[-1]<8 and state[1]>0:
        if state[1]>8-state[-1]:
            new_state = [1] + [state[1] + state[-1] - 8] + [state[2]] + [state[3]] + [state[4]] + [8]
        else:
            new_state = [1] + [0] + [state[2]] + [state[3]] + [state[4]] + [state[1] + state[-1]]
        return new_state

型
因此，启发式标准如下：

def sum_state(state):
        return sum(state[1:5])

型
在前面，我将在这里包括BFS和DFS的，这样你就可以理解我在做什么

def expand_front(front, method):  
    if method=='DFS':        
        if front:
            print("Front:")
            print(front)
            node=front.pop(0)
            for child in find_children(node):     
                front.insert(0,child)
                
    elif method=='BFS':
        if front:
            print("Front:")
            print(front)
            node=front.pop(0)
            for child in find_children(node):     
                front.append(child)

    elif method == 'BEFS':
        if front:
            print("Front:")
            print(front)
            node = front.pop(0)
            for child in find_children(node):
                front.insert(0,child)
                front.sort(key=sum_state) 
                
    return front

型
最后，对于队列，我不知道应该在哪里进行排序

def extend_queue(queue, method):
    if method == 'DFS':
        print("Queue:")
        print(queue)
        node = queue.pop(0)
        queue_copy = copy.deepcopy(queue)
        children = find_children(node[-1])
        for child in children:
            path = copy.deepcopy(node)
            path.append(child)
            queue_copy.insert(0, path)

    elif method == 'BFS':
        print("Queue:")
        print(queue)
        node = queue.pop(0)
        queue_copy = copy.deepcopy(queue)
        children = find_children(node[-1])
        for child in children:
            path = copy.deepcopy(node)
            path.append(child)
            queue_copy.append(path)

    elif method == 'BEFS':
        print("Queue:")
        print(queue)
        node = queue.pop(0)
        queue_copy = copy.deepcopy(queue)
        children = find_children(node[-1])
        for child in children:
            path = copy.deepcopy(node)
            path.append(child)
            queue_copy.append(path)
            queue_copy.sort(key=sum_state)
    
    return queue_copy

型
所以，我几乎可以肯定我在扩展前端的排序实现是正确的，但我不知道如何处理队列