### 狄克斯特拉(Dijkstra)算法实现
狄克斯特拉算法用于求解带权有向图或无向图中，从一个源节点到所有其他节点的最短路径。对于无权图，可以将每条边的权重视为1。以下是使用邻接矩阵实现的狄克斯特拉算法代码：
```cpp
#include <iostream>
#include <cstring>
#include <climits>
using namespace std;
const int MAXN = 100;
// 狄克斯特拉算法函数
void dijkstra(int graph[MAXN][MAXN], int n, int source) {
int dist[MAXN]; // 存储源点到各点的最短距离
bool sptSet[MAXN]; // 标记节点是否已确定最短路径
// 初始化距离数组和标记数组
for (int i = 0; i < n; i++) {
dist[i] = INT_MAX;
sptSet[i] = false;
}
dist[source] = 0; // 源点到自身的距离为0
// 迭代n次，每次确定一个节点的最短路径
for (int count = 0; count < n - 1; count++) {
int u = -1;
int minDist = INT_MAX;
// 找到未确定最短路径的节点中距离源点最近的节点
for (int v = 0; v < n; v++) {
if (!sptSet[v] && dist[v] <= minDist) {
minDist = dist[v];
u = v;
}
}
sptSet[u] = true; // 标记该节点已确定最短路径
// 更新与u相邻节点的距离
for (int v = 0; v < n; v++) {
if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v]) {
dist[v] = dist[u] + graph[u][v];
}
}
}
// 输出结果
for (int i = 0; i < n; i++) {
cout << "从节点 " << source << " 到节点 " << i << " 的最短距离是: ";
if (dist[i] == INT_MAX) {
cout << "无法到达" << endl;
} else {
cout << dist[i] << endl;
}
}
}
int main() {
int n = 5; // 节点数
int graph[MAXN][MAXN] = {
{0, 1, 0, 1, 0},
{1, 0, 1, 0, 0},
{0, 1, 0, 1, 1},
{1, 0, 1, 0, 1},
{0, 0, 1, 1, 0}
};
int source = 0; // 源节点
dijkstra(graph, n, source);
return 0;
}
```
### 广度优先搜索（BFS）算法实现
广度优先搜索算法是一种用于遍历或搜索树或图的算法。在无权图中，BFS可以用来求解单源最短路径问题。以下是使用邻接表实现的BFS算法代码：
```cpp
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int MAXN = 100;
// BFS算法函数
void bfs(vector<int> adj[], int n, int source) {
int dist[MAXN]; // 存储源点到各点的最短距离
for (int i = 0; i < n; i++) {
dist[i] = -1; // 初始化为无法到达
}
queue<int> q;
q.push(source);
dist[source] = 0; // 源点到自身的距离为0
while (!q.empty()) {
int u = q.front();
q.pop();
// 遍历u的所有邻接节点
for (int v : adj[u]) {
if (dist[v] == -1) {
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
// 输出结果
for (int i = 0; i < n; i++) {
cout << "从节点 " << source << " 到节点 " << i << " 的最短距离是: ";
if (dist[i] == -1) {
cout << "无法到达" << endl;
} else {
cout << dist[i] << endl;
}
}
}
int main() {
int n = 5; // 节点数
vector<int> adj[MAXN];
// 添加边
adj[0].push_back(1);
adj[0].push_back(3);
adj[1].push_back(0);
adj[1].push_back(2);
adj[2].push_back(1);
adj[2].push_back(3);
adj[2].push_back(4);
adj[3].push_back(0);
adj[3].push_back(2);
adj[3].push_back(4);
adj[4].push_back(2);
adj[4].push_back(3);
int source = 0; // 源节点
bfs(adj, n, source);
return 0;
}
```
本文介绍了BFS（广度优先搜索）、贝尔曼福特算法及狄克斯特拉算法三种经典的最短路径搜索算法。BFS利用队列进行层次遍历，适用于路径权重相同的场景。贝尔曼福特算法通过遍历每条边更新节点的最短距离，适用于存在负权边的情况。狄克斯特拉算法则通过优先选择离起点最近的点来更新其他节点的距离。
扫一扫
2178
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
