【最短路径】之Dijkstra算法

最短路径

单源最短路径：计算源点到其他各顶点的最短路径的长度
全局最短路径：图中任意两点的最短路径
Dijkstra、Bellman-Ford、SPFA求单源最短路径
Floyed可以求全局最短路径，但是效率比较低
SPFA算法是Bellman-Ford算法的队列优化
Dijkstra算法不能求带负权边的最短路径，而SPFA算法、Bellman-Ford算法、Floyd-Warshall可以求带负权边的最短路径。
Bellman-Ford算法的核心代码只有4行，Floyd-Warshall算法的核心代码只有5行。
深度优先遍历可以求一个点到另一个点的最短路径的长度

Dijkstra算法

Dijkstra() {初始化;for(循环n次) {u = 使dis[u]最小的还未被访问的顶点的编号;记u为确定值;for(从u出发能到达的所有顶点v){if(v未被访问 && 以u为中介点使s到顶点v的最短距离更优)优化dis[v];}}
}

//邻接矩阵
int n, e[maxv][maxv];
int dis[maxv], pre[maxv];// pre用来标注当前结点的前一个结点
bool vis[maxv] = {false};
void Dijkstra(int s) {fill(dis, dis + maxv, inf);dis[s] = 0;for(int i = 0; i < n; i++) pre[i] = i; //初始状态设每个点的前驱为自身for(int i = 0; i < n; i++) {int u = -1, minn = inf;for(int j = 0; j < n; j++) {if(visit[j] == false && dis[j] < minn) {u = j;minn = dis[j];}}if(u == -1) return;visit[u] = true;for(int v = 0; v < n; v++) {if(visit[v] == false && e[u][v] != inf && dis[u] + e[u][v] < dis[v]) {dis[v] = dis[u] + e[u][v];pre[v] = u; // pre用来标注当前结点的前一个结点}}}
}

//邻接表
struct node {int v, dis;
}
vector<node> e[maxv];
int n;
int dis[maxv], pre[maxv];// pre用来标注当前结点的前一个结点
bool vis[maxv] = {false};
for(int i = 0; i < n; i++) pre[i] = i; //初始状态设每个点的前驱为自身
void Dijkstra(int s) {fill(d, d + maxv, inf);dis[s] = 0;for(int i = 0; i < n; i++) {int u = -1, minn = inf;for(int j = 0; j < n; j++) {if(visit[j] == false && dis[j] < minn) {u = j;minn = dis[j];}}if(u == -1) return ;visit[u] = true;for(int j = 0; j < e[u].size(); j++) {int v = e[u][j].v;if(visit[v] == false && dis[u] + e[u][j].dis < dis[v]) {dis[v] = dis[u] + e[u][j].dis;pre[v] = u;}}}
}

void dfs(int s, int v) {if(v == s) {printf("%d\n", s);return ;}dfs(s, pre[v]);printf("%d\n", v);
}

三种附加考法：第一标尺是距离，如果距离相等的时候，新增第二标尺
- 新增边权（第二标尺），要求在最短路径有多条时要求路径上的花费之和最小

for(int v = 0; v < n; v++) { //重写v的for循环if(visit[v] == false && e[u][v] != inf) {if(dis[u] + e[u][v] < dis[v]) {dis[v] = dis[u] + e[u][v];c[v] = c[u] + cost[u][v];}else if(dis[u] + e[u][v] == dis[v] && c[u] + cost[u][v] < c[v]) {c[v] = c[u] + cost[u][v];}}
}

给定每个点的点权（第二标尺），要求在最短路径上有多条时要求路径上的点权之和最大

for(int v = 0; v < n; v++) {if(visit[v] == false && e[u][v] != inf) {if(dis[u] + e[u][v] < dis[v]) {dis[v] = dis[u] + e[u][v];w[v] = w[u] + weight[v];}else if(dis[u] + e[u][v] == dis[v] && w[u] + weight[v] > w[v]) {w[v] = w[u] + weight[v];}}
}

直接问有多少条最短路径

增加一个数组num[]，num[s] = 1，其余num[u] = 0，表示从起点s到达顶点u的最短路径的条数为num[u]

