重复结果[剪辑]

Repetition of results [CLIPS]

(deftemplate path
(slot start) 
(slot end)
(multislot path) 
(slot cost(type NUMBER)))

(deftemplate info
(slot start) 
(slot end)
(multislot path) 
(slot cost))


(deftemplate startend
   (slot start)
   (slot end))



(deffacts variable_table

(path (start A)(end B)(path A,a,b,B)         (cost  7))
(path (start A)(end C)(path A,a,b,c,C)       (cost   10))
(path (start A)(end D)(path A,a,m,n,d,D)     (cost 8.5))
(path (start A)(end E)(path A,a,m,n,E)       (cost 5.5))
(path (start A)(end F)(path A,a,m,n,k,g,f,F) (cost  9.4))
(path (start A)(end CS) (path A,a,m,n,k,CS)  (cost  6.7))
(path (start A)(end G)(path A,a,m,n,k,g,G)   (cost 8))
(path (start A)(end H)(path A,a,m,n,d,e,H)   (cost 10.3))
(path (start A)(end I)(path A,a,m,I)         (cost 3.5))

(path (start B)(end A) (path B,b,a,A)        (cost   7  ))
(path (start B)(end C) (path B,b,c,C)        (cost  4))
(path (start B)(end D) (path B,b,c,d,D)      (cost 7 ))
(path (start B)(end E) (path B,b,g,k,n,E)    (cost 5.8  ))
(path (start B)(end F) (path B,b,g,f,F)      (cost  4.7))
(path (start B)(end CS)(path B,b,g,k,CS)     (cost  4.6))
(path (start B)(end G) (path NG2,b,g,G)      (cost  3.3))
(path (start B)(end H) (path NG2,b,g,f,e,H)  (cost 6.5 ))
(path (start B)(end I) (path NG2,b,g,k,n,m,I)(cost 7.8 ))

(path (start C)(end A) (path C,c,b,a,A)      (cost   10))
(path (start C)(end B) (path C,c,b,B)        (cost   5))
(path (start C)(end D) (path C,c,d,D)        (cost   4))
(path (start C)(end E) (path C,c,d,n,E)      (cost   5.3))
(path (start C)(end F) (path C,c,d,e,f,F)    (cost   7.6))
(path (start C)(end CS)(path C,c,b,g,k,CS)   (cost   7.6))
(path (start C)(end G) (path C,c,b,g,G)      (cost  6.3))
(path (start C)(end H) (path C,c,d,e,H)      (cost   5.8))
(path (start C)(end I) (path C,c,d,n,m,I)    (cost  9))

(path (start D)(end A) (path D,d,n,m,a,A)    (cost  8.5))
(path (start D)(end B) (path D,d,c,b,B)      (cost  7))
(path (start D)(end C) (path D,d,c,C)        (cost  4))
(path (start D)(end E) (path D,d,n,E)        (cost  5))
(path (start D)(end F) (path D,d,e,f,F)      (cost  5.6))
(path (start D)(end CS)(path D,d,n,k,CS)     (cost  6.2))
(path (start D)(end G) (path D,d,e,f,g,G)    (cost  6))
(path (start D)(end H) (path D,d,e,H)        (cost  3.8))
(path (start D)(end I) (path D,d,n,m,I)      (cost  7))

(path (start E)(end A) (path E,n,m,a,A)      (cost  5.5))
(path (start E)(end B) (path E,n,k,g,b,B)    (cost  5.8))
(path (start E)(end C) (path E,n,d,c,C)      (cost  7))
(path (start E)(end D) (path E,n,d,D)        (cost  5))
(path (start E)(end F) (path E,n,k,g,f,F)    (cost  5.9))
(path (start E)(end CS)(path E,n,k,CS)       (cost  3.2))
(path (start E)(end G) (path E,n,k,g,G)      (cost  4.5))
(path (start E)(end H) (path E,n,d,e,H)      (cost  6.8))
(path (start E)(end I) (path E,n,m,I)        (cost  4))

(path (start F)(end A) (path F,f,g,k,n,m,a,A)(cost   9.4))
(path (start F)(end B) (path F,f,g,b,B)      (cost   4.7))
(path (start F)(end C) (path F,f,e,d,c,C)    (cost  7.6))
(path (start F)(end D) (path F,f,e,d,D)      (cost  5.6))
(path (start F)(end E) (path F,f,g,k,n,E)    (cost  5.9))
(path (start F)(end CS)(path F,f,g,k,CS)     (cost   4.7))
(path (start F)(end G) (path F,f,g,G)        (cost   3.4))
(path (start F)(end H) (path F,f,e,H)        (cost   3.8))
(path (start F)(end I) (path F,f,g,k,n,m,I)  (cost  7.9))


(path (start CS)(end A) (path CS,k,n,m,a,A)  (cost  6.7))
(path (start CS)(end B) (path CS,k,g,b,B)    (cost  4.6))
(path (start CS)(end C) (path CS,K,g,b,c,C)  (cost  7.6))
(path (start CS)(end D) (path CS,k,n,d,D)    (cost  6.2))
(path (start CS)(end E) (path CS,K,N,E)      (cost  3.2))
(path (start CS)(end F) (path CS,k,g,f,F)    (cost  4.7))
(path (start CS)(end G) (path CS,k,g,G)      (cost  3.3))
(path (start CS)(end H) (path CS,k,g,f,e,H)  (cost  6.5))
(path (start CS)(end I)(path CS,k,n,m,I)     (cost  5.2))

(path (start G)(end A) (path G,g,k,n,m,a,A)  (cost       8))
(path (start G)(end B) (path G,g,b,B)        (cost  3.3))
(path (start G)(end C) (path G,g,b,c,C)      (cost  6.3))
(path (start G)(end D) (path G,g,f,e,d,D)    (cost  6))
(path (start G)(end E) (path G,g,k,n,E)      (cost  4.5))
(path (start G)(end F) (path G,g,f,F)        (cost  3.4))
(path (start G)(end CS)(path G,g,k,CS)       (cost  3.3))
(path (start G)(end H) (path G,g,f,e,H)      (cost  5.2))
(path (start G)(end I) (path G,g,k,n,m,I)    (cost  6.5))

(path (start H)(end A) (path H,e,d,n,m,a,A)  (cost 10.3))
(path (start H)(end B) (path H,e,f,g,B)      (cost  6.5))
(path (start H)(end C) (path H,e,d,C)        (cost  3.8))
(path (start H)(end D) (path H,e,d,c,D)      (cost  5.8))
(path (start H)(end E) (path H,e,d,n,E)      (cost  6.8))
(path (start H)(end F) (path H,e,f,F)        (cost  3.8))
(path (start H)(end CS)(path H,e,f,g,k,CS)   (cost  6.5))
(path (start H)(end H) (path H,e,f,g,H)      (cost  5.2))
(path (start H)(end I) (path H,e,d,n,m,I)    (cost  8.8))

(path (start I)(end A) (path I,m,a,A)        (cost  3.5))
(path (start I)(end B) (path I,m,n,k,g,b,B)  (cost 7.8))
(path (start I)(end C) (path I,m,n,d,c,C)    (cost  9))
(path (start I)(end D) (path I,m,n,d,D)      (cost  7))
(path (start I)(end E) (path I,m,n,E)        (cost  4))
(path (start I)(end F) (path I,m,n,k,g,f,F)  (cost  7.9))
(path (start I)(end CS)(path I,m,m,k,CS)     (cost  5.2))
(path (start I)(end G) (path I,m,n,k,g,G)    (cost  6.5))
(path (start I)(end H) (path I,m,n,d,e,I)    (cost 8.8)))

 (defrule lancesaisiepoint
?f1 <-  (debut node)
=>
    (retract ?f1)
    (printout t "how many node start")
    (bind ?x (read))
    (assert (startnode ?x))
 )

