重複結果的[CLIPS]

Question

(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結果combinaison。 我所期望的是將corse的輸入數量（在nmr開始節點和結束節點之間）與最低成本相結合。 我試圖用縮進，但它給出了不同的結果，可能是我把它放在代碼中。

和如果我使用不同的解決方案，例如類或函數？但我在這個領域仍然是新的，所以我不知道我能做什麼，非常感謝你的幫助。

Answer 1

如果您有多條規則檢測最短路徑，則需要向每個規則添加一個模式以排除其他規則檢測到的路徑。

在這種情況下，您可以添加模式 「（？沒有（信息（start啓動）（完結束）））」，以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))))