for(int v = 0; v < n; v++) {if(visit[v] == false && e[u][v] != inf) {if(dis[u] + e[u][v] < dis[v]) {dis[v] = dis[u] + e[u][v];num[u] = num[v];}else if(dis[u] + e[u][v] == dis[v]) {num[v] = num[v] + num[u];}}
}

例子：比如说又要路径最短，又要点权权值最大，而且还要输出个数，而且还要输出路径

for(int v = 0; v < n; v++) {if(visit[v] == false && e[u][v] != inf) {if(dis[u] + e[u][v] < dis[v]) {dis[v] = dis[u] + e[u][v];num[v] = num[u];w[v] = w[u] + weight[v];pre[v] = u;} else if(dis[u] + e[u][v] == dis[v]) {num[v] = num[v] + num[u];if(w[u] + weight[v] > w[v]) {w[v] = w[u] + weight[v];pre[v] = u;}}}
}void printPath(int v) {if(v == s) {printf("%d", v);return ;}printPath(pre[v]);printf("%d ", v);
}

of course, 可以不用这么麻烦，用Dijkstra求最短路径和pre数组，然后用深度优先遍历来获取想知道的一切，包括点权最大，边权最大，路径个数，路径
因为可能有多条路径，所以Dijkstra部分的pre数组使用vecto<int> pre[maxv];

//Dijkstra部分
if(dis[u] + e[u][v] < dis[v]) {dis[v] = dis[u] + e[u][v];pre[v].clear();pre[v].push_back(u);
} else if(dis[i] + e[u] == dis[v]) {pre[v].push_back(u);
}

既然已经求得pre数组，就知道了所有的最短路径，然后要做的就是用dfs遍历所有最短路径，找出一条使第二标尺最优的路径

