Python 3.x python中多AGV的最短路径算法_Python 3.x_Algorithm_Shortest Path

Python 3.x python中多AGV的最短路径算法

python-3.x algorithm

Python 3.x python中多AGV的最短路径算法,python-3.x,algorithm,shortest-path,Python 3.x,Algorithm,Shortest Path,我正试图为我的最短路径问题找到一个解决方案。我有两个车辆（AGV）在一个小型9节点系统中。AGV需要在不妨碍彼此的情况下从起始位置到结束位置是否有一种易于在python中实现的算法来查找两辆车的最短路径（系统的最短路径）？路径必须不相交，以避免共谋当只使用一辆车时，我使用Dijikstra算法。现在有了两条，我显然可以让其中一条选择最短的路径，并为另一条阻塞路径。但是在这样一个小的系统中，另一辆AGV可能会等到第一辆AGV完成。我相信一定有更好的解决办法。在我的研究中，我找不到解决这个问题

我正试图为我的最短路径问题找到一个解决方案。我有两个车辆（AGV）在一个小型9节点系统中。AGV需要在不妨碍彼此的情况下从起始位置到结束位置

是否有一种易于在python中实现的算法来查找两辆车的最短路径（系统的最短路径）？路径必须不相交，以避免共谋

当只使用一辆车时，我使用Dijikstra算法。现在有了两条，我显然可以让其中一条选择最短的路径，并为另一条阻塞路径。但是在这样一个小的系统中，另一辆AGV可能会等到第一辆AGV完成。我相信一定有更好的解决办法。在我的研究中，我找不到解决这个问题的算法，而且实现起来并不复杂

谢谢你的帮助

import numpy as np
from itertools import combinations
import itertools
from scipy.sparse.csgraph import csgraph_from_dense
from scipy.sparse.csgraph import dijkstra


class NavigationSystem:
    def __init__(self):
        self.map_sparse = csgraph_from_dense(
            np.genfromtxt('karte.csv', delimiter=',')[2:, 2:])
        self.coordinates = np.genfromtxt(
            'koordinaten.csv', delimiter=',')[1:, 1:]
        self._shortest_distances, self._predecessors = dijkstra(
            self.map_sparse, return_predecessors=True)

    def get_shortest_distance(start, end):
        v_old = [1, 2, 3, 4, 5, 6, 7, 8, 9]
        e_old = [map_sparse]
        g_old = (v_old, e_old)

        v_new = list(itertools.permutations(v_old, 2))
        e_new = []
        g_new = (v_new, e_new)

        for x in v_new:
            for every neighbour a of x[0]:
                if a != x[1]:
                    e_new.append((a, x[0]))

            for every neighbour b of x[1]:
                if b != x[0]:
                    e_new.append((b, x[1]))

            for every neighbour a of x[0]:
                for every neighbour b of x[1]:
                    if a != b:
                        e_new.append((x[0], x[1]), (a, b))
        return self._shortest_distances[start][end]

更新#1：我试着把塔斯勒的建议写成代码。但因为我对编程还很陌生，所以我一直在挣扎，我相信我离编程还有很长的路要走。所以我有很多问题，希望你能帮助我

关于边：在哪里添加边？我猜是E'（E_new），但我不知道是什么形式
我如何包括“每个邻居”？我不知道如何把邻居从地图上弄出来
我正在努力恰当地构造代码，并将计算出的边用于dijikstra算法。下面写代码的方式，我甚至不使用最短距离的边缘
我只计算其中一辆AGV的最短路径，但应该同时计算两辆AGV的最短路径，对吗

非常感谢你，我真的很感谢你的帮助

import numpy as np
from itertools import combinations
import itertools
from scipy.sparse.csgraph import csgraph_from_dense
from scipy.sparse.csgraph import dijkstra


class NavigationSystem:
    def __init__(self):
        self.map_sparse = csgraph_from_dense(
            np.genfromtxt('karte.csv', delimiter=',')[2:, 2:])
        self.coordinates = np.genfromtxt(
            'koordinaten.csv', delimiter=',')[1:, 1:]
        self._shortest_distances, self._predecessors = dijkstra(
            self.map_sparse, return_predecessors=True)

    def get_shortest_distance(start, end):
        v_old = [1, 2, 3, 4, 5, 6, 7, 8, 9]
        e_old = [map_sparse]
        g_old = (v_old, e_old)

        v_new = list(itertools.permutations(v_old, 2))
        e_new = []
        g_new = (v_new, e_new)

        for x in v_new:
            for every neighbour a of x[0]:
                if a != x[1]:
                    e_new.append((a, x[0]))

            for every neighbour b of x[1]:
                if b != x[0]:
                    e_new.append((b, x[1]))

            for every neighbour a of x[0]:
                for every neighbour b of x[1]:
                    if a != b:
                        e_new.append((x[0], x[1]), (a, b))
        return self._shortest_distances[start][end]

我想“不碍事”意味着两辆车不能同时在同一个节点

在这种情况下，您可以再次将其建模为最短路径问题，但这次是在一个新的图中，其中每个顶点表示原始图中的一对顶点，即两辆车的位置。因此，让

G=（V，E）

表示您的原始图形，并通过以下方式构造一个新图形

G'=（V'，E'）

：

```
V'
```
包含
```
V
```
中顶点的所有对
```
（u，V）
```
（如果需要，可以省略形式为
```
（u，u）
```
的对，因为这些对无论如何都无法访问）
现在，对于边缘，看看从位置
```
（u，v）
```
会发生什么。第一辆车移动到某个位置
```
a！=v
```
在
```
E
```
中的
```
u
```
和
```
a
```
之间有一条边，或者第二辆车移动到某个位置
```
b！=u
```
在
```
E
```
中的
```
v
```
和
```
b
```
之间有一条边，或者如果
```
a！=b
```

在伪代码中，您可以得到：（对每一对

（u，v）

执行此操作）

然后，您可以查找

（s1，s2）

和

（t1，t2）

之间的最短路径，其中

s1

和

s2

是两个起始点，

e1，e2

是目标点。如果您想让两辆车在同一个顶点开始或结束，则必须添加必要的边以使

（t，t）

您在

G'

中获得了大量顶点，这是

中顶点数量的平方，因此您可以预期大型实例上的运行时也近似为平方（大多数算法用于查找最短路径）。然而，9个顶点很小，所以这里不用担心

顺便说一句，当在正方形网格上（或在任何只有相同长度边的图形上）工作时，Dijkstra有点过分了。您可以通过从起始位置进行简单的BFS（广度优先搜索）来加快速度，并从您沿途的位置进行记录。

我认为“不碍事”意味着两辆车不能同时处于同一节点