(defrule saisiepoint
?f <-   (startnode ?a)
    (test (> ?a 0))
=>
 (printout t " Enter nbr node start" crlf)
(printout t "start node name ")
(bind ?start (read))
(printout t "node start value ")
(bind ?y1 (read))
(assert (startnode ?start ?y1))
(retract ?f)
(assert (startnode (- ?a 1)))
)

(defrule lancesaisiemoins
?f1 <-  (startnode 0)
=>
(retract ?f1)
(printout t "how many node end ")
(bind ?x (read))
(assert (endnode ?x))
 )

(defrule saisiemoins
?f <-   (endnode ?a)
(test (> ?a 0))
=>
(printout t "Enter nbr node end" crlf)
(printout t "end node name ")
(bind ?end (read))
(printout t "node end value ")
(bind ?y2 (read))
(assert (endnode ?end ?y2))
(retract ?f)
(assert (endnode (- ?a 1))))


(defrule supprnbrpoint ;compter
?x<-    (startnode 0)
=>
    (retract ?x)
    )

(defrule supprnbrmoins
?x<-    (endnode 0)
=>
    (retract ?x)
    )

(defrule info

 ?M <- (startnode ?start ?y1)
 ?K <- (endnode ?end ?y2)
  =>
(assert (start ?start end ?end)))


