user1427661 - 1 year ago 86

Python Question

So I have a problem that I want to use depth first search to solve, returning the first path that DFS finds. Here is my (incomplete) DFS function:

`start = problem.getStartState()`

stack = Stack()

visited = []

stack.push(start)

if problem.isGoalState(problem.getStartState):

return something

while stack:

parent = stack.pop()

if parent in visited: continue

if problem.isGoalState(parent):

return something

visited.append(parent)

children = problem.getSuccessors(parent)

for child in children:

stack.push(child[0])

The startState and goalState variables are simply a tuple of x, y coordinates. problem is a class with a variety of methods. The important ones here are getSuccessors (which returns the children of a given state in the form of a list of 3 item tuples. for this part of the problem though, only the first element of the tuple, (child[0]), which returns the state of the child in x, y coordinates, is important) and isGoalState (which provides the x, y coordinates of the goal state).

So I THINK (difficult to test at this point), that this function, given proper implementation of everything else, will return once it has reached a goal state. Please let me know if I am missing something. My biggest issue, though, is WHAT to return. I want it to output a list of all of the states it takes to get to the goal state, in order from the beginning to the end. It doesn't seem like simply returning my stack will do the trick, since the stack will include many unvisited children. Nor will my visited list yield anything useful, since it is conceivable I could reach dead ends, have to backtrack, but still have the dead-end tuples in the visited list. How would I go about getting the list I desire?

Answer Source

You are right - you cannot simply return the stack, it indeed contains a lot of unvisited nodes.

However, by maintaining a map (dictionary): `map:Vertex->Vertex`

such that `parentMap[v] = the vertex we used to discover v`

, you can get your path.

The modification you will need to do is pretty much in the for loop:

```
for child in children:
stack.push(child[0])
parentMap[child] = parent #this line was added
```

Later on, when you found your target, you can get the path from the source to the target (pseudo code):

```
curr = target
while (curr != None):
print curr
curr = parentMap[curr]
```

Note that the order will be reversed, it can be solved by pushing all elements to a stack and then print.

I once answered a similar (though not identical IMO) question regarding finding the actual path in BFS in this thread

Another solution is to use a recursive version of DFS rather then iterative+stack, and once a target is found, print all `current`

nodes in the recursion back up - but this solution requires a redesign of the algorithm to a recursive one.

P.S. Note that DFS might fail to find a path to the target (even if maintaining a `visited`

set) if the graph contains an infinite branch.

If you want a complete (always finds a solution if one exists) and optimal (finds shortest path) algorithm - you might want to use BFS or Iterative Deepening DFS or even A* Algorithm if you have some heuristic function