时间限制:10000ms
单点时限:1000ms
内存限制:256MB

描述

万圣节的晚上,小Hi和小Ho在吃过晚饭之后,来到了一个巨大的鬼屋!

鬼屋中一共有N个地点,分别编号为1..N,这N个地点之间互相有一些道路连通,两个地点之间可能有多条道路连通,但是并不存在一条两端都是同一个地点的道路。

不过这个鬼屋虽然很大,但是其中的道路并不算多,所以小Hi还是希望能够知道从入口到出口的最短距离是多少?

提示:Super Programming Festival Algorithm。

输入

每个测试点(输入文件)有且仅有一组测试数据。

在一组测试数据中:

第1行为4个整数N、M、S、T,分别表示鬼屋中地点的个数和道路的条数,入口(也是一个地点)的编号,出口(同样也是一个地点)的编号。

接下来的M行,每行描述一条道路:其中的第i行为三个整数u_i, v_i, length_i,表明在编号为u_i的地点和编号为v_i的地点之间有一条长度为length_i的道路。

对于100%的数据,满足N<=10^5,M<=10^6, 1 <= length_i <= 10^3, 1 <= S, T <= N, 且S不等于T。

对于100%的数据,满足小Hi和小Ho总是有办法从入口通过地图上标注出来的道路到达出口。

输出

对于每组测试数据,输出一个整数Ans,表示那么小Hi和小Ho为了走出鬼屋至少要走的路程。

样例输入
  1. 5 10 3 5
  2. 1 2 997
  3. 2 3 505
  4. 3 4 118
  5. 4 5 54
  6. 3 5 480
  7. 3 4 796
  8. 5 2 794
  9. 2 5 146
  10. 5 4 604
  11. 2 5 63
样例输出
  1. 172
  1. #include <iostream>
  2. #include <vector>
  3. #include <queue>
  4. #include <algorithm>
  5. #include <climits>
  6. using namespace std;
  7.  
  8. const int INF = 1e9;
  9.  
  10. struct node {
  11. int idx;
  12. int len;
  13. node(int _idx = , int _len = ) : idx(_idx), len(_len){}
  14. };
  15.  
  16. int N, M, S, T;
  17. vector<vector<node>> graph;
  18. vector<int> dist;
  19.  
  20. void solve() {
  21. vector<int> visit(N+, false);
  22. //priority_queue<int, vector<int>, greater<int>> heap;
  23. queue<int> heap;
  24. dist[S] = ;
  25. heap.push(S);
  26. visit[S] = true;
  27. while (!heap.empty()) {
  28. //int u = heap.top();
  29. int u = heap.front();
  30. heap.pop();
  31. visit[u] = false;
  32. for (int i = ; i < graph[u].size(); ++i) {
  33. int v = graph[u][i].idx;
  34. if (dist[v] > dist[u] + graph[u][i].len) {
  35. dist[v] = dist[u] + graph[u][i].len;
  36. if (!visit[v]) {
  37. heap.push(v);
  38. visit[v] = true;
  39. }
  40. }
  41. }
  42. }
  43. cout << dist[T] << endl;
  44. }
  45.  
  46. int main() {
  47. while (cin >> N >> M >> S >> T) {
  48. graph.assign(N+, vector<node>());
  49. dist.assign(N+, INF);
  50. int u, v, len;
  51. for (int i = ; i <= M; ++i) {
  52. cin >> u >> v >> len;
  53. graph[u].push_back(node(v, len));
  54. graph[v].push_back(node(u, len));
  55. }
  56. solve();
  57. }
  58. return ;
  59. }

堆优化的Dijkstra算法。总体来说还是SPFA算法更好写一点。不过Dijsktra算法可以提前输出,只到轮到点T,直接输出即可。

  1. #include <iostream>
  2. #include <vector>
  3. #include <queue>
  4. #include <algorithm>
  5. using namespace std;
  6.  
  7. const int INF = 1e9;
  8.  
  9. struct edge {
  10. int idx;
  11. int dist;
  12. edge(int _idx, int _dist) : idx(_idx), dist(_dist) {}
  13. };
  14.  
  15. struct cmp {
  16. bool operator () (const edge &a, const edge &b) { return a.dist > b.dist; }
  17. };
  18.  
  19. int N, M, S, T;
  20. vector<vector<edge>> graph;
  21.  
  22. void solve() {
  23. priority_queue<edge, vector<edge>, cmp> heap;
  24. vector<int> dist(N + , INF);
  25. vector<bool> visit(N + , false);
  26. dist[S] = ;
  27. visit[S] = true;
  28. for (int i = ; i < graph[S].size(); ++i) {
  29. auto v = graph[S][i];
  30. dist[v.idx] = min(dist[v.idx], v.dist);
  31. heap.push(edge(v.idx, dist[v.idx]));
  32. }
  33. while (!heap.empty()) {
  34. auto u = heap.top();
  35. heap.pop();
  36. if (u.idx == T) {
  37. cout << u.dist << endl;
  38. return;
  39. }
  40. if (visit[u.idx]) continue;
  41. visit[u.idx] = true;
  42. for (int i = ; i < graph[u.idx].size(); ++i) {
  43. auto v = graph[u.idx][i];
  44. if (!visit[v.idx] && dist[v.idx] > dist[u.idx] + v.dist) {
  45. dist[v.idx] = dist[u.idx] + v.dist;
  46. heap.push(edge(v.idx, dist[v.idx]));
  47. }
  48. }
  49. }
  50. cout << "-1" << endl;
  51. }
  52.  
  53. int main() {
  54. while (cin >> N >> M >> S >> T) {
  55. int u, v, len;
  56. graph.resize(N + );
  57. for (int i = ; i < M; ++i) {
  58. cin >> u >> v >> len;
  59. graph[u].push_back(edge(v, len));
  60. graph[v].push_back(edge(u, len));
  61. }
  62. solve();
  63. }
  64. return ;
  65. }

