Dijkstra(迪杰斯特拉)算法是一种用于寻找带权重图中的最短路径的算法。它由荷兰计算机科学家Edsger Dijkstra于1956年提出,被广泛应用于网络路由算法和地图路线规划等领域。
算法思想:
- 初始化一个距离数组,用于保存起点到每个顶点的当前最短距离(初始时将起点距离设置为0,其他顶点距离设置为无穷大)
- 创建一个集合S,用于保存已经找到最短路径的顶点
- 重复以下步骤,直到集合S包含所有顶点:
- 从未包含在集合S中的顶点中,选择距离起点最短的顶点v
- 将顶点v添加到集合S中
- 对于v的每个邻接顶点u,如果通过v可以缩短起点到顶点u的距离,则更新距离数组中u的距离值为起点到v的距离加上v到u的边的权重
优点:
- Dijkstra算法能够找到起点到各个顶点的最短路径,确保解的正确性。
- 算法的时间复杂度较低,对于稠密图和稀疏图都能够高效地求解最短路径问题。
缺点:
- 算法要求图中边的权重必须为非负数,否则结果可能不正确。
- 当图的规模较大时,Dijkstra算法的时间复杂度较高,不适合处理规模较大的问题。
以下是使用C++语言实现Dijkstra算法的示例代码:
#include <iostream>
#include <vector>
#include <queue>
#include <limits>
using namespace std;
vector<int> dijkstra(vector<vector<pair<int, int>>> graph, int start) {
int n = graph.size();
vector<int> distance(n, numeric_limits<int>::max());
vector<bool> visited(n, false);
distance[start] = 0;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
pq.push({0, start});
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
visited[u] = true;
for (auto &v : graph[u]) {
if (!visited[v.first] && distance[u] + v.second < distance[v.first]) {
distance[v.first] = distance[u] + v.second;
pq.push({distance[v.first], v.first});
}
}
}
return distance;
}
int main() {
int n, m, start;
cin >> n >> m >> start;
vector<vector<pair<int, int>>> graph(n);
for (int i = 0; i < m; ++i) {
int u, v, w;
cin >> u >> v >> w;
graph[u].push_back({v, w});
graph[v].push_back({u, w});
}
vector<int> distance = dijkstra(graph, start);
for (int i = 0; i < n; ++i) {
cout << "Distance from " << start << " to " << i << ": " << distance[i] << endl;
}
return 0;
}
注意事项:
- 确保输入的图数据是正确的,即节点编号和边的权重都符合实际情况。
- 确保起点start的编号在图的范围内。
- 由于Dijkstra算法对于负权边的处理不正确,所以要确保图中的边权重都是非负数。
- 在C++中使用优先队列作为最小堆来保存待处理的顶点,确保能够按照距离的升序进行处理。
Dijkstra(迪杰斯特拉)算法是一种用于寻找带权重图中的最短路径的算法。它由荷兰计算机科学家Edsger Dijkstra于1956年提出,被广泛应用于网络路由算法和地图路线规划等领域。
算法思想:
- 初始化一个距离数组,用于保存起点到每个顶点的当前最短距离(初始时将起点距离设置为0,其他顶点距离设置为无穷大)
- 创建一个集合S,用于保存已经找到最短路径的顶点
- 重复以下步骤,直到集合S包含所有顶点:
- 从未包含在集合S中的顶点中,选择距离起点最短的顶点v
- 将顶点v添加到集合S中
- 对于v的每个邻接顶点u,如果通过v可以缩短起点到顶点u的距离,则更新距离数组中u的距离值为起点到v的距离加上v到u的边的权重
优点:
- Dijkstra算法能够找到起点到各个顶点的最短路径,确保解的正确性。
- 算法的时间复杂度较低,对于稠密图和稀疏图都能够高效地求解最短路径问题。
缺点:
- 算法要求图中边的权重必须为非负数,否则结果可能不正确。
- 当图的规模较大时,Dijkstra算法的时间复杂度较高,不适合处理规模较大的问题。
以下是使用C++语言实现Dijkstra算法的示例代码:
#include <iostream>
#include <vector>
#include <queue>
#include <limits>
using namespace std;
vector<int> dijkstra(vector<vector<pair<int, int>>> graph, int start) {
int n = graph.size();
vector<int> distance(n, numeric_limits<int>::max());
vector<bool> visited(n, false);
distance[start] = 0;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
pq.push({0, start});
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
visited[u] = true;
for (auto &v : graph[u]) {
if (!visited[v.first] && distance[u] + v.second < distance[v.first]) {
distance[v.first] = distance[u] + v.second;
pq.push({distance[v.first], v.first});
}
}
}
return distance;
}
int main() {
int n, m, start;
cin >> n >> m >> start;
vector<vector<pair<int, int>>> graph(n);
for (int i = 0; i < m; ++i) {
int u, v, w;
cin >> u >> v >> w;
graph[u].push_back({v, w});
graph[v].push_back({u, w});
}
vector<int> distance = dijkstra(graph, start);
for (int i = 0; i < n; ++i) {
cout << "Distance from " << start << " to " << i << ": " << distance[i] << endl;
}
return 0;
}
注意事项:
- 确保输入的图数据是正确的,即节点编号和边的权重都符合实际情况。
- 确保起点start的编号在图的范围内。
- 由于Dijkstra算法对于负权边的处理不正确,所以要确保图中的边权重都是非负数。
- 在C++中使用优先队列作为最小堆来保存待处理的顶点,确保能够按照距离的升序进行处理。
Dijkstra(迪杰斯特拉)算法是一种用于寻找带权重图中的最短路径的算法。它由荷兰计算机科学家Edsger Dijkstra于1956年提出,被广泛应用于网络路由算法和地图路线规划等领域。
算法思想:
- 初始化一个距离数组,用于保存起点到每个顶点的当前最短距离(初始时将起点距离设置为0,其他顶点距离设置为无穷大)
- 创建一个集合S,用于保存已经找到最短路径的顶点
- 重复以下步骤,直到集合S包含所有顶点:
- 从未包含在集合S中的顶点中,选择距离起点最短的顶点v
- 将顶点v添加到集合S中
- 对于v的每个邻接顶点u,如果通过v可以缩短起点到顶点u的距离,则更新距离数组中u的距离值为起点到v的距离加上v到u的边的权重
优点:
- Dijkstra算法能够找到起点到各个顶点的最短路径,确保解的正确性。
- 算法的时间复杂度较低,对于稠密图和稀疏图都能够高效地求解最短路径问题。
缺点:
- 算法要求图中边的权重必须为非负数,否则结果可能不正确。
- 当图的规模较大时,Dijkstra算法的时间复杂度较高,不适合处理规模较大的问题。
以下是使用C++语言实现Dijkstra算法的示例代码:
#include <iostream>
#include <vector>
#include <queue>
#include <limits>
using namespace std;
vector<int> dijkstra(vector<vector<pair<int, int>>> graph, int start) {
int n = graph.size();
vector<int> distance(n, numeric_limits<int>::max());
vector<bool> visited(n, false);
distance[start] = 0;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
pq.push({0, start});
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
visited[u] = true;
for (auto &v : graph[u]) {
if (!visited[v.first] && distance[u] + v.second < distance[v.first]) {
distance[v.first] = distance[u] + v.second;
pq.push({distance[v.first], v.first});
}
}
}
return distance;
}
int main() {
int n, m, start;
cin >> n >> m >> start;
vector<vector<pair<int, int>>> graph(n);
for (int i = 0; i < m; ++i) {
int u, v, w;
cin >> u >> v >> w;
graph[u].push_back({v, w});
graph[v].push_back({u, w});
}
vector<int> distance = dijkstra(graph, start);
for (int i = 0; i < n; ++i) {
cout << "Distance from " << start << " to " << i << ": " << distance[i] << endl;
}
return 0;
}
注意事项:
- 确保输入的图数据是正确的,即节点编号和边的权重都符合实际情况。
- 确保起点start的编号在图的范围内。
- 由于Dijkstra算法对于负权边的处理不正确,所以要确保图中的边权重都是非负数。
- 在C++中使用优先队列作为最小堆来保存待处理的顶点,确保能够按照距离的升序进行处理。
Dijkstra(迪杰斯特拉)算法是一种用于寻找带权重图中的最短路径的算法。它由荷兰计算机科学家Edsger Dijkstra于1956年提出,被广泛应用于网络路由算法和地图路线规划等领域。
算法思想:
- 初始化一个距离数组,用于保存起点到每个顶点的当前最短距离(初始时将起点距离设置为0,其他顶点距离设置为无穷大)
- 创建一个集合S,用于保存已经找到最短路径的顶点
- 重复以下步骤,直到集合S包含所有顶点:
- 从未包含在集合S中的顶点中,选择距离起点最短的顶点v
- 将顶点v添加到集合S中
- 对于v的每个邻接顶点u,如果通过v可以缩短起点到顶点u的距离,则更新距离数组中u的距离值为起点到v的距离加上v到u的边的权重
优点:
- Dijkstra算法能够找到起点到各个顶点的最短路径,确保解的正确性。
- 算法的时间复杂度较低,对于稠密图和稀疏图都能够高效地求解最短路径问题。
缺点:
- 算法要求图中边的权重必须为非负数,否则结果可能不正确。
- 当图的规模较大时,Dijkstra算法的时间复杂度较高,不适合处理规模较大的问题。
以下是使用C++语言实现Dijkstra算法的示例代码:
#include <iostream>
#include <vector>
#include <queue>
#include <limits>
using namespace std;
vector<int> dijkstra(vector<vector<pair<int, int>>> graph, int start) {
int n = graph.size();
vector<int> distance(n, numeric_limits<int>::max());
vector<bool> visited(n, false);
distance[start] = 0;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
pq.push({0, start});
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
visited[u] = true;
for (auto &v : graph[u]) {
if (!visited[v.first] && distance[u] + v.second < distance[v.first]) {
distance[v.first] = distance[u] + v.second;
pq.push({distance[v.first], v.first});
}
}
}
return distance;
}
int main() {
int n, m, start;
cin >> n >> m >> start;
vector<vector<pair<int, int>>> graph(n);
for (int i = 0; i < m; ++i) {
int u, v, w;
cin >> u >> v >> w;
graph[u].push_back({v, w});
graph[v].push_back({u, w});
}
vector<int> distance = dijkstra(graph, start);
for (int i = 0; i < n; ++i) {
cout << "Distance from " << start << " to " << i << ": " << distance[i] << endl;
}
return 0;
}
注意事项:
- 确保输入的图数据是正确的,即节点编号和边的权重都符合实际情况。
- 确保起点start的编号在图的范围内。
- 由于Dijkstra算法对于负权边的处理不正确,所以要确保图中的边权重都是非负数。
- 在C++中使用优先队列作为最小堆来保存待处理的顶点,确保能够按照距离的升序进行处理。