Question

我需要编写一个Lisp函数来查找两个节点之间的最长路径，而无需重新访问任何节点。但是，如果起始节点和结束节点相同，则可以重新访问此节点。该函数需要是递归和深度优先搜索。

我一直试图解决这个问题几个小时，但无法提出解决方案。我知道函数的一般大纲，但无法正确编程。在一些代码中，主要是伪代码：

(defun longest-path (start end net &optional (current-path nil))  
    (cond ((and (eql start end)
                (not (null current-path)))
          (list start))
          (t
           (find neighbors of start/node)
           (remove any previously traveled neighbors to avoid loop)
           (call longest-path on these neighbors)
           (check to see which of these correct paths is longest))))

网看起来像'（（ab）（bc）），其中第一项是节点，其他一切都是它的邻居（例如，节点a有邻居b，节点b有邻居c）。

是的，这是用于家庭作业，所以如果您不方便发布解决方案或其任何部分，请不要。我只是Lisp的新手，想要一些技巧/帮助，以获得一个不错的开始。

由于

编辑：嗯，我能得到的最多的是：

(defun longest-path (start end net &optional (current-path nil))
  (cond ((and (eql start end)
              (not (null current-path)))
         (list start))
        (t
         (push start current-path)
         (let ((neighbors (cdr (assoc start net))))
           (let ((new-neighbors (set-difference neighbors current-path)))
             (let ((paths (mapcar #'(lambda (node)
                                      (longest-path node end net current-path))
                            new-neighbors)))
               (let ((longest (longest paths)))
                 (if longest
                     (cons start longest)
                   nil))))))))


(defun longest (lst)
  (do ((l lst (cdr l))
       (r nil (if (> (length (car l)) (length r))
                  (car l)
                r)))
      ((null l) r)))

它产生正确的解决方案，除非起始节点和结束节点相同。即使它们是相同的，我也无法弄清楚如何进行搜索。

Answer 1

我记得保罗格雷厄姆的书中的这个算法：Ansi Common Lisp。这是书中一个练习的解决方案的链接。这应该对你有帮助。

Solution

Answer 2

我认为您需要检查三种情况：

到达终点 - ＆gt;返回此路径
没有更多选择 - ＆gt; return nil
找到最长的邻居路径

代码大纲：

(defun longest-path (node end-node net current-path)
  (cond ((eql node end-node)
         (or current-path (list node end-node)))
        ((null (node-neighbors node net))
         ())
        (t
         (let* ((neighbors (node-neighbors node net))
                (not-visited-neighbors (set-difference neighbors current-path))
                (paths (mapcar (lambda (next-node)
                                 (longest-path next-node end-node net
                                               (cons node current-path)))
                               not-visited-neighbors)))
           (first (sort paths #'> :key #'length))))))

如何在Lisp中找到两个节点之间的最长路径？

2 个答案: