С помощью координат нарисовать граф и сделать обход на лиспе - Lisp - Ответ 6304814

(defun Hamilton (net &optional (begin 0))
  (let* ((start begin)
         (x (array-dimension net 0))
         (from 0)
         (curr-vertex start)
         (curr-coord (list start 0))
         (repetit-coord nil)
         (count 1)
         (Path (list start))
         (Sum 0))
    (loop
      ;; find
      (loop :for j :from from :to (1- x) :do
        (if (plusp (aref net curr-vertex j))
            (unless (member j path)
              (return (setq curr-coord (list curr-vertex j))))))
      ;; not found the solve
      (and (equal curr-coord repetit-coord)
           (= curr-vertex start)
           (return (princ "No solution.")))
      ;; final check & return
      (if (= count (1- x))
          (when (plusp (aref net curr-vertex start))
            (setq Path (cons start (cons curr-vertex Path)))
            ;; path & sum
            (loop :for i :on Path :until (null (cdr i)) :do
                  (incf Sum (aref net (first i) (second i))))
            (return (values Path Sum))))  ; finish
      (cond
        ;;  backtracking
        ((equal curr-coord repetit-coord)
         (decf count)
         (setq from (1+ (pop Path))
               curr-vertex (first Path)))
        ;; step advance
        (t (unless (= (first path) (first curr-coord))
             (push (first curr-coord) Path)
             (incf count))
           (setq from 0
                 repetit-coord curr-coord
                 curr-vertex (second curr-coord)))))))
 
(compile 'Hamilton)
 
;; Test network. Picture №1.
(defparameter *net* #2A(
  (   0    0 1104    0 1292 1153  934  984 1068    0)
  (   0    0    0  740    0  482 1172    0  251    0)
  (1104    0    0    0  394    0  630    0    0  183)
  (   0  740    0    0    0  376    0 1206    0    0)
  (1292    0  394    0    0    0    0 2250    0  536)
  (1153  482    0  376    0    0    0 1090  288    0)
  ( 934 1172  630    0    0    0    0    0 1169  562)
  ( 984    0    0 1206 2250 1090    0    0    0    0)
  (1068  251    0    0    0  288 1169    0    0    0)
  (   0    0  183    0  536    0  562    0    0    0)))
 
(Hamilton *net* 7)
; (7 3 5 8 1 6 9 4 2 0 7)
; 6873

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Граф для ходов коня по доске. ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun Make-Board (n)
  (let ((w (loop for i from 1 to n collect i)))
    (mapcan (lambda (col)
              (mapcar (lambda (row) (list col row)) w)) w)))
 
(defun Fill-Table (board)
  (let* ((len (length board)) (side (round (sqrt len))) (accum '())
         (alist (pairlis board (loop for i from 0 to (- len 1) collect i) accum)))
    (defparameter *ht* (make-hash-table :size len :test #'equal))
    (flet ((Knight (square &aux accum)  
             (dolist (offset '((2 1) (1 2) (-1 2) (-2 1) (-2 -1) (-1 -2) (1 -2) (2 -1)))
               (push (mapcar #'+ square offset) accum))
               (remove-if #'(lambda (x)
                              (or (< side (car  x)) (> 1 (car  x)) 
                                  (< side (cadr x)) (> 1 (cadr x))))
                          accum))); (Knight '(1 1))  => ((2 3) (3 2))
    (mapcar #'(lambda (square)
                (let ((fields (mapcar #'(lambda (offset)
                                          (cdr (assoc offset alist :test #'equal)))
                                      (Knight square)))
                      (cell (cdr (assoc square alist :test #'equal))))
                  (setf (gethash cell *ht*) fields)))
            board)
    'Ok)))
 
(defun Adjacency-Matrix (n)
  (let* ((dim (* n n))
         (arr (make-array (list dim dim) :initial-element 0)))
    (dotimes (node dim)
      (dolist (ls (gethash node *ht*))
        (setf (aref arr node ls) 1)))
    arr))
 
;;; Suite.
(defun Move-Knight (n)
  ;; create the table *ht*
  (Fill-Table (Make-Board n))
  ;; create the network
  (defparameter *net* (Adjacency-Matrix n)))
  
;;; Test.
;; 8x8  Picture №3.
(Move-Knight 8)
(Hamilton *net* 0)
=>
(0 17 27 37 31 46 63 53 36 30 47 62 52 58 48 42 57 51 61 55 45 39 54 60
 43 28 38 44 59 49 32 26 16 33 50 56 41 24 34 40 25 35 29 23 13 7 22 12
 6 21 15 5 11 1 18 8 2 19 9 3 20 14 4 10 0)
 
;; 6x6
(Move-Knight 6)
(Hamilton *net* 1)
=>
(1 12 25 33 29 21 34 23 10 2 13 0 8 4 17 28 32 24 
 20 31 18 26 30 19 6 14 27 35 22 11 15 7 3 16 5 9 1)