全路径算法中的Python和列表可变性

Question

I've been working on a all-simple-paths algorithm in python based off of networkx's version . At the moment the only changes I'm trying to make are to get it to get ALL paths for ALL nodes without doing it inside of a O(n^2) double loop.

I believe I have the main algorithm sorted, but I'm not quite used to the mutability of Python's list structure and I think that's what's messing up the algorithm.

I've written a similar program in Java so I know how many paths there should be on a test graph, but I can't seem to even get the numbers reasonably close.

def _all_simple_paths_graph(DG, cutoff):
    uniquePaths = []
    nlist = DG.nodes()
    for source in nlist:
        uniqueTreePaths = []
        if cutoff < 1:
            return
        visited = [source]
        stack = [iter(DG[source])]
        while stack:
            children = stack[-1]
            child = next(children, None)
            if child is None:
                stack.pop()
                visited.pop()
            elif len(visited) < cutoff:
                if child not in visited:
                    visited.append(child)
                    stack.append(iter(DG[child]))
                    if visited not in uniqueTreePaths:
                        yield visited
                        uniqueTreePaths.append(visited)
            else: #len(visited) == cutoff:
                if visited not in uniqueTreePaths:
                    yield visited + [child]
                    uniqueTreePaths.append(visited)
                stack.pop()
                visited.pop()
    uniquePaths.extend(uniqueTreePaths)

Can anyone tell me where I've gone wrong? I believe it's to do with where visited should be mutable and where it shouldn't. However, I could also have got the basic functionality wrong, I'm fairly new to Python!

Answer 1

You didn't specify what the symptom is. Is the yielded stuff wrong, or is uniquePaths wrong? It looks like that the function yields the right paths, but at the end of the function, uniquePaths has far fewer paths than it should, and they're all empty.

The reason why there's not enough paths, is that uniquePaths.extend(uniqueTreePaths) is not at the right indention.

The problem you're here for, is that visited is a mutable list. In Python, all lists are mutable. In fact, that's the reason this algorithm works. visited is treated like a stack that happens to be the path. When you append visited to uniqueTreePaths multiple times, you are really appending the same object over and over again. When you modify visited , all of them are modified.

To fix this problem, you should append a copy of the list. This is going to be fairly expensive memory-wise, but you wanted all unique paths in a graph, so you should've been aware of that already. You can use uniqueTreePaths.append(list(visited)) to make a new list object out of visited . I would actually create a tuple out of it, so that it can't be modified: uniqueTreePaths.append(tuple(visited)) .