在我的 A* 算法中路径没有到达末端节点

Question

从How to speed up least-cost path model at large spatial extents 开始，我尝试在 Netlogo 中编写 A* 算法，以在大空间范围内增加我的最低成本路径模型。这是我的代码：

to findPath [ID-start-node ID-end-node]

 let currentNodesInList [ ]
 let current-node node ID-start-node
 let end-node node ID-end-node
 ask current-node [ set color red]
 ask end-node [ set color red]

 set currentNodesInList lput current-node currentNodesInList

 while [not member? end-node currentNodesInList] [

 ask current-node [ 

 foreach sort nodes-on neighbors [ 

  ask ? [set f-value [link-cost] of link ([who] of current-node) ([who] of ?) + distance end-node] ]  

  let next-current-node min-one-of [nodes-on neighbors] of current-node [f-value]
  ask link ([who] of current-node) ([who] of next-current-node) [set color red]
  set current-node next-current-node

  set currentNodesInList lput current-node currentNodesInList] ]
end

当 ID-start-node 和 ID-end-node 在景观中接近时，代码似乎可以工作。但是，当 ID-start-node 和 ID-end-node 之间的距离较大时，路径不会到达 ID-end-node（见下图；但有时，代码可以工作）。

图中ID-start-node和ID-end-node用红色开始表示，路径用红色绘制。

非常感谢您的帮助。

Answer 1

您可能想在 NetLogo 用户社区中查看此模型：

http://ccl.northwestern.edu/netlogo/models/community/Astardemo1

它实现了一个简单的过程（查找路径），将源补丁和目标补丁作为参数并返回补丁列表（这是从源补丁到目标补丁的最短路径之一） A-star 最短路径查找算法。

您也可以尝试关闭世界环绕。

Answer 2

A* 必须有一种方法来备份尝试旧路径，如果它遇到死胡同，或者看起来效率低下的事情。您的实现只是继续沿着一条路径前进。虽然您的方式绝对是实现寻路的最自然的方式，而且更简单，但这可能就是您遇到问题的原因。

这是我想出的一个实现。它直接使用补丁而不是链接，这实际上看起来对你来说会更好。只需给它一个补丁任务，报告跨越该补丁以及源和目标补丁的成本。我对此不太满意：真正的 A* 使用堆来跟踪它认为每条可能的路径应该有多好。我不得不用一个列表来模拟堆，所以它不会像真正的 A* 那样快。如果其他人看到改进，请随时编辑我的答案或在 cmets 中提出建议！无论如何，这里是：

to-report find-path [ get-cost source destination ]
  let paths (list (list source))
  let estimated-costs (list [distance destination ] of source)
  let path first paths

  let visited patch-set source
  let encountered patch-set source

  while [ source != destination ] [
    let estimated-cost min estimated-costs
    let path-index position estimated-cost estimated-costs
    set path item path-index paths
    set source last path
    let path-cost estimated-cost - [ distance destination ] of source
    let source-cost [ runresult get-cost ] of source

    set paths remove-item path-index paths
    set estimated-costs remove-item path-index estimated-costs

    set visited (patch-set source visited)

    ask [ neighbors with [ not member? self visited ] ] of source [
      let patch-cost runresult get-cost
      let step-cost distance source * (patch-cost + source-cost) / 2
      let est-cost path-cost + step-cost + distance destination

      let add? true

      if member? self encountered [
        let other-path false
        foreach paths [
          if last ? = self [
            set other-path ?
          ]
        ]
        if other-path != false [
          let other-path-index position other-path paths
          let other-path-cost item other-path-index estimated-costs
          ifelse other-path-cost < est-cost [
            set add? false
          ] [
            set paths remove-item other-path-index paths
            set estimated-costs remove-item other-path-index estimated-costs
          ]
        ]
      ]

      if add? [
        set estimated-costs fput est-cost estimated-costs
        set paths fput (lput self path) paths

        set encountered (patch-set self encountered)
      ]
    ]    
  ]
  report path
end

如果cost 是一个包含穿越该补丁的成本的补丁变量，那么您可以这样称呼它：find-path task [ cost ] source-patch target-patch。希望这会有所帮助！