Dijkstra算法
应用
解决单源最短路径
思想
贪心
大致实现过程
用一个二维数组存有向图，如map[i][j]表示从i点到j点的距离，一个一维数组book存储0和1表示该点是否被纳入最短路径，一个一维数组dist存储源点到该点的最短路径，算法开始，将book数组的值全部赋值1，dist数组全部赋值无穷大，先将与源点相连的点的dist数组赋值，再进入for循环，假如共有n个顶点，则循环n次，在循环中每次在没有被纳入最短路径的点中通过dist数组找出一个离源点最近的一个A点，然后用这个A点作为中转点，更新没有被纳入最短路径且与这个A点相连的点的dist数组中的值，n次循环结束之后dist数组中存的值就是源点到该点的最短路径。
具体代码
#include<stdio.h>
#define size 10001
#define most 999999
int dist[size];//起点到其余各顶点的最短路径长度，初始化为无穷大
int before[size];//顶点到其所在的最短路径上的前一个顶点的数组下标信息，初始化为-1,可给出源点到此点的最短路径的具体路径
bool book[size];//用来标记顶点是否已经并入最短路径，初始化为false表示没有被纳入最短路径
int map[size][size];//用来存储各顶点之间的关系，map[x][y]中存储的值表示为x点到y点的距离
int n, m, s;//分别表示点的个数，有向边的个数，出发点（源点）的编号
void init() { //算法初始化
book[s] = true; //标记源点，将源点纳入最短路径
for (int i = 1; i <= n; i++) {
if (i != s) {
book[i] = false;//初始化用来标记的数组
}
before[i] = -1; //初始化前驱数组
for (int li = 1; li <= n; li++) {//初始化存储图数据的数组
if (i != li) {
map[i][li] = most; //无穷值认为两个顶点之间不能到达
} else {
map[i][li] = 0; //一个顶点到自身顶点之间的距离为0
}
}
}
}
void run_dijkstra() {
for (int i = 1; i <= n - 1; i++) {
int min = most, x;
for (int j = 1; j <= n; j++) {//找到离源点最近且没有被纳入最短路径的顶点，设该点为x点
if (!book[j] && dist[j] < min) {
min = dist[j];
x = j;
}
}
book[x] = true;//将离更新点最近的点x点标记
for (int j = 1; j <= n; j++) {//更新与x点相连的点的到源点距离
if (!book[j] && (dist[x] + map[x][j] < dist[j])) {//此点没有被标记且通过x点做中转点可缩短此点到源点的距离
dist[j] = dist[x] + map[x][j];//更新此点到源点的距离
before[j] = x;//更新此点的前驱点为x点
}
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &s);
init();//输入n,m,s之后再初始化
for (int i = 0; i < m; i++) { //输入数据
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
map[a][b] = c;
}
for (int i = 1; i <= n; i++) { //初始化dist数组，这里初始与源点想连的其余各个顶点的路程
dist[i] = map[s][i];
}
run_dijkstra();
for (int i = 1; i <= n; i++) {
printf("%d ", dist[i]);
}
}该代码用链式前向星优化存图方式之后
#include<stdio.h>
#include<string.h>
#define size 10001
#define most 0x3f3f3f3f
long long dist[size];//起点到其余各顶点的最短路径长度，初始化为无穷大
int before[size];//顶点到其所在的最短路径上的前一个顶点的数组下标信息，初始化为-1,
//可给出源点到此点的最短路径的具体路径
bool book[size];//用来标记顶点是否已经并入最短路径，初始化为false表示没有被纳入最短路径
int n, m, s;//分别表示点的个数，有向边的个数，出发点（源点）的编号
struct edges { //链式前向星存图
int x;//该边的尾(edge[i].x表示第i条边的终)
int distan;//此边的权值
int next;//同起点的下一条边在edge数组中的储存位置
} edge[size*10000];//用来存边
int num;//对边进行编号的
int head[size];//head[i]表示以i为起点的第一条边在edge数组中的位置，即edge数组的下标
void toin(int a, int b, int c) { //存边，a,b,c分别表示两个顶点和该边的权值（距离）
num++;//编号增加
edge[num].x = b;//
edge[num].distan = c;//存入该边的权值
edge[num].next = head[a];//将以a为起点的前一条边的编号放在这要存的这条边的next里面
head[a] = num;//让head[a]等于存入的这条边的编号
}
void init() { //算法初始化
num = 0; //编号初始化为0
memset(book, 0, sizeof(book));
memset(before, -1, sizeof(before));
memset(dist,0x3f3f3f3f,sizeof(dist));
dist[s] = 0;
}
/*
void run_dijkstra() {
int sa = s;
while (!book[sa]) {
book[sa] = true;
for (int i = head[sa]; i != 0; i = edge[i].next) { //链式前向星开始以sa为始顶点搜边
if (!book[edge[i].x] && dist[edge[i].x] > dist[sa] + edge[i].distan) {
dist[edge[i].x] = dist[sa] + edge[i].distan;
before[i]=edge[i].x;
}
}
long long min = most;
for (int i = 1; i <= n; i++) { //从所有还没有被纳入最短路径的点中找一个离源点最短的点
if (!book[i] && min > dist[i]) {
sa = i;
min = dist[i];
}
}
}
}
*/
void run_dijkstra() {
for (int i = 1; i <= n - 1; i++) {
int min = most, g;
for (int j = 1; j <= n; j++) {//找到此时离源点最近且没有被纳入最短路径的顶点，设该点为x点
if (!book[j] && dist[j] < min) {
min = dist[j];
g = j;
}
}
book[g] = true;//将离更新点最近的点x点标记
for (int i = head[g]; i != 0; i = edge[i].next) { //链式前向星开始以g为始顶点搜边
if (!book[edge[i].x] && dist[edge[i].x] > dist[g] + edge[i].distan) {
dist[edge[i].x] = dist[g] + edge[i].distan;
before[i]=edge[i].x;
}
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &s);
init();//输入n,m,s之后再初始化
for (int i = 0; i < m; i++) { //输入数据
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
toin(a, b, c);
}
run_dijkstra();
for (int i = 1; i <= n; i++) {
printf("%d ", dist[i]);
}
}经典例题
【模板】单源最短路径（弱化版）
题目背景
本题测试数据为随机数据，在考试中可能会出现构造数据让SPFA不通过，如有需要请移步 P4779。
题目描述
如题，给出一个有向图，请输出从某一点出发到所有点的最短路径长度。
输入格式
第一行包含三个整数 n,m,sn,m,s，分别表示点的个数、有向边的个数、出发点的编号。
接下来 mm 行每行包含三个整数 u,v,wu,v,w，表示一条 u→vu→v 的，长度为 ww 的边。
输出格式
输出一行 nn 个整数，第 ii 个表示 ss 到第 ii 个点的最短路径，若不能到达则输出 231−1231−1。
输入输出样例
输入 #1
4 6 1
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4输出 #1
0 2 4 3
说明/提示
【数据范围】
对于 20%20% 的数据：1≤n≤51≤n≤5，1≤m≤151≤m≤15；
对于 40%40% 的数据：1≤n≤1001≤n≤100，1≤m≤1041≤m≤104；
对于 70%70% 的数据：1≤n≤10001≤n≤1000，1≤m≤1051≤m≤105；
对于 100%100% 的数据：1≤n≤1041≤n≤104，1≤m≤5×1051≤m≤5×105，1≤u,v≤n1≤u,v≤n，w≥0w≥0，∑w<231∑w<231，保证数据随机。Update 2022/07/29：两个点之间可能有多条边，敬请注意。
对于真正 100%100% 的数据，请移步 P4779。请注意，该题与本题数据范围略有不同。
样例说明：
图片1到3和1到4的文字位置调换
思路：略
朴素的代码没有过（<.-.>）。。
#include<stdio.h>
#define size 10001
#define most 0x3f3f3f3f
int dist[size];//起点到其余各顶点的最短路径长度，初始化为无穷大
int before[size];//顶点到其所在的最短路径上的前一个顶点的数组下标信息，初始化为-1,可给出最短路径的具体路径
bool book[size];//用来标记顶点是否已经并入最短路径，初始化为false表示没有被纳入最短路径
int map[size][size];//用来存储各顶点之间的关系，map[x][y]中存储的值表示为x点到y点的距离
int n, m, s;//分别表示点的个数，有向边的个数，出发点（源点）的编号
void init() { //算法初始化
book[s] = true; //标记源点，将源点纳入最短路径
for (int i = 1; i <= n; i++) {
if (i != s) {
book[i] = false;//初始化用来标记的数组
}
before[i] = -1; //初始化前驱数组
for (int li = 1; li <= n; li++) {//初始化存储图数据的数组
if (i != li) {
map[i][li] = most; //无穷值认为两个顶点之间不能到达
} else {
map[i][li] = 0; //一个顶点到自身顶点之间的距离为0
}
}
}
}
void run_dijkstra() {
for (int i = 1; i <= n - 1; i++) {
//找到离源点最近的顶点
int min = most, mi;
for (int j = 1; j <= n; j++) {
if (!book[j] && dist[j] < min) {
min = dist[j];
mi = j;
}
}
book[mi] = true;
for (int j = 1; j <= n; j++) {
if (!book[j] && (dist[mi] + map[mi][j] < dist[j])) {
dist[j] = dist[mi] + map[mi][j];
before[j] = mi;
}
}
}
}
//
void printmap() {
printf("/// \n");
for (int i = 1; i <= n; i++) {
for (int k = 1; k <= n; k++) {
printf("%d ", map[i][k]);
}
printf("\n");
}
printf("/// \n");
}
void initagain() {
for (int i = 1; i <= n; i++) {
map[i][i] = 0;
}
}
//
int main() {
scanf("%d %d %d", &n, &m, &s);
init();//输入n,m,s之后再初始化
for (int i = 0; i < m; i++) { //输入数据
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
if(c>map[a][b]){
continue;
}
map[a][b] = c;
}
initagain();
for (int i = 1; i <= n; i++) { //初始化dist数组，这里是源点到其余各个顶点的初始路程
dist[i] = map[s][i];
}
run_dijkstra();
for (int i = 1; i <= n; i++) {
printf("%d ", dist[i]);
}
}利用链式前向星优化存图方式之后
#include<stdio.h>
#include<string.h>
#define size 10001
#define most 2147483647
long long dist[size];//起点到其余各顶点的最短路径长度，初始化为无穷大
int before[size];//顶点到其所在的最短路径上的前一个顶点的数组下标信息，初始化为-1,
//可给出源点到此点的最短路径的具体路径
bool book[size];//用来标记顶点是否已经并入最短路径，初始化为false表示没有被纳入最短路径
int n, m, s;//分别表示点的个数，有向边的个数，出发点（源点）的编号
struct edges { //链式前向星存图
int x;//该边的尾(edge[i].x表示第i条边的终)
int distan;//此边的权值
int next;//同起点的下一条边在edge数组中的储存位置
} edge[size*10000];//用来存边
int num;//对边进行编号的
int head[size];//head[i]表示以i为起点的第一条边在edge数组中的位置，即edge数组的下标
void toin(int a, int b, int c) { //存边，a,b,c分别表示两个顶点和该边的权值（距离）
num++;//编号增加
edge[num].x = b;//
edge[num].distan = c;//存入该边的权值
edge[num].next = head[a];//将以a为起点的第二条边放在第一条边前面
head[a] = num;//让head[a]等于第二条边的编号
}
void init() { //算法初始化
num = 0; //编号初始化为0
/*
for (int i = 1; i <= n; i++) {
book[i] = false;//初始化用来标记的数组
before[i] = -1; //初始化前驱数组
dist[i] = most;
}
for (int i = 0; i < m; i++) { //初始化head数组
head[i] = -1;
}
*/
memset(book, 0, sizeof(book));
memset(before, -1, sizeof(before));
//memset(dist, 0x3f3f3f3f, sizeof(dist));
for(int i=1;i<=n;i++){
dist[i]=most;
}
dist[s] = 0;
}
void run_dijkstra() {
int sa = s;
while (!book[sa]) {
book[sa] = true;
for (int i = head[sa]; i != 0; i = edge[i].next) { //链式前向星开始以sa为始顶点搜边
if (!book[edge[i].x] && dist[edge[i].x] > dist[sa] + edge[i].distan) {
dist[edge[i].x] = dist[sa] + edge[i].distan;
}
}
long long min = most;
for (int i = 1; i <= n; i++) { //从所有还没有被纳入最短路径的点中找一个离源点最短的点
if (!book[i] && min > dist[i]) {
sa = i;
min = dist[i];
}
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &s);
init();//输入n,m,s之后再初始化
for (int i = 0; i < m; i++) { //输入数据
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
toin(a, b, c);
}
run_dijkstra();
for (int i = 1; i <= n; i++) {
printf("%d ", dist[i]);
}
}
528
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
