问题描述:

can someone please elaborate upon the functionality/conditions of travel(A,B,Visited,Path) and travel(A,B,P,[B|P]) .. this code finds the path between path A and B in a graph

`edge(a,b).`

edge(b,c).

edge(b,d).

edge(c,d).

edge(d,b).

edge(e,f).

edge(e,g).

edge(e,h).

edge(h,i).

edge(i,g).

edge(b,e).

connectedEdges(X,Y) :- edge(X,Y).

connectedEdges(X,Y) :- edge(Y,X).

path(A,B,Path) :-

travel(A,B,[A],Q),

reverse(Q,Path).

travel(A,B,P,[B|P]) :-

connectedEdges(A,B).

travel(A,B,Visited,Path) :-

connectedEdges(A,C),

C \== B,

\+member(C,Visited),

travel(C,B,[C|Visited],Path).

Lets start with the first `travel/4`

rule:

```
travel(A,B,P,[B|P]) :-
connectedEdges(A,B).
```

"If points A and B are directly connected to each other, then we have found a direct sub-path, and hence can succeed by adding point B to the path which is unified with all the points we have visited thus far."

In other words, since we have solved a sub-problem (by finding a direct connection to 2 nodes), we can essentially state that `P`

(all that we have visited so far), is the tail of the path list `[B|P]`

(the total path is the last node we have visited .... the current destination node, *prepended* to all the previous nodes we've visited).

Now for the next

`travel/4`

rule:
```
travel(A,B,Visited,Path) :-
connectedEdges(A,C),
C \== B,
\+member(C,Visited),
travel(C,B,[C|Visited],Path).
```

It is important to note that this second rule will always be tried as an alternative, whether or not the first rule succeeded. Due to that fact of this implementation, the implication here is that this code can possibly find *multiple* paths (if more than one exists).

Anyway, in this second rule we find any nodes that are connected to `A`

, *other than* `B`

. Why?, this is because the first rule above already tried that; in this rule we're searching for alternatives. If that node `C`

hasn't already been visited, we simply try to travel from that point (`C`

) to our destination. Then we recursively query/call `travel/4`

yet again, until we've found a complete path(s).

Note again, that this implementation may find 0, 1, or more than 1 solution to a given query.

To recapitulate, the first rule is called to find

您可能感兴趣的文章：

- python - Completing a function to add Values depending on specific "Regions" (More info provided)
- python - TypeError: return arrays must be of ArrayType
- botframework - Activity dropped because this channel is not enabled for this bot
- c# - How use fastJSON with a JSON array
- ios - Fixed horizontal spacing from bigger of the two labels
- php - Reading a specific line from a text file
- clr - Any implementation of an Unrolled Linked List in C#?
- Finding Hudson Log Files
- Forward to a payment-gateway together with POST data using cURL (or any other PHP server side solution)
- WCF in Winforms app - is it always single-threaded?

随机阅读：

**推荐内容**-

**热点内容**