[hihoCoder] #1093 : 最短路径·三:SPFA算法的更多相关文章

  1. 【最短路径】 SPFA算法

    上一期介绍到了SPFA算法,只是一笔带过,这一期让我们详细的介绍一下SPFA. 1 SPFA原理介绍 SPFA算法和dijkstra算法特别像,总感觉自己讲的不行,同学说我的博客很辣鸡,推荐一个视频讲 ...

  2. 【最短路径】 SPFA算法优化

    首先先明确一个问题,SPFA是什么?(不会看什么看,一边学去,传送门),SPFA是bellman-ford的队列优化版本,只有在国内才流行SPFA这个名字,大多数人就只知道SPFA就是一个顶尖的高效算 ...

  3. 【最短路径】 常用算法图解+1376:信使(msner)六解

    进入图之后,最短路径可谓就是一大重点,最短路径的求法有很多种,每种算法各有各的好处,你会几种呢?下面来逐个讲解. 1 floyed算法 1)明确思想及功效:在图中求最短路还是要分开说的,分别是单源最短 ...

  4. hihocoder 1093 SPFA算法

    题目链接:http://hihocoder.com/problemset/problem/1093 , 最短路的SPFA算法. 由于点的限制(10w),只能用邻接表.今天也学了一种邻接表的写法,感觉挺 ...

  5. 最短路径--SPFA 算法

    适用范围:给定的图存在负权边,这时类似Dijkstra等算法便没有了用武之地,而Bellman-Ford算法的复杂度又过高,SPFA算法便派上用场了. 我们约定有向加权图G不存在负权回路,即最短路径一 ...

  6. Bellman-Ford & SPFA 算法——求解单源点最短路径问题

    Bellman-Ford算法与另一个非常著名的Dijkstra算法一样,用于求解单源点最短路径问题.Bellman-ford算法除了可求解边权均非负的问题外,还可以解决存在负权边的问题(意义是什么,好 ...

  7. 最短路径——SPFA算法

    一.前提引入 我们学过了Bellman-Ford算法,现在又要提出这个SPFA算法,为什么呢? 考虑一个随机图(点和边随机生成),除了已确定最短路的顶点与尚未确定最短路的顶点之间的边,其它的边所做的都 ...

  8. 图的最短路径-----------SPFA算法详解(TjuOj2831_Wormholes)

    这次整理了一下SPFA算法,首先相比Dijkstra算法,SPFA可以处理带有负权变的图.(个人认为原因是SPFA在进行松弛操作时可以对某一条边重复进行松弛,如果存在负权边,在多次松弛某边时可以更新该 ...

  9. 最短路径——Bellman-Ford算法以及SPFA算法

    说完dijkstra算法,有提到过朴素dij算法无法处理负权边的情况,这里就需要用到Bellman-Ford算法,抛弃贪心的想法,牺牲时间的基础上,换取负权有向图的处理正确. 单源最短路径 Bellm ...

随机推荐

  1. Intent跳转到系统应用中的拨号界面、联系人界面、短信界面及其他

    现在开发中的功能需要直接跳转到拨号.联系人.短信界面等等,查找了很多资料,自己整理了一下. 首先,我们先看拨号界面,代码如下: Intent intent =new Intent(); intent. ...

  2. Linux获得命令帮助(学习笔记五)

    一.获得命令帮助 1.1.内部命令与外部命令 简单来说,在linux系统中有存储位置的命令为外部命令: 没有存储位置的为内部命令,可以理解为内部命令嵌入在linux的shell中,所以看不到. typ ...

  3. spring boot 1.5.2 操作mongodb3.4.0

    1:build.gradle 添加mongodb依赖 dependencies { compile('org.springframework.boot:spring-boot-starter-web' ...

  4. 每日一句英语:怎样回答美国人的How is it going问候语?

    和中国人"吃了吗"是一个性质,本质上仅仅是个话题的起始点,而不是真的想知道你吃了没有. 美国人打招呼有几种方式: 不太熟的人:How are you? 一 般说 pretty go ...

  5. 基于vue 的 UI框架 -- Mint UI

    网址: http://mint-ui.github.io/docs/#!/zh-cn 官网: http://mint-ui.github.io/#!/zh-cn vue2.0实例: http://bl ...

  6. bg和fg命令

    linux提供的fg和bg命令,可以让我们轻松调度正在运行的任务   假如你发现前天运行的一个程序需要很长的时间,但是需要干前天的事情,你就可以用ctrl-z挂起这个程序,然后可以看到系统的提示: [ ...

  7. poj 4014 Dice 贪心

    //poj 4014 //sep9 #include <iostream> #include <algorithm> using namespace std; int n; s ...

  8. 〖Linux〗apt-get wait for another apt process

    #!/bin/bash i= tput sc >& || \ >&; do )) in ) j="-" ;; ) j="\\" ;; ...

  9. Q2:Reverse Words in a String

    Clarification: What constitutes a word? A sequence of non-space characters constitutes a word. Could ...

  10. 理解并使用.NET 4.5中的HttpClient(转)

    原文地址:http://www.cnblogs.com/wywnet/p/httpclient.html HttpClient介绍HttpClient是.NET4.5引入的一个HTTP客户端库,其命名 ...