(defrule var  

 ?e1 <-(startnode ?start ?)
 ?f1 <-(endnode ?end ?)
 (path (start ?start) (end ?end) (path $?path) (cost ?cost))

(not (and (startnode ?start$? ?)
       (path (start ?start$?) (end ?end) (cost ?cost?&:(< ?cost? ?cost)))))
   =>


   (printout t " PATH  " ?start " to " ?end " by " ?path " with a cost of  " ?cost  crlf)
   (assert (info (start ?start) (end ?end) (path $?path) (cost ?cost))))

(defrule var1 

    ?e2 <-(startnode ?start ?)
    ?f2 <-(endnode ?end ?)
   (path (start ?start) (end ?end) (path $?path) (cost ?cost))

(not (and (endnode ?end$? ?)
 (path (start ?start) (end ?end$?) (cost ?cost2&:
(< ?cost2 ?cost)))))
  =>

  (printout t " PATH  " ?start " to " ?end " by " ?path " with  a cost of  " ?cost  crlf)
  (assert (info (start ?start) (end ?end) (path $?path) (cost 
?cost))))

this pict show the result if i have the number of start node equal to the number of end node

this pict show the result when we have the number of start node greedy than the end node

所以当我应用@GRAY 给出的规则时,我对任何大于 3 的数字都有相同的 3 结果组合。 我期望的是将 corse 的输入数量(在 nmr 开始节点和结束节点之间)与最低成本进行所有组合。 我试过收回但它给出了不同的结果可能是我把它放在代码中。

如果我使用不同的解决方案,例如 class 或函数怎么办???但我在这个领域还是新手,所以我不知道我能做什么,非常感谢你的帮助。

如果您有多个检测最短路径的规则,则需要为每个规则添加一个模式以排除其他规则检测到的路径。

在这种情况下,您可以将模式“(not (info (start ?start) (end ?end)))”添加到 var 和 var1 规则中以排除之前检测到的模式:

(defrule var
   ?e1 <- (startnode ?start ?)
   ?f1 <- (endnode ?end ?)
   (path (start ?start) (end ?end) (path $?path) (cost ?cost))
   (not (and (startnode ?start$? ?)
             (path (start ?start$?) (end ?end) (cost ?cost?&:(< ?cost? ?cost)))))
   (not (info (start ?start) (end ?end)))
   =>
   (printout t " PATH  " ?start " to " ?end " by " ?path " with a cost of  " ?cost crlf)
   (assert (info (start ?start) (end ?end) (path $?path) (cost ?cost))))

(defrule var1
   ?e2 <- (startnode ?start ?)
   ?f2 <- (endnode ?end ?)
   (path (start ?start) (end ?end) (path $?path) (cost ?cost))
   (not (and (endnode ?end$? ?)
             (path (start ?start) (end ?end$?) (cost ?cost2&:(< ?cost2 ?cost)))))
   (not (info (start ?start) (end ?end)))
   =>
   (printout t " PATH  " ?start " to " ?end " by " ?path " with  a cost of  " ?cost crlf)
   (assert (info (start ?start) (end ?end) (path $?path) (cost ?cost))))