深度优先算法python_Python中的深度优先搜索算法

(This question is followed up in more detail here: python-search-algorithm-from-implied-graphs)

Suppose I have a function that takes an input ($x_i$) and then goes through a loop and yields a series of outputs ($x_{i, j}$). Then each output can be an input again to the same function yielding further outputs ($x_{i, j, k}$). And I'm trying to find a set of steps via this function to a particular end state.

This is a general problem, and my question is what is a good code structure within python to handle this.

Here's some meta code as an example (though it might be more complicated in practice):

def f(x):

for i in range(n):

if some_condition:

yield g(x,i)

yield false

Then for some $x_0$ and some $y$, we're looking for a sequence $x_0,x_1,\ldots,x_k$, such that $x_k=y$, and $x_{j+1}=g(x_j,i_j)$ for $j\in{0,\ldots,k-1}$.

To do this with a depth first search where you would calculate $f(f(\ldots f(x) \ldots))$ first until it yields the targeted result or a false. Then back up one step and yield the second result from $f$ and repeat (a rough description, but you get the idea: a depth first search, basically).

It seems to me that the yield keyword is going to be inefficient to handle this. You've also got to handle the stack (I think this is the right terminology) of $(x, f(x), f(f(x)),\ldots)$ in a way that allows you to back track when you hit a dead end.

This general problem is something I come across now and then, and I kind of solve it ad hoc, but I wondered if there was a good general structure for solving this, which naturally and efficiently handles the stack and exploring the tree of possible solutions in python.

I hope this question is sufficiently clear. I welcome any thoughts, comments, clarifications or answers.

解决方案

I think that just using an explicit stack for the current path and recursion is simpler:

def search(start_state, neighbors, goal):

path = [start_state]

class PathFound(RuntimeError):

pass

def rsearch(x):

if goal(x):

raise PathFound

for y in neighbors(x):

path.append(y)

rsearch(y)

path.pop()

try:

rsearch(start_state)

except PathFound:

return path

return None # No path exists

Python has a low recursion limit but for a depth-first search this is normally not an issue (and it can be extended anyway by sys.setrecursionlimit).