Considering the following network example:
gg = nx.complete_graph(6)
paths = nx.all_simple_paths(gg, source=0, target=3, cutoff=5)
print(list(paths))
nx.draw(gg, with_labels = True)
The all_simple_paths() give back all possible paths between node (0, 3). I need an alternative function that avoid to calculate a path if a node was previously used.
If you want to keep the unique combinations of paths, i.e. unique sets of nodes to reach to a target, you could build a set of frozensets from your paths, and back to a list.
Using a frozenset here, enables you to remove duplicates by building a set from the resulting iterable. Howerver, we'll have to rearange the resulting paths, since sets have no order. For that we can use a list comprehension, to build lists from those frozensets and enforce that the source and target nodes are at the beginning and end respectively:
So for the shared example:
gg = nx.complete_graph(6)
source = 0
target = 3
paths = nx.all_simple_paths(gg, source=source, target=target, cutoff=5)
s = set(map(frozenset, paths))
# {frozenset({0, 3, 4}), frozenset({0, 2, 3})...
non_redundant_paths = [[source, *[*p-{source,target}],target] for p in s]
Another way, possibly preferable since you only have to iterate once, is to iterate over the generator of paths, and keep track of the seen ones using a set:
non_redundant_paths = []
seen = []
for p in paths:
if set(p) not in seen:
non_redundant_paths.append(p)
seen.append({*p})
print(non_redundant_paths)
[[0, 4, 3], [0, 2, 3], [0, 1, 2, 4, 3], [0, 1, 5, 3], [0, 2, 4, 3],
[0, 3], [0, 1, 4, 3], [0, 1, 2, 4, 5, 3], [0, 2, 4, 5, 3], [0, 2, 5, 3],
[0, 4, 5, 3], [0, 1, 2, 3], [0, 1, 4, 5, 3], [0, 5, 3], [0, 1, 2, 5, 3], [0, 1, 3]]