Question

我有5个公交车站的路线图：

a --_       _--b
     \--c--/
d ---/     \---e

我需要获取所有可能的有效路径。有效路径是两个公交车站之间的路径，而不会跳过它们之间的任何公交车站。

例如，如果我们用二进制列表将公交车站表示为

            a b c d e
Stations = [1,1,1,1,1]

以下路径是有效的：

P1 = [1,0,1,0,1] # a <-> c <-> e
P2 = [0,0,1,1,0] # c <-> b 
P3 = [0,0,0,0,1] # e

这些是无效的：

P4 = [1,1,0,0,0]
P5 = [0,1,0,1,0]

我创建了有效连接的矩阵：

  a b c d e
a 1   1
b   1 1
c 1 1 1 1 1
d     1 1
e     1   1

我创建了所有可能的组合

c = list(itertools.product([0, 1], repeat=len(stations))

并将每个路径乘以上述矩阵，但我没有得到任何有意义的信息。有人知道获取所有有效路径的方法吗？我们的地图上可能有许多巴士站。

Answer 1

此答案包含一个简单的DFS解决方案（对于大型图形，不一定非常有效）。

设置图形：

graph = {
    'a': {'c'},
    'b': {'c'},
    'c': {'a', 'b', 'd', 'e'},
    'd': {'c'},
    'e': {'c'},
}

给出一个节点和一个已访问节点的列表，枚举所有可能的子路径：

def list_paths(node, excluded_nodes):
    excluded_nodes = set(excluded_nodes)
    excluded_nodes.add(node)
    yield [node]
    yield from [[node] + p
        for x in graph[node] - excluded_nodes
        for p in list_paths(x, excluded_nodes)]

对所有起始节点执行此操作：

def list_all_paths():
    for k in graph:
        yield from list_paths(k, set())

最后，运行它，我们获得：

>>> from pprint import pprint
>>> pprint(list(list_all_paths()))
[['a'],
 ['a', 'c'],
 ['a', 'c', 'b'],
 ['a', 'c', 'd'],
 ['a', 'c', 'e'],
 ['b'],
 ['b', 'c'],
 ['b', 'c', 'a'],
 ['b', 'c', 'd'],
 ['b', 'c', 'e'],
 ['c'],
 ['c', 'a'],
 ['c', 'd'],
 ['c', 'b'],
 ['c', 'e'],
 ['d'],
 ['d', 'c'],
 ['d', 'c', 'a'],
 ['d', 'c', 'b'],
 ['d', 'c', 'e'],
 ['e'],
 ['e', 'c'],
 ['e', 'c', 'a'],
 ['e', 'c', 'd'],
 ['e', 'c', 'b']]

自然地，您可以将它们轻松地嵌入到自己的向量中：

def list_all_vectors():
    embedding = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}
    zero = [0 for x in range(len(embedding))]
    for path in list_all_paths():
        v = list(zero)
        for x in path:
            v[embedding[x]] = 1
        yield v

pprint(list(list_all_vectors()))

您会注意到，对于较大的图形，这很容易一遍又一遍地重新计算相同的子路径。快速解决此问题的方法可能是某种形式的记忆，尽管通常情况下，可能会有更好的算法。（尝试谷歌搜索“枚举所有哈密顿路径”。）

Answer 2

对我来说，这看起来像是树算法。

从任何起点开始，列出可以直接到达的所有公交车站。

从A开始，得到A-D和A-C

从每个步骤中重复一次，除非不要停止我们已经去过的地方。（如果已经在我们去过的站点列表中，请不要添加字母）

AD-C（从A-D，然后添加C）

AC-D，AC-B，AC-E

再次重复

ADC-B，ADC-E

ACD-（分支结束）

ACB-E（分支结束）

重复剩余起点的过程，可能的总路线是发现的所有路径的并集。

与其将其视为数组问题，不如将其视为构建一组字符串。如果创建的数据结构可以很好地表示问题，则该算法通常更易于理解和实施。

您需要以一种可以让您所有邻居停靠的方式输入路线图开始

A：C，D

B：C，E

C：A，B，D，E

D：A，C

E：B，C

希望这会有所帮助。那就是我现在所有的时间。

所有有效的可能组合

2 个答案: