最短路径快速spfa

  1. #include <stdio.h>
  2. #include <queue>
  3. #include <iostream>
  4. using namespace std;
  5. #define INF 0xfffff //因为为了辨别是否有负权,所以INF不能开太大
  6. #define MAX 1100
  7. int dist[MAX], pre[MAX], path[MAX][MAX];
  8. bool sign[MAX];
  9. void initialize(int n) //初始化
  10. {
  11. for(int i=1; i<=n; i++)
  12. {
  13. {
  14. //pre[i] = 0;
  15. dist[i] = INF; //将距离开始全变为最大
  16. sign[i] = false;
  17. }
  18. for(int j=1; j<=n; j++)
  19. path[i][j] = INF; //图初始
  20. }
  21. }
  22. void spfa(int n, int start) //无法计算负权
  23. {
  24. /* for (int i=1; i<=n; ++i) //初始化
  25. {
  26. dist[i] = INF;
  27. sign[i] = false;
  28. }*/
  29. queue<int> Q;
  30. dist[start] = 0;
  31. sign[start] = true;
  32. Q.push(start);
  33. while (!Q.empty()){
  34. int temp = Q.front();
  35. Q.pop();
  36. for (int i=0; i<=n; ++i)
  37. {
  38. if (dist[temp] + path[temp][i] < dist[i])//存在负权的话,就需要创建一个COUNT数组,当某点的入队次数超过V(顶点数)返回。
  39. {
  40. dist[i] = dist[temp] + path[temp][i];
  41. if (!sign[i])
  42. {
  43. Q.push(i);
  44. sign[i] = true;
  45. }
  46. //这个内循环可以判断所要权值相对应条件的值如dist[start];
  47. }
  48. }
  49. sign[temp] = false;
  50. }
  51. }
  52. void input(int line)
  53. {
  54. int a, b, weight;
  55. for(int i=0; i<line; i++)
  56. {
  57. scanf("%d%d%d", &a, &b, &weight);
  58. if(path[a][b] > weight) //有多条路,保存最短的那条
  59. {
  60. path[a][b] = weight;
  61. path[b][a] = weight; //无向图双向
  62. }
  63. }
  64. }
  65. int main()
  66. {
  67. int n, line;
  68. scanf("%d%d", &n, &line);
  69. initialize(n);
  70. input(line);
  71. spfa(n, 1);
  72. printf("%d\n\n", dist[n]);
  73. return 0;
  74. }

来自为知笔记(Wiz)

附件列表

时间: 2024-10-31 11:40:42

最短路径快速spfa的相关文章

hdoj-1869 六度分离【最短路径--dijkstra&amp;&amp;spfa&amp;&amp;floyd】

题目:http://acm.hdu.edu.cn/showproblem.php?pid=1869 解题思路: 转化成最短路径问题,如果两人认识,把两者之间距离看成1      如果任意两人之间隔着7个人及其以上 (即距离>7)   则不满足六度分离 spfa: #include<cstdio> #include<cstring> #include<queue> #define INF 0x3f3f3f3f #define MAXN 100+10//点数 #def

[图论] 最短路径(Bellman-Ford , SPFA , Floyed , Dijkstra)

注:模板以hdu 2544 为例 Problem Description 在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的t-shirt.但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的!所以现在他们想要寻找最短的从商店到赛场的路线,你可以帮助他们吗? Input 输入包括多组数据.每组数据第一行是两个整数N.M(N<=100,M<=10000),N表示成都的大街上有几个路口,标号为1的路口是商店所在地,标号为N的路口是赛场所在地,M则表示在成都有几条路.N=M=

hdu3790 最短路径问题(spfa)

最短路径问题 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 33536    Accepted Submission(s): 9835 Problem Description 给你n个点,m条无向边,每条边都有长度d和花费p,给你起点s终点t,要求输出起点到终点的最短距离及其花费,如果最短距离有多条路线,则输出花费最少的. Input

最短路径 Floyd &amp;&amp; spfa

floyd算法是一个很强大的算法,它可以计算任意两点之间的最短路径,其边可以为负值.时间复杂度n^3 1 void floyd() 2 { 3 int k,u,v; 4 for(k=0;k<G.vunm;k++) 5 for(u=0;u<G.vunm;u++) 6 for(v=0;v<G.vunm;v++) 7 { 8 if(D[u][v]>D[u][k]+D[k][v]) 9 { 10 D[u][v]=D[u][k]+D[k][v]; 11 } 12 } 13 printf(&q

HDU ACM 3790最短路径问题(SPFA算法实现)

分析:同时计算最短距离和花费,距离相同时还要更新费用,还要同时存储正向边和反向边. 注意:不能用cin和cout,否则会超时. #include<iostream> #include<queue> using namespace std; int u[200002]; int v[200002]; int w[200002]; int p[200002]; bool vis[1001]; int d[1001]; int cost[1001]; int first[1001]; i

单源最短路径,spfa

SPFA又是一个好东西,看代码吧qwq #include <cstdio> #include <cstring> #include <queue> #include <algorithm> #include <iostream> using namespace std; const int oo=2147483647; const int Maxn=500001; queue<int> q; int head[Maxn*2],nxt[

最短路径:我的理解--SPFA算法

最短路径:我的理解--SPFA算法 SPFA算法 求单源最短路的SPFA算法的全称是:Shortest Path Faster Algorithm. 最短路径快速算法-SPFA算法是西南交通大学段凡丁于1994年发表的. 适用范围:给定的图存在负权边,这时类似Dijkstra等算法便没有了用武之地,而Bellman-Ford算法的复杂度又过高,SPFA算法便派上用场了. 我们约定有向加权图G不存在负权回路,即最短路径一定存在.当然,我们可以在执行该算法前做一次拓扑排序,以判断是否存在负权回路,但

The Postal Worker Rings Once(UVA 117)最短路径—SPFA算法+邻接表

The Postal Worker Rings Once From:UVA, 117 Time Limit: 3000 MS Background Graph algorithms form a very important part of computer science and have a lineage that goes back at least to Euler and the famous Seven Bridges of K?nigsberg problem. Many opt

SPFA最短路算法

SPFA:Shortest Path Faster Algoriithm 快速最短路径算法 SPFA的核心算法就是Bell-Ford算法.它使用一个队列或者一个栈来减少了Bell-Ford中不必要的松弛.可以处理负边和环的情况,他的使用比Dijstra更广泛.但是未经优化的SPFA算法时间复杂度不稳定,测试用例对它的影响较大.所以有的时候为了简单方便,我们直接使用Dijstra算法来解决. SPFA实现的过程非常类似于BFS.他们都是使用队列来维护,不同的是,BFS的每个顶点只入队一次,而SPF