📜  在 STL 中使用集合的 Dijkstra 最短路径算法

📅  最后修改于: 2022-05-13 01:57:54.428000             🧑  作者: Mango

在 STL 中使用集合的 Dijkstra 最短路径算法

给定一个图和图中的一个源顶点,找到从源到给定图中所有顶点的最短路径。

在 STL 中使用集合的 Dijkstra 最短路径算法

Input : Source = 0
Output : 
     Vertex   Distance from Source
        0                0
        1                4
        2                12
        3                19
        4                21
        5                11
        6                9
        7                8
        8                14

我们已经讨论了 Dijkstra 的最短路径实现。

  • Dijkstra 的邻接矩阵表示算法(在 C/C++ 中,时间复杂度为 O(v 2 )
  • Dijkstra 的邻接表表示算法(在 C 语言中,时间复杂度为 O(ELogV))

第二种实现在时间复杂度方面更好,但确实很复杂,因为我们已经实现了自己的优先级队列。 STL 提供了priority_queue,但是提供的优先级队列不支持减少键和删除操作。在 Dijkstra 的算法中,我们需要一个优先级队列以及对优先级队列的以下操作:

  • ExtractMin :从所有尚未找到最短距离的顶点中,我们需要得到距离最小的顶点。
  • DecreaseKey :提取顶点后,我们需要更新其相邻顶点的距离,如果新的距离更小,则更新数据结构中的距离。

上面的操作可以通过c++ STL的set数据结构很容易实现,set保持它所有的key都是有序的,所以最小的远距离顶点总是在开始,我们可以从那里提取它,这就是ExtractMin操作,并相应地更新其他相邻的顶点如果任何顶点的距离变小,则删除其先前的条目并插入新的更新条目,即 DecreaseKey 操作。

下面是基于集合数据结构的算法。

1) Initialize distances of all vertices as infinite.

2) Create an empty set.  Every item of set is a pair
  (weight, vertex). Weight (or distance) is used used
  as first item  of pair as first item is by default 
  used to compare two pairs.

3) Insert source vertex into the set and make its
   distance as 0.

4) While Set doesn't become empty, do following
    a) Extract minimum distance vertex from Set. 
       Let the extracted vertex be u.
    b) Loop through all adjacent of u and do 
       following for every vertex v.

           // If there is a shorter path to v
           // through u. 
           If dist[v] > dist[u] + weight(u, v)

               (i) Update distance of v, i.e., do
                     dist[v] = dist[u] + weight(u, v)
               (i) If v is in set, update its distance
                   in set by removing it first, then
                   inserting with new distance
               (ii) If v is not in set, then insert
                    it in set with new distance
               
5) Print distance array dist[] to print all shortest
   paths. 

下面是上述想法的 C++ 实现。

C++
// Program to find Dijkstra's shortest path using STL set
#include
using namespace std;
# define INF 0x3f3f3f3f
 
// This class represents a directed graph using
// adjacency list representation
class Graph
{
    int V;    // No. of vertices
 
    // In a weighted graph, we need to store vertex
    // and weight pair for every edge
    list< pair > *adj;
 
public:
    Graph(int V);  // Constructor
 
    // function to add an edge to graph
    void addEdge(int u, int v, int w);
 
    // prints shortest path from s
    void shortestPath(int s);
};
 
// Allocates memory for adjacency list
Graph::Graph(int V)
{
    this->V = V;
    adj = new list< pair >[V];
}
 
void Graph::addEdge(int u, int v, int w)
{
    adj[u].push_back(make_pair(v, w));
    adj[v].push_back(make_pair(u, w));
}
 
// Prints shortest paths from src to all other vertices
void Graph::shortestPath(int src)
{
    // Create a set to store vertices that are being
    // processed
    set< pair > setds;
 
    // Create a vector for distances and initialize all
    // distances as infinite (INF)
    vector dist(V, INF);
 
    // Insert source itself in Set and initialize its
    // distance as 0.
    setds.insert(make_pair(0, src));
    dist[src] = 0;
 
    /* Looping till all shortest distance are finalized
       then setds will become empty    */
    while (!setds.empty())
    {
        // The first vertex in Set is the minimum distance
        // vertex, extract it from set.
        pair tmp = *(setds.begin());
        setds.erase(setds.begin());
 
        // vertex label is stored in second of pair (it
        // has to be done this way to keep the vertices
        // sorted distance (distance must be first item
        // in pair)
        int u = tmp.second;
 
        // 'i' is used to get all adjacent vertices of a vertex
        list< pair >::iterator i;
        for (i = adj[u].begin(); i != adj[u].end(); ++i)
        {
            // Get vertex label and weight of current adjacent
            // of u.
            int v = (*i).first;
            int weight = (*i).second;
 
            //    If there is shorter path to v through u.
            if (dist[v] > dist[u] + weight)
            {
                /*  If distance of v is not INF then it must be in
                    our set, so removing it and inserting again
                    with updated less distance. 
                    Note : We extract only those vertices from Set
                    for which distance is finalized. So for them,
                    we would never reach here.  */
                if (dist[v] != INF)
                    setds.erase(setds.find(make_pair(dist[v], v)));
 
                // Updating distance of v
                dist[v] = dist[u] + weight;
                setds.insert(make_pair(dist[v], v));
            }
        }
    }
 
    // Print shortest distances stored in dist[]
    printf("Vertex   Distance from Source\n");
    for (int i = 0; i < V; ++i)
        printf("%d \t\t %d\n", i, dist[i]);
}
 
// Driver program to test methods of graph class
int main()
{
    // create the graph given in above figure
    int V = 9;
    Graph g(V);
 
    //    making above shown graph
    g.addEdge(0, 1, 4);
    g.addEdge(0, 7, 8);
    g.addEdge(1, 2, 8);
    g.addEdge(1, 7, 11);
    g.addEdge(2, 3, 7);
    g.addEdge(2, 8, 2);
    g.addEdge(2, 5, 4);
    g.addEdge(3, 4, 9);
    g.addEdge(3, 5, 14);
    g.addEdge(4, 5, 10);
    g.addEdge(5, 6, 2);
    g.addEdge(6, 7, 1);
    g.addEdge(6, 8, 6);
    g.addEdge(7, 8, 7);
 
    g.shortestPath(0);
 
    return 0;
}


输出 :

Vertex   Distance from Source
0          0
1          4
2          12
3          19
4          21
5          11
6          9
7          8
8          14