int optvalue;
vector<int> pre[maxv];
vector<int> path, temppath;
void dfs(int v) { // v为当前访问结点if(v == start) {temppath.push_back(v);int value = 路径temppath上的value值;if(value 优于 optvalue) {optvalue = value;path = temppath;}temppath.pop_back();return ;}temppath.push_back(v);for(int i = 0; i < pre[v].size(); i++)dfs(pre[v][i]);temppath.pop_back();}

解释：
- 对于递归边界而言，如果当前访问的结点是叶子结点（就是路径的开始结点），那么说明到达了递归边界，把v压入temppath，temppath里面就保存了一条完整的路径。如果计算得到的当前的value大于最大值，就path = temppath，然后把temppath的最后一个结点弹出，return ;
- 对于递归式而言，每一次都是把当前访问的结点压入，然后找他的pre[v][i]，进行递归，递归完毕后弹出最后一个结点
计算当前temppath边权或者点权之和的代码：

// 边权之和
int value = 0;
for(int i = tempptah.size() - 1; i > 0; i--) {int id = temppath[i], idnext = temppath[i - 1];value += v[id][idnext];
}
// 点权之和
int value = 0;
for(int i = temppath.size(); i >= 0; i--) {int id = temppath[i];value += w[id];
}

计算路径直接在Dijkstra部分写就可以
例子：计算最短距离的路径和最小花费

#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
int n, m, s, d;
int e[510][510], dis[510], cost[510][510];
vector<int> pre[510];
bool visit[510];
const int inf = 99999999;
vector<int> path, temppath;
int mincost = inf;
void dfs(int v) {if(v == s) {temppath.push_back(v);int tempcost = 0;for(int i = temppath.size() - 1; i > 0; i--) {int id = temppath[i], nextid = temppath[i-1];tempcost += cost[id][nextid];}if(tempcost < mincost) {mincost = tempcost;path = temppath;}temppath.pop_back();return ;}temppath.push_back(v);for(int i = 0; i < pre[v].size(); i++)dfs(pre[v][i]);temppath.pop_back();
}
int main() {fill(e[0], e[0] + 510 * 510, inf);fill(dis, dis + 510, inf);scanf("%d%d%d%d", &n, &m, &s, &d);for(int i = 0; i < m; i++) {int a, b;scanf("%d%d", &a, &b);scanf("%d", &e[a][b]);e[b][a] = e[a][b];scanf("%d", &cost[a][b]);cost[b][a] = cost[a][b];}pre[s].push_back(s);dis[s] = 0;for(int i = 0; i < n; i++) {int u = -1, minn = inf;for(int j = 0; j < n; j++) {if(visit[j] == false && dis[j] < minn) {u = j;minn = j;}}if(u == -1) break;visit[u] = true;for(int v = 0; v < n; v++) {if(visit[v] == false && e[u][v] != inf) {if(dis[v] > dis[u] + e[u][v]) {dis[v] = dis[u] + e[u][v];pre[v].clear();pre[v].push_back(u);} else if(dis[v] == dis[u] + e[u][v]) {pre[v].push_back(u);}}}}dfs(d);for(int i = path.size() - 1; i >= 0; i--)printf("%d ", path[i]);printf("%d %d", dis[d], mincost);return 0;
}
//注意路径path因为是从末端一直压入push_back到path里面的，所以要输出路径的时候倒着输出

【最短路径】之Dijkstra算法相关推荐

最短路径的Dijkstra算法（邻接表）
原文:http://blog.csdn.net/axiqia/article/details/50984464 描述以邻接表作为存储结构实现,求解从给定源点到给定结束点的最短路径. 输入从1开始表 ...
图的单源最短路径：Dijkstra算法实现
本文介绍的是图的非负权值的单源最短路径问题.问题的提出是,对于有权图D,t提供源点v,要找到从v到其他所有点的最短路径,即单源最短路径问题,在本文中,解决这一问题,是普遍比较熟悉的Dijkstra算法 ...
数据结构——最短路径之Dijkstra算法(与最小生成树的prime算法很像，建议一起看)
最短路径之Dijkstra算法 (一)Dijkstra算法单源最短路径:就是从某一个顶点出发,到图中任意顶点之间的最短路径: [算法概述]:Dijkstra算法适用于解决单源最短路径的问题.即:从源 ...
dijkstra算法PHP,单源最短路径（dijkstra算法）php实现
做一个医学项目,其中在病例评分时会用到单源最短路径的算法.单源最短路径的dijkstra算法的思路如下: 如果存在一条从i到j的最短路径(Vi.....Vk,Vj),Vk是Vj前面的一顶点.那么(Vi ...
最短路径之Dijkstra算法
今天看了最短路径之Dijkstra算法,对这算法,写上自己的心得和感悟! 1.Dijkstra算法,(迪杰斯特拉)--单源最短路径求的是一个源点到其他顶点的最短路径算法描述 1).算法思想设G= ...
最短路径问题——Dijkstra算法详解（单源最短路径）
单源最短路径单源最短路径,是指从图中任一点出发到其他各点之间的最短路径. Dijkstra算法介绍 Dijkstra算法又称迪杰特斯拉算法,dijkstra算法的核心思想是将全部结点所在集合V分成两 ...
最短路径（Dijkstra算法），一文必看懂最短路径的方法
最短路径问题(Dijkstra算法) 从图中的某一个顶点出发到达另一个顶点的所经过的边的权重和最小的一条路径,称为最短路径. Dijkstra算法适用于求一个节点到其他节点的最短路径,主要特点是通过广 ...
dijkstra 算法_最短路径问题Dijkstra算法详解
1.Dijkstra算法介绍 · 算法起源: · Djkstra 算法是一种用于计算带权有向图中单源最短路径(SSSP:Single-Source Shortest Path)的算法,由计算机科学家E ...
C语言基本数据结构之三（图的广度及深度遍历，求单源最短路径的Dijkstra算法）
上一篇主要讲了二叉树的先序,中序,后序遍历算法以及深度和节点的算法,这篇就讲一讲图的基本算法. 一.图的基本概念 1.1有向图G1: 有向图G是由两个集合V(G)和E(G)组成的,其中:V(G)是顶点 ...
数据结构最短路径例题_编程小白暑期进阶笔记45-C语言数据结构与算法最短路径和dijkstra算法...
最短路径算法特点: 迪科斯彻算法使用了广度优先搜索解决赋权有向图或者无向图的单源最短路径问题,算法最终得到一个最短路径树.该算法常用于路由算法或者作为其他图算法的一个子模块. 算法思路: Dijks ...

【最短路径】之Dijkstra算法

最短路径

Dijkstra算法

【最短路径】之Dijkstra算法相关推荐

最新文章

热门文章