Dijkstra 算法的 C++ 实现

本文介绍了Dijkstra算法的基本原理及其在最短路径问题中的应用。该算法以起始点为中心逐层扩展,确保找到从起点到其他各点的最短路径。适用于所有边权均为正的情况,并提供了算法的C++实现。

Dijkstra算法 Dijkstra(迪杰斯特拉)算法是典型的最短路径路由算法,是广度优先算法的一种,用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止。其基本原理是:每次新扩展一个距离最短的点,更新与其相邻的点的距离。当所有边权都为正时,由于不会存在一个距离更短的没扩展过的点,所以这个点的距离永远不会再被改变,因而保证了算法的正确性。不过根据这个原理,用Dijkstra求最短路的图不能有负权边,因为扩展到负权边的时候会产生更短的距离,有可能就破坏了已经更新的点距离不会改变的性质。 Dijkstra算法能得出最短路径的最优解,但由于它遍历计算的节点很多,所以效率低。 Dijkstra算法是很有代表性的最短路算法,在很多专业课程中都作为基本内容有详细的介绍,如数据结构,图论,运筹学等等。
Dijkstra 算法的时间复杂度为O(n^2)   
空间复杂度取决于存储方式,邻接矩阵为O(n^2)
代码实现

#include <stdio.h>
#include <vector>
#include <iostream>
using namespace std;
#define INF 0x7fffffff
#define maxN 50
#define USE_C 1
#define NOT_USE_C 0
#define USE_CPP 1
int matrix[maxN][maxN];
void Dijkstra_cpp(vector<vector<int>>&vec,vector<int>& result,int v0){
    vector<int> visited(vec.size(),0);
    int last_visitied = 0;
    result[0] = 0;
    for(int i =0;i<vec.size()-1;i++){
        for(int j = 0;j<vec.size()-1;j++){
        if(visited[i]==0){
            if(vec[v0][j]!= 0){
            int dist =vec[v0][j] +last_visited;
            if(dist<result[j])
            result[j] = dist;
        }
    }
}
    int minIndex = 0;
    while(visited[minIndex] == 1)
        minIndex++;
    for(int j = minIndex;j<vec.size();j++){
        if(visited[j] ==0&&result[j]<result[minIndex]){
            minIndex = j;
        }
    }
    last_visited = result[minIndex];
    visited[minIndex] = 1;
    v0 = minIndex;
    }
} 
int _tmain(int argc,_TCHAR* argv[]){
    freopen("Dijkstra2Data.txt","r",stdin);
    int n;
    cin>>n;
    vector<vector<int>> vec(n,vector<int>(n,0));
    for(i = 0;i<n;i++){
        for(j = 0;j<n;j++){
            cin>>vec[i][j];
        }
    }
    vector<int> result(n,INF);
    Dijkstra_cpp(vec,result,0);
    for(int i  =0;i<n;i++){
        if(result[i] == INF)
        cout<<"INF"<<endl;
        else
        cout<<result[i]<<endl;
    }
    return 0;
}
Dijkstra算法是用于寻找图中从单一源点到所有其他节点的最短路径的算法,下面是其C++代码实现: ```cpp #include <iostream> #include <vector> #include <string> #include <climits> using namespace std; const int INFINITY = INT_MAX; const int VISITED = 1; const int UNVISITED = 0; // 边的结构体 struct Edge { int end; int weight; Edge(int e, int w) : end(e), weight(w) {} }; // 路径结构体 struct Path { string route; }; // 假设的图类 class Graph { private: int verticesNum; vector<vector<int>> matrix; vector<int> Mark; vector<Path> path; public: Graph(int n) : verticesNum(n) { matrix.resize(n, vector<int>(n, INFINITY)); Mark.resize(n, UNVISITED); path.resize(n); } // 获取顶点数量 int VerticesNum() { return verticesNum; } // 添加边 void AddEdge(int from, int to, int weight) { matrix[from][to] = weight; } // 获取第一条边 Edge FirstEdge(int v) { for (int i = 0; i < verticesNum; i++) { if (matrix[v][i] != INFINITY) { return Edge(i, matrix[v][i]); } } return Edge(-1, INFINITY); } // 获取下一条边 Edge NextEdge(Edge e) { for (int i = e.end + 1; i < verticesNum; i++) { if (matrix[e.end][i] != INFINITY) { return Edge(i, matrix[e.end][i]); } } return Edge(-1, INFINITY); } // 判断是否为边 bool IsEdge(Edge e) { return e.end != -1; } // Dijkstra算法实现 void Dijkstra(int s, int D[]) { path.resize(verticesNum); int i, j; for (i = 0; i < verticesNum; i++) { D[i] = matrix[s][i]; path[i].route = "v" + to_string(s) + "-->" + "v" + to_string(i); } Mark[s] = VISITED; D[s] = 0; for (i = 0; i < verticesNum; i++) { // 找到一条最短的特殊路径 int min = INFINITY; int k = 0; for (j = 0; j < verticesNum; j++) { if (Mark[j] == UNVISITED && min > D[j]) { min = D[j]; k = j; } } Mark[k] = VISITED; for (Edge e = FirstEdge(k); IsEdge(e); e = NextEdge(e)) { int endVertex = e.end; if (Mark[endVertex] == UNVISITED && D[endVertex] > (D[k] + e.weight) && e.weight != INFINITY) { // 更新endVertex的最短特殊路径 D[endVertex] = D[k] + e.weight; path[endVertex].route = path[k].route + "-->v" + to_string(endVertex); } } } for (int i = 0; i < verticesNum; i++) { if (D[i] != INFINITY) { cout << path[i].route << endl; } else { cout << "no road" << endl; } } } }; int main() { int n = 5; // 假设有5个节点 Graph g(n); // 添加边 g.AddEdge(0, 1, 10); g.AddEdge(0, 3, 30); g.AddEdge(1, 2, 50); g.AddEdge(2, 4, 10); g.AddEdge(3, 2, 20); g.AddEdge(3, 4, 60); int D[5]; g.Dijkstra(0, D); return 0; } ``` 上述代码实现Dijkstra算法,通过图类`Graph`来表示图结构,`Dijkstra`函数实现算法的核心逻辑。在`main`函数中,创建了一个图并添加了边,然后调用`Dijkstra`函数计算从节点0到其他节点的最短路径并输出结果 [^1]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值