Python比较列表并存储在新变量中

Question

我在python中需要一些帮助。

我正在使用 Aimsun流量模拟器进行一些模拟，编程语言是python。

我的问题是：

我需要搜索车辆可以做的所有可能路线。

我得到了这些不完整的路线：

 1. Route 1 - [967, 973]  
 2. Route 2 - [967, 970] 
 3. Route 3 - [970, 396]    
 4. Route 4 - [396, 3269] 
 5. Route 5 - [3269, 3275] 
 6. Route 6 - [3275, 3278]
 7. Route 7 - [3278, 404] 
 8. Route 8 - [3278, 408] 
 9. Route 9 - [404, 448]
 10. Route 10 - [408, 410] 
 11. Route 11 - [408, 411] 
 12. Route 12 - [448, 454] 
 13. Route 13 - [410, 419] 
 14. Route 14 - [410, 433] 
 15. Route 15 - [410, 437] 
 16. Route 17 - [411, 412]

起点是967，所以任何车辆都会在这一点开始。

此列表表示各部分的连接，因此如果第二列中的值不会在第一列的下一个值中重复，则此值将表示结束点，因此车辆将完成行程。

因此，对于完成第一条路线，我们有：

Route Finish 1 - [967, 973]因为973不会在第一列重复。

在这种情况下很简单，我用这条路线存储一个变量。

现在开始解决问题：

第二条路线由路线2,3,4,5,6组成，

Route 2 - [967, 970, 396, 3269, 3275, 3278]

但问题是3278在第一列中重复了两次：

1. Route 7 - [3278, 404]
2. Route 8 - [3278, 408]

所以我有两条路线：

1. Route x - [967, 970, 396, 3269, 3275, 3278, 404]
2. Route y - [967, 970, 396, 3269, 3275, 3278, 408]

并且问题增加

1. Route a - [967, 970, 396, 3269, 3275, 3278, 404, 448]
2. Route b - [967, 970, 396, 3269, 3275, 3278, 408, 410]
3. Route c - [967, 970, 396, 3269, 3275, 3278, 408, 411]
4. Route d - [967, 970, 396, 3269, 3275, 3278, 408, 454]

并以同样的方式继续。

如何动态合并此列表，最后我将所有路径都放在变量中：

1. Route Finish 1 - [....] 
2. Route Finish 2 - [....]

我尝试了很多代码，比较和存储变量，但不起作用。

我希望你们明白了。

Answer 1

我为没有使用python 3而道歉，因为我没有安装它。请将print语句转换为函数，它应该可以正常工作。

概述

根据您的问题陈述，我绘制了如下路线：

通过查看此图表，我想出了一些观察结果：

• 如果我从967开始，我将在以下节点（或车站或车站）结束：973，454，419，{{ 1}}，433和437。我在代码中调用了这些节点412或leaf_nodes。
• 问题陈述中您所谓的“路线”只是完整路线的一部分。
• 因此，“routes”的数量实际上是end_points
中的节点数
• 对于这个解决方案，我使用了python模块networkx。如果您的系统中没有它，则需要安装它。安装超出了本讨论的范围，但您可以通过Google搜索 python pip 开始。
• 主力是end_points功能。此函数查看图形，起点和终点，并返回连接起点和终点的所有路径。

我的方法

1. 定义数据。我如何表示输入，最好是在文本文件中。
2. 阅读文本文件，构建图表
3. 创建目标节点列表（AKA networks.all_simple_paths()）
4. 对于end_points中的每个节点，打印从起始节点（967）到此节点的路径

数据文件

我将输入表示为文本文件（routes.txt），其中每行包含两个节点：源和目标。

end_points

代码

967 973  
967 970 
970 396    
396 3269 
3269 3275 
3275 3278
3278 404 
3278 408 
404 448
408 410 
408 411 
448 454 
410 419 
410 433 
410 437 
411 412

输出

# routes.py
# Make sure you have `networkx` installed
import networkx

def build_routes():
    '''
    Reads a text file, where each line is a pair of nodes, then build
    a graph of all the nodes. Returns the graph and a list of leaf nodes
    '''
    routes = networkx.DiGraph()
    leaf_nodes = set()
    nonleaf_nodes = set()
    with open('routes.txt') as f:
        for line in f:
            # Each line consists of two nodes: a source and a
            # destination.
            source, destination = line.split()
            nonleaf_nodes.add(source)
            leaf_nodes.add(destination)
            routes.add_edge(source, destination)

    leaf_nodes.difference_update(nonleaf_nodes)
    return routes, leaf_nodes

def print_routes(routes, start_point, end_points):
    for end_point in end_points:
        for path in networkx.all_simple_paths(routes, start_point, end_point):
            print ' > '.join(path)

if __name__ == '__main__':
    routes, end_points = build_routes()
    print_routes(routes, '967', end_points)

Answer 2

据我了解，您希望找到从967开始且无法延伸的所有路线。

这里有一些代码可以找出最大路线，从967开始。

首先，我们需要输入“不完整路线”列表。 可能的路线是这些对的串联。

steps = [
[967, 973],
[967, 970],
[970, 396],
[396, 3269],
[3269, 3275],
[3275, 3278],
[3278, 404],
[3278, 408],
[404, 448],
[408, 410],
[408, 411],
[448, 454],
[410, 419],
[410, 433],
[410, 437],
[411, 412],
]

从967开始，我们扩展路线，保持所有可能性。 在这里，我定义了一个函数来增加中间体路径的长度。

def add_steps(routes, finished_routes):
    new_routes = []
    for r in routes:
        end = r[-1]
        r_finished = True
        for s in steps:
            if s[0] == end:
                new_routes.append(r + [s[1]])
                r_finished = False
        if r_finished:
            finished_routes.append(r)
    return new_routes, finished_routes

你可以尝试

>>> add_steps([[967]], [])

得到

Out: ([[967, 973], [967, 970]], [])

然后，下一步

>>> add_steps([[967, 973], [967, 970]], [])
([[967, 970, 396]], [[967, 973]])

这意味着“[967,970,396]”是一条中间路线，可以延长，“[967,973]”是一条不能再延长的完成路线。

重复此功能的应用，直到所有路线都完成。

routes = [[967]]
finished_routes = []
for n in range(20):
    routes, finished_routes = add_steps(routes, finished_routes)
    if not routes:
        print finished_routes
        break

打印出的结果是

[[967, 973], [967, 970, 396, 3269, 3275, 3278, 404, 448, 454], [967, 970, 396, 3269, 3275, 3278, 408, 410, 419], [967, 970, 396, 3269, 3275, 3278, 408, 410, 433], [967, 970, 396, 3269, 3275, 3278, 408, 410, 437], [967, 970, 396, 3269, 3275, 3278, 408, 411, 412]]