Разработать программу для поиска пути в лабиринте

(defun find_room (point labirint) 
 
(cond ((null labirint) nil) 
 
((eql (caar labirint) point) (second (car labirint))) 
 
(t (find_room point (cdr labirint)))))
 
 
 
(defun find_path_r (labyrinth path) 
 
(let ((room (find_room (car path) labyrinth))) 
 
(case room 
 
((nil) nil) 
 
((out) (nreverse (cons 'out path))) 
 
(t (find_path_r labyrinth (cons room path)))))) 
 
 
 
(defun find_path (labyrinth) 
 
(find_path_r labyrinth (cons 'in nil)))

(defun search (v graph chk)  ;; найти первую вершину, связанную с v и непосещенную
  (dolist (i graph nil)
    (when (and (eq v (car i)) (not (member (cadr i) chk))) (return (cadr i)))
    (when (and (eq v (cadr i)) (not (member (car i) chk))) (return (car i)))))
 
(defun dfs! (graph &optional (chk '(1)) (stack '(1))) ;; обход в глубину
  (let ((w (if (null stack) nil (search (car stack) graph chk))))
       (cond ((and (null w) (null stack)) nil)
             ((null w) (dfs! graph chk (cdr stack)))
             (t (cons (list (car stack) w) (dfs! graph (cons w chk) (cons w stack)))))))
 
(defun dfs (graph v)  ;; более удобный интерфейс обхода в глубину
  (dfs! graph (list v) (list v)))
 
(defun search-path (lst e) ;; поиск пути
  (cond ((null lst) nil)
        ((eq (cadar lst) e) (list (car lst)))
        (t (cons (car lst) (search-path (cdr lst) e)))))
 
(defun task (graph b e) ;; собственно решение
  (search-path (dfs graph b) e))
 
;; пробуем:
 
(task '((1 2) (1 3) (2 4) (2 5) (3 5) (3 6) (4 5) (5 6)) 1 5)
 
==> ((1 2) (2 4) (4 5))