Python BFS和UCS算法。我的BFS实现工作正常，但我的UCS没有'；TCan'；我不明白为什么

只要我没有弄错，UCS和BFS是一样的，唯一的区别是它不是扩展最浅的节点，而是扩展路径成本最低的节点。（也使用PriorityQueue而不是Queue）因此我复制了BFS代码，创建了一个额外的映射来跟踪每个节点的路径成本，并且只更改了在队列/优先级队列中推送/弹出项目的方式

注意：getConferences（state）返回一个三元组列表（state、action、cost）

以下是我的两个实现：

BFS：

UCS:

根据自动签名器，我的BFS工作得很好，但我的UCS失败了。以下是它失败的测试及其结果：

        B1          E1
       ^  \        ^  \
      /    V      /    V
    *A --> C --> D --> F --> [G]
      \    ^      \    ^
       V  /        V  /
        B2          E2

    A is the start state, G is the goal.  Arrows mark 
    possible state transitions.  This graph has multiple
    paths to the goal, where nodes with the same state 
    are added to the fringe multiple times before they
    are expanded.

The following section specifies the search problem and the solution.
The graph is specified by first the set of start states, followed by
the set of goal states, and lastly by the state transitions which are
of the form: 

<start state> <actions> <end state> <cost>


start_state: A
goal_states: G
A 0:A->B1 B1 1.0
A 1:A->C C 2.0
A 2:A->B2 B2 4.0
B1 0:B1->C C 8.0
B2 0:B2->C C 16.0
C 0:C->D D 32.0
D 0:D->E1 E1 64.0
D 1:D->F F 128.0
D 2:D->E2 E2 256.0
E1 0:E1->F F 512.0
E2 0:E2->F F 1024.0
F 0:F->G G 2048.0

student solution:       ['1:A->C', '0:C->D', '0:E1->F']
student expanded_states:    ['A', 'B1', 'C', 'B2', 'D', 'E1', 'F', 'E2']

correct solution:       ['1:A->C', '0:C->D', '1:D->F', '0:F->G']
correct expanded_states:    ['A', 'B1', 'C', 'B2', 'D', 'E1', 'F', 'E2']

b1e1
^  \        ^  \
/V/V
*A-->C-->D-->F-->[G]
\    ^      \    ^
V/V/
B2 E2
A是开始状态，G是目标。箭头标记
可能的状态转换。此图有多个
目标的路径，其中具有相同状态的节点
在添加到边缘之前，会多次添加到边缘
扩大了。
以下部分指定了搜索问题和解决方案。
该图首先由一组启动状态指定，然后由
目标状态集，最后是状态转换
形式如下：
启动状态：A
目标(u)国家:G
A 0:A->B1 1.0
A1:A->C2.0
A2:A->B2 4.0
B1 0:B1->C 8.0
B2 0:B2->C 16.0
c0:C->d32.0
D 0:D->E1 E1 64.0
D1:D->F 128.0
D2:D->E2 256.0
E1 0:E1->F 512.0
E20:E2->F 1024.0
F 0:F->G 2048.0
学生解决方案：['1:A->C'，'0:C->D'，'0:E1->F']
学生状态：['A'，'B1'，'C'，'B2'，'D'，'E1'，'F'，'E2']
正确的解决方案：['1:A->C'，'0:C->D'，'1:D->F'，'0:F->G']
正确的扩展状态：['A'，'B1'，'C'，'B2'，'D'，'E1'，'F'，'E2']

看起来您没有正确构建您的继任者。你不知何故没有从D到达e1。我想你使用的是dicts或list。尽量使代码只使用元组。这样，您就不会传递任何引用，也不会弄乱代码

我将使用如下所示的数据。第一个是优先级，第二个是我们旅行过的节点列表，第三个是下一个要扩展的节点

queue.push((2, (A, C), D))

---

看起来你没有正确地构建你的继任者。你不知何故没有从D到达e1。我想你使用的是dicts或list。尽量使代码只使用元组。这样，您就不会传递任何引用，也不会弄乱代码

我将使用如下所示的数据。第一个是优先级，第二个是我们旅行过的节点列表，第三个是下一个要扩展的节点

queue.push((2, (A, C), D))

---

无论当前值如何，都可以更新costMap。因此，您会重复增加以前访问过的子项和当前子项的尚未访问的公共继承项的成本

考虑这个例子：从A开始，以C结束。每个转换都有成本为1的节点链：A->A1->A2->A3->A4->A5->A6->A7->A8->A9->A10。A节点中的每个节点都通向B，成本为3。B导致C。您当前的实现将从至少3个节点（A、A1、A2）多次更新B的成本，即使它的实际成本是3（A->B）

---

您应该检查子项是否在costMap中，比较当前的costMap值和新的costMap值，并且只有在新值更好时才推送到队列中。如果costMap不包含子项，请将其添加到costMap和队列中。

您可以更新costMap，而不考虑当前值。因此，您会重复增加以前访问过的子项和当前子项的尚未访问的公共继承项的成本

考虑这个例子：从A开始，以C结束。每个转换都有成本为1的节点链：A->A1->A2->A3->A4->A5->A6->A7->A8->A9->A10。A节点中的每个节点都通向B，成本为3。B导致C。您当前的实现将从至少3个节点（A、A1、A2）多次更新B的成本，即使它的实际成本是3（A->B）

您应该检查子项是否在costMap中，比较当前的costMap值和新的costMap值，并且只有在新值更好时才推送到队列中。如果costMap不包含子项，请将其添加到costMap和队列中

queue.push((2, (A, C), D))