[算法与数据结构] - No.10 图论(3)- 最短路Dijkstra算法、Bellman-Ford算法和Floyd算法
2017-08-04 23:06
621 查看
最短路径问题:如果从图中某一顶点(称为源点)到达另一顶点(称为终点)的路径可能不止一条,如何找到一条路径使得沿此路径上各边上的权值总和达到最小。
三种算法主要用途:
1. 边上权值非负情形的单源最短路径问题 — Dijkstra算法
2. 边上权值为任意值的单源最短路径问题 — Bellman和Ford算法
3. 所有顶点之间的最短路径 — Floyd算法
Dijkstra算法:贪心策略
算法思想:设G=(V,E)是一个带权有向图,把图中顶点集合V分成两组,已求出最短路径的顶点集合S和其余未确定最短路径的顶点集合V-S,按最短路径长度的递增次序依次把V-S的顶点加入S中。选择V-S中距离远点路径最短的点v',以v'为中转点更新所有的点的最短路径
起始设置所有点距离源点v的最短路径。如果v'与v相连,那么最短路径就是<v,v'>的长度,否则就是无穷大
Bellman-Ford算法:持续松弛操作
什么叫松弛操作呢?在松弛一条边(u,v)的过程中,要测试是否可以通过u,对迄今找到的v的最短路径进行改进;如果可以改进的话,则更新d[v]。
bellman-ford算法是对图进行n-1次松弛操作,如果n-1次松弛操作以后还能继续进行松弛操作,那么说明原图中有负环(即圈的各边总权值为负)
为什么是n-1呢?我们可以确定的是,在一次对所有边进行松弛操作以后,我们至少可以确定一个定点的距离源点的最短路径(最坏可以考虑一条直线,中间有若干点,这种情况一次松弛只能确定一个点距离源点的最短路径。当一个点的连接的点个数超过一时,我们每次松弛确定得点个数大于1,最坏情况就是n-1次松弛确定所有点的最短路径)
那么,算法就很简单了,只有下面几行:
Bellman的算法,存在一个问题就是每次都对所有的边进行进行松弛,会浪费一些时间复杂度。比如当我们还没有更新某个次序比较靠后的节点的时候,却会在第二个循环中,考虑用该节点去松弛其余节点。
比较好的改进措施是,我们使用一个队列,每次把刚刚进行松弛操作的节点加入队列中,每次从队列中取出节点去更新其他的节点这就是SPFA算法
void spfa()
{
queue<int> myqueue;
while(!myqueue.empty())
{
myqueue.pop();
}
myqueue.push(0);
while(!myqueue.empty())
{
int v = myqueue.front();
visited[v] = 0;
myqueue.pop();
for(int i = 0 ; i<n;i++)
{
if(dis[i]>dis[v]+arr[v][i])
{
dis[i] = dis[v] + arr[v][i];
if(visited[i]!=1)
{
visited[i] = 1;
myqueue.push(i);
}
}
}
}
}使用上述spfa函数替代bellman函数即可
Floyd算法:计算图中每个顶点到其余所有顶点的最短路
这个算法时间复杂度为n^3。对于任意节点i,j遍历所有k,找到这样的k,使得以k为中转站的时候,i,j之间的最短路最短
一共三个for循环,算法很好记;前两个for循环用于遍历i,j后面一个for循环用于找到中转站k
核心代码:
算法实现:
文章中有的地方使用的是有向图表达,有的是无向图表达。望注意
P.S.文章不妥之处还望指正
三种算法主要用途:
1. 边上权值非负情形的单源最短路径问题 — Dijkstra算法
2. 边上权值为任意值的单源最短路径问题 — Bellman和Ford算法
3. 所有顶点之间的最短路径 — Floyd算法
Dijkstra算法:贪心策略
算法思想:设G=(V,E)是一个带权有向图,把图中顶点集合V分成两组,已求出最短路径的顶点集合S和其余未确定最短路径的顶点集合V-S,按最短路径长度的递增次序依次把V-S的顶点加入S中。选择V-S中距离远点路径最短的点v',以v'为中转点更新所有的点的最短路径
起始设置所有点距离源点v的最短路径。如果v'与v相连,那么最短路径就是<v,v'>的长度,否则就是无穷大
#include <iostream> using namespace std; const int MAX =99999999; unsigned int n,e; int arr[100][100]; int visited[100] = {0}; int dis[100]; void Dijkstra() { for(int i = 1; i<n; i++) { int temp = MAX; int newVec = 0; for(int j = 1; j<n; j++) { if(visited[j]==0&&dis[j]<temp) { newVec = j; temp = dis[j]; } } visited[newVec] = 1; for(int j = 1; j<n; j++) { if(visited[j] == 0&&arr[newVec][j]<MAX) { if(dis[j]>dis[newVec]+ arr[newVec][j]) { dis[j] = dis[newVec]+ arr[newVec][j]; } } } } } int main() { cin>>n>>e; if(n>0&&e>0) { for(int i=0; i<100; i++) { for(int j=0; j<100; j++) { if(i!=j) arr[i][j] = MAX; else arr[i][j] = 0; } } for(int i=0; i<e; i++) { int from,to,dis; cin>>from>>to>>dis; arr[from][to] = dis; //arr[to][from] = dis; } /*for(int i=0; i<n; i++) { for(int j=0; j<n; j++) { cout<<arr[i][j]<<" "; } cout<<endl<<endl; }*/ for(int i = 0; i<n; i++) { dis[i] = arr[0][i]; } /*for(int i = 0; i<n; i++) { cout<<distance[i]<<" "; }*/ cout<<"Dijkstra 最短路:"<<endl; visited[0] = 1; Dijkstra(); for(int i = 0; i<n; i++) { cout<<dis[i]<<" "; } } return 0; } /* 5 7 0 1 10 0 3 30 0 4 100 1 2 50 2 4 10 3 2 20 3 4 60 */
Bellman-Ford算法:持续松弛操作
什么叫松弛操作呢?在松弛一条边(u,v)的过程中,要测试是否可以通过u,对迄今找到的v的最短路径进行改进;如果可以改进的话,则更新d[v]。
bellman-ford算法是对图进行n-1次松弛操作,如果n-1次松弛操作以后还能继续进行松弛操作,那么说明原图中有负环(即圈的各边总权值为负)
为什么是n-1呢?我们可以确定的是,在一次对所有边进行松弛操作以后,我们至少可以确定一个定点的距离源点的最短路径(最坏可以考虑一条直线,中间有若干点,这种情况一次松弛只能确定一个点距离源点的最短路径。当一个点的连接的点个数超过一时,我们每次松弛确定得点个数大于1,最坏情况就是n-1次松弛确定所有点的最短路径)
那么,算法就很简单了,只有下面几行:
for(int i = 0;i<n-1;i++) { for(int j = 0;j<e;j++) { if(distance[edge[j].to]>distance[edge[j].from]+edge[j].val) { distance[edge[j].to] = distance[edge[j].from]+edge[j].val; } } }完整代码如下:
#include <iostream> #include <stdlib.h> using namespace std; const int MAX =99999999; typedef struct Edge{ int from,to; int val; }Edge; Edge edge[1000]; unsigned int n,e; int dis[100]; bool Bellman() { for(int i = 0;i<n-1;i++) { for(int j = 0;j<e;j++) { if(dis[edge[j].to]>dis[edge[j].from]+edge[j].val) { dis[edge[j].to] = dis[edge[j].from]+edge[j].val; } } } bool flag = true; for(int k = 0 ; k < e;k++) { if(dis[edge[k].to]>dis[edge[k].from]+edge[k].val) { flag = false; break; } } return flag; } int main() { cin>>n>>e; if(n>0&&e>0) { for(int i = 1;i<n;i++) { dis[i] = MAX; } dis[0] = 0; for(int i=0; i<e; i++) { int from,to,dis; cin>>from>>to>>dis; edge[i].from = from; edge[i].to = to; edge[i].val = dis; //arr[to][from] = dis; } for(int i = 0; i<e; i++) { if(edge[i].from == 0) { dis[edge[i].to] = edge[i].val; } } for(int i = 0; i<n; i++) { cout<<dis[i]<<" "; } cout<<"Bellman-Ford最短路:"<<endl; bool flag = Bellman(); if(flag) { for(int i = 0; i<n; i++) { cout<<dis[i]<<" "; } } else { cout<<"存在负环"<<endl; } } return 0; } /* 5 7 0 1 10 0 3 30 0 4 100 1 2 50 2 4 10 3 2 20 3 4 60 5 7 0 1 10 0 4 100 1 2 50 2 3 -2 3 0 -1 3 4 -6 4 2 -1 */
Bellman的算法,存在一个问题就是每次都对所有的边进行进行松弛,会浪费一些时间复杂度。比如当我们还没有更新某个次序比较靠后的节点的时候,却会在第二个循环中,考虑用该节点去松弛其余节点。
比较好的改进措施是,我们使用一个队列,每次把刚刚进行松弛操作的节点加入队列中,每次从队列中取出节点去更新其他的节点这就是SPFA算法
void spfa()
{
queue<int> myqueue;
while(!myqueue.empty())
{
myqueue.pop();
}
myqueue.push(0);
while(!myqueue.empty())
{
int v = myqueue.front();
visited[v] = 0;
myqueue.pop();
for(int i = 0 ; i<n;i++)
{
if(dis[i]>dis[v]+arr[v][i])
{
dis[i] = dis[v] + arr[v][i];
if(visited[i]!=1)
{
visited[i] = 1;
myqueue.push(i);
}
}
}
}
}使用上述spfa函数替代bellman函数即可
Floyd算法:计算图中每个顶点到其余所有顶点的最短路
这个算法时间复杂度为n^3。对于任意节点i,j遍历所有k,找到这样的k,使得以k为中转站的时候,i,j之间的最短路最短
一共三个for循环,算法很好记;前两个for循环用于遍历i,j后面一个for循环用于找到中转站k
核心代码:
for(int k=0; k<n; k++) for(int i=0; i<n; i++) for(int j=0; j<n; j++) if(arr[i][k]<MAX && arr[k][j]<MAX && arr[i][j]>arr[i][k]+arr[k][j]) arr[i][j]=arr[i][k]+arr[k][j];
算法实现:
#include <iostream> using namespace std; const int MAX =99999999; unsigned int n,e; int arr[100][100]; void floyd() { for(int k=0; k<n; k++) for(int i=0; i<n; i++) for(int j=0; j<n; j++) if(arr[i][k]<MAX && arr[k][j]<MAX && arr[i][j]>arr[i][k]+arr[k][j]) arr[i][j]=arr[i][k]+arr[k][j]; } int main() { cin>>n>>e; if(n>0&&e>0) { for(int i=0; i<100; i++) { for(int j=0; j<100; j++) { if(i!=j) arr[i][j] = MAX; else arr[i][j] = 0; } } for(int i=0; i<e; i++) { int from,to,dis; cin>>from>>to>>dis; arr[from][to] = dis; arr[to][from] = dis; } floyd(); for(int i=0; i<n; i++) { for(int j=0; j<n; j++) { cout<<arr[i][j]<<" "; } cout<<endl; } return 0; } } /* 5 7 0 1 10 0 3 30 0 4 100 1 2 50 2 4 10 3 2 20 3 4 60 */
文章中有的地方使用的是有向图表达,有的是无向图表达。望注意
P.S.文章不妥之处还望指正
相关文章推荐
- 2544 最短路 Dijkstra算法 Floyd算法 Bellman_Ford算法 SPFA算法
- 最短路算法 :Bellman-ford算法 & Dijkstra算法 & floyd算法 & SPFA算法 详解
- 最短路算法 :Bellman-ford算法 & Dijkstra算法 & floyd算法 & SPFA算法 详解
- 单源最短路径算法--Dijkstra算法和Bellman-Ford算法
- Dijkstra算法、Bellman-Ford算法、Floyd算法
- 最短路径(Floyd算法和Dijkstra算法和Bellman-Ford算法)
- 最短路算法 :Bellman-ford算法 & Dijkstra算法 & floyd算法 & SPFA算法 详解
- 最短路算法(Floyd算法,Dijkstra算法,Bellman-Ford算法,SPFA算法)
- 紫书第十一章-----图论模型与算法(最短路径Dijkstra算法Bellman-Ford算法Floyd算法)
- 蓝桥杯 算法训练 最短路 (Bellman-Ford算法)
- 图论算法--单源最短路--dijkstra算法(优先队列优化)
- 算法-从动态规划到贪心算法,Bellman-Ford和Dijkstra算法求解最短路
- 最短路算法 :Bellman-ford算法 & Dijkstra算法 & floyd算法 & SPFA算法详解&BFS
- Dijkstra算法,Bellman-Ford算法和BFS算法解决有向图的单源最短路径问题
- 最短路径[Floyd算法,Dijkstra算法,Bellman-Ford(贝尔曼)]算法
- ⑨讲图论第五课: Bellman-Ford算法求最短路
- 数据结构:最短路径算法之Bellman-Ford算法
- ⑨讲图论第五课: Bellman-Ford算法求最短路
- 算法——单源最短路径:Bellman-Ford算法、Dijkstra算法
- POJ - 2240 Arbitrage (最短路 Floyd算法 && Bellman-Ford算法)