我的 Dijkstra 算法没有选择最短路径

Question

我尝试使用两个自定义顶点结构和它们的边为我的自定义图编写 Dijkstra 算法，该算法可以编译，但它在选择最佳距离时做出了错误的选择。代码如下。

class Graph {
struct Edge;
struct Vertex {
    std::string _data;  //name of vertex    
    std::list<Edge*> _ins;
    std::list<Edge*> _outs;
    bool visited;
    int BestDist;//best distance from source to sink

};
struct Edge {
    int _weight;
    Vertex *_from;
    Vertex *_to;
    bool travelled; //if the edge has been travalled
};
//Graph of String as key to Values as vertexes
std::unordered_map<std::string, Vertex *> _mainData; 

//Dijkstra Algo
int BestDistance(std::string source, std::string sink) {

    //to save vertexes names
    std::queue<std::string> q;

    //for each vertex set dist and path to infinity
    for (auto startItr : _mainData)
    {
        startItr.second->BestDist = Max;
        startItr.second->visited = false;
        for (auto kachal : startItr.second->_outs)
        {
            kachal->travelled = false;
        }
    }

    //set source distacne to 0 sicen it is visiting itself
    _mainData[source]->BestDist = 0;
    q.push(source);

    //while there is unknown distance vertex and we havent reach sink yet
    while (!q.empty() )
    {
        //smallest unknow distance vertex
        std::string currentVer = q.front(); q.pop();
        //set that vertex to visited
        _mainData[currentVer]->visited = true;

        //for each vertex adj to current vertex
        for (auto adjVer : _mainData[currentVer]->_outs) {
            //if that vertex is not visted
            if (!adjVer->travelled) {
                int cvw = adjVer->_weight; //cost of edge from cuurent vertex to adj vertex

                //if current vert.distance +cvw < adj vertex distance
                if (_mainData[currentVer]->BestDist + cvw < _mainData[adjVer->_to->_data]->BestDist) {
                    //update adj vertex
                    q.push(adjVer->_to->_data);
                    //deacrease adj vertex distacne  to current distacne + cvw
                    _mainData[adjVer->_to->_data]->BestDist = _mainData[currentVer]->BestDist + cvw;
                    //marked the travlled edge true
                    adjVer->travelled = true;
                }
            }
        }
    }
    return _mainData[sink]->BestDist;
}

这是我的主要内容：

 #include "stdafx.h"
 #include "Graph.h"
 #include <iostream>

int main()
 {
 Graph myGraph;
 myGraph.Add("A");
 myGraph.Add("B");
 myGraph.Add("C");
 myGraph.Add("D");
 myGraph.Add("E");
 myGraph.Add("F");
 myGraph.Add("G");

 myGraph.Connect("A", "B",20);
 myGraph.Connect("A", "C",30);
 myGraph.Connect("B", "D",200);
 myGraph.Connect("C", "F",100);
 myGraph.Connect("C", "G",200);
 myGraph.Connect("D", "E",50);
 myGraph.Connect("E", "F",1);
 myGraph.Connect("F", "G",30);
 std::cout << "best distacne example : " << myGraph.BestDistance("A", "G");

所以当我运行代码时，从 A 到 G 的最佳距离应该返回为 160 (A->C->F->G)，但代码返回 280，即 (A->C->G) .我可以提供我的添加和连接功能，但我确信它们工作正常。

Answer 1

所以在分析了上述算法后，我意识到我的错误是将每条边标记为是否经过，并据此做出决定。我应该做的是标记每个顶点是否被访问。其余的都可以。所以这是我在正加权图中找到最短路径的 Dijkstra 算法实现的正确版本。希望对你有帮助

//Dijkstra Algo
int BestDistance(std::string source, std::string sink) {

    //to save vertexes names
    std::queue<std::string> q;

    //for each vertex set dist and path to infinity
    for (auto startItr : _mainData)
    {
        startItr.second->BestDist = Max;
        startItr.second->visited = false;
    }

    //set source distacne to 0 sicen it is visiting itself
    _mainData[source]->BestDist = 0;

    q.push(source);

    //while there is unknown distance vertex and we havent reach sink yet
    while (!q.empty() )
    {
        //smallest unknow distance vertex
        std::string currentVer = q.front(); q.pop();

        //set that vertex to visited
        _mainData[currentVer]->visited = true;

        //for each vertex adj to current vertex
        for (auto adjVer : _mainData[currentVer]->_outs) {
            //if that vertex is not visted
            if (!adjVer->_to->visited) {
                int cvw = adjVer->_weight; //cost of edge from cuurent 
                                           //vertex to adj vertex

                //if current vert.distance +cvw < adj vertex distance
                if (_mainData[currentVer]->BestDist + cvw < 
                   _mainData[adjVer->_to->_data]->BestDist) {

                    q.push(adjVer->_to->_data);

                    //deacrease adj vertex distacne  to current distacne + cvw
                    _mainData[adjVer->_to->_data]->BestDist = _mainData[currentVer]->BestDist + cvw;
                    //setting the path of adj vertext to his previous one
                    _mainData[adjVer->_to->_data]->path = _mainData[currentVer]; 
                }
            }
        }
    }
    return _mainData[sink]->BestDist;
}