单源最短路径算法

最新推荐文章于 2025-06-15 14:08:42 发布

calotte2012

最新推荐文章于 2025-06-15 14:08:42 发布

阅读量901

点赞数

CC 4.0 BY-SA版权

分类专栏：算法

本文链接：https://blog.youkuaiyun.com/u011418829/article/details/82025939

算法专栏收录该内容

9 篇文章

订阅专栏

本文介绍了单源最短路径问题，重点讲解了Dijkstra算法和Bellman-Ford算法。Dijkstra算法通过维护已求得最短路径的顶点集合，每次选择距离根节点最近的未处理顶点更新路径。而Bellman-Ford算法基于松弛原理，通过重复|V|-1次松弛所有边找到最短路径，同时检查负权值环。文章提供了相关实现代码链接。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题引入：给定一个图和图中一顶点root，如何获取该顶点到图中所有顶点的最短路径。

通常有两种方法：DIjkstra算法和Bellman-Ford算法，先说第一种算法。

(1)DIjkstra算法思想主要是维护两个集合，第一个集合是已经求的的最短路径中的顶点s1，第二个则是尚未求的最短路径的顶点s2。每次从s2中选择一个和root距离最短的顶点u，利用此顶点去更新s2中的所有顶点的距离。

(2)Bellman-Ford算法基于松弛原理。与DIjkstra算法每次采用贪心算法选择最短路径的点不同，该算法每次简单的松弛所有边，重复|V|-1次（|V|表示顶点数），因为在没有环的情况下，最长的可能路径有|V|-1条边，所以必须扫描这么多次以保证最长的边均获得松弛。最后，可以再次扫描一次边来判断是否存在负权值的环。

主要实现代码如下：

const int inf=0x3f3f3f3f;

int getMinVertex(vector<int>& dist,vector<bool>& seen){
    int mind=inf,u;
    for(int i=0;i<dist.size();++i){
        if(!seen[i] && dist[i]<mind){
            mind=dist[i];
            u=i;
        }
    }
    return u;
}

void dijkstra(vector<vector<int>>& g,int src,vector<int>& dist){
    auto n=g.size();
    vector<bool> seen(n,false);
    fill(dist.begin(),dist.end(),inf);
    dist[src]=0;
    for(int cnt=0;cnt<n;++cnt){
        int u=getMinVertex(dist,seen);
        seen[u]=true;
        for(int v=0;v<n;++v){
            if(!seen[v] && g[u][v] && dist[u]+g[u][v]<dist[v])
                dist[v]=dist[u]+g[u][v];
        }
    }
}

struct Node{
    int u,v,w;
    Node(int _u,int _v,int _w):u(_u),v(_v),w(_w){}
};

void bellford(vector<vector<int>>& g,int src,vector<int>& dist){
    vector<Node> edges;
    for(int i=0;i<g.size();++i){
        for(int j=0;j<g[0].size();++j){
            if(g[i][j]){
                edges.emplace_back(Node(i,j,g[i][j]));
                edges.emplace_back(Node(i,j,g[i][j]));
            }
        }
    }
    fill(dist.begin(),dist.end(),inf);
    dist[src]=0;
    for(int i=1;i<g.size();++i){
        for(auto e:edges){
            if(dist[e.u]+e.w<dist[e.v])
                dist[e.v]=dist[e.u]+e.w;
        }
    }

    for(auto e:edges){
        if(dist[e.u]+e.w<dist[e.v])
            cout<<"Graph contains a negative-weight cycle\n";
    }
}


int main() {
    vector<vector<int>> g={{0, 4, 0, 0, 0, 0, 0, 8, 0},
                           {4, 0, 8, 0, 0, 0, 0, 11, 0},
                           {0, 8, 0, 7, 0, 4, 0, 0, 2},
                           {0, 0, 7, 0, 9, 14, 0, 0, 0},
                           {0, 0, 0, 9, 0, 10, 0, 0, 0},
                           {0, 0, 4, 14, 10, 0, 2, 0, 0},
                           {0, 0, 0, 0, 0, 2, 0, 1, 6},
                           {8, 11, 0, 0, 0, 0, 1, 0, 7},
                           {0, 0, 2, 0, 0, 0, 6, 7, 0}
                            };
    vector<int> dist(g.size());
    dijkstra(g,0,dist);
    for(auto d:dist)
        cout<<d<<" ";
    cout<<endl;
    vector<int> dist2(g.size());
    bellford(g,0,dist2);
    cout<<"bell-ford:\n";
    for(auto d:dist2)
        cout<<d<<" ";
    cout<<endl;
}

参考：

(1)https://www.geeksforgeeks.org/dijkstras-shortest-path-algorithm-greedy-algo-7/

(2)https://en.wikipedia.org/wiki/Bellman–Ford_algorithm