[hihoCoder] #1093 : 最短路径·三:SPFA算法
描述
万圣节的晚上,小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为了走出鬼屋至少要走的路程。
- 样例输入
-
- 5 10 3 5
- 1 2 997
- 2 3 505
- 3 4 118
- 4 5 54
- 3 5 480
- 3 4 796
- 5 2 794
- 2 5 146
- 5 4 604
- 2 5 63
- 5 10 3 5
- 样例输出
-
- 172
- #include <iostream>
- #include <vector>
- #include <queue>
- #include <algorithm>
- #include <climits>
- using namespace std;
- const int INF = 1e9;
- struct node {
- int idx;
- int len;
- node(int _idx = , int _len = ) : idx(_idx), len(_len){}
- };
- int N, M, S, T;
- vector<vector<node>> graph;
- vector<int> dist;
- void solve() {
- vector<int> visit(N+, false);
- //priority_queue<int, vector<int>, greater<int>> heap;
- queue<int> heap;
- dist[S] = ;
- heap.push(S);
- visit[S] = true;
- while (!heap.empty()) {
- //int u = heap.top();
- int u = heap.front();
- heap.pop();
- visit[u] = false;
- for (int i = ; i < graph[u].size(); ++i) {
- int v = graph[u][i].idx;
- if (dist[v] > dist[u] + graph[u][i].len) {
- dist[v] = dist[u] + graph[u][i].len;
- if (!visit[v]) {
- heap.push(v);
- visit[v] = true;
- }
- }
- }
- }
- cout << dist[T] << endl;
- }
- int main() {
- while (cin >> N >> M >> S >> T) {
- graph.assign(N+, vector<node>());
- dist.assign(N+, INF);
- int u, v, len;
- for (int i = ; i <= M; ++i) {
- cin >> u >> v >> len;
- graph[u].push_back(node(v, len));
- graph[v].push_back(node(u, len));
- }
- solve();
- }
- return ;
- }
堆优化的Dijkstra算法。总体来说还是SPFA算法更好写一点。不过Dijsktra算法可以提前输出,只到轮到点T,直接输出即可。
- #include <iostream>
- #include <vector>
- #include <queue>
- #include <algorithm>
- using namespace std;
- const int INF = 1e9;
- struct edge {
- int idx;
- int dist;
- edge(int _idx, int _dist) : idx(_idx), dist(_dist) {}
- };
- struct cmp {
- bool operator () (const edge &a, const edge &b) { return a.dist > b.dist; }
- };
- int N, M, S, T;
- vector<vector<edge>> graph;
- void solve() {
- priority_queue<edge, vector<edge>, cmp> heap;
- vector<int> dist(N + , INF);
- vector<bool> visit(N + , false);
- dist[S] = ;
- visit[S] = true;
- for (int i = ; i < graph[S].size(); ++i) {
- auto v = graph[S][i];
- dist[v.idx] = min(dist[v.idx], v.dist);
- heap.push(edge(v.idx, dist[v.idx]));
- }
- while (!heap.empty()) {
- auto u = heap.top();
- heap.pop();
- if (u.idx == T) {
- cout << u.dist << endl;
- return;
- }
- if (visit[u.idx]) continue;
- visit[u.idx] = true;
- for (int i = ; i < graph[u.idx].size(); ++i) {
- auto v = graph[u.idx][i];
- if (!visit[v.idx] && dist[v.idx] > dist[u.idx] + v.dist) {
- dist[v.idx] = dist[u.idx] + v.dist;
- heap.push(edge(v.idx, dist[v.idx]));
- }
- }
- }
- cout << "-1" << endl;
- }
- int main() {
- while (cin >> N >> M >> S >> T) {
- int u, v, len;
- graph.resize(N + );
- for (int i = ; i < M; ++i) {
- cin >> u >> v >> len;
- graph[u].push_back(edge(v, len));
- graph[v].push_back(edge(u, len));
- }
- solve();
- }
- return ;
- }
[hihoCoder] #1093 : 最短路径·三:SPFA算法的更多相关文章
- 【最短路径】 SPFA算法
上一期介绍到了SPFA算法,只是一笔带过,这一期让我们详细的介绍一下SPFA. 1 SPFA原理介绍 SPFA算法和dijkstra算法特别像,总感觉自己讲的不行,同学说我的博客很辣鸡,推荐一个视频讲 ...
- 【最短路径】 SPFA算法优化
首先先明确一个问题,SPFA是什么?(不会看什么看,一边学去,传送门),SPFA是bellman-ford的队列优化版本,只有在国内才流行SPFA这个名字,大多数人就只知道SPFA就是一个顶尖的高效算 ...
- 【最短路径】 常用算法图解+1376:信使(msner)六解
进入图之后,最短路径可谓就是一大重点,最短路径的求法有很多种,每种算法各有各的好处,你会几种呢?下面来逐个讲解. 1 floyed算法 1)明确思想及功效:在图中求最短路还是要分开说的,分别是单源最短 ...
- hihocoder 1093 SPFA算法
题目链接:http://hihocoder.com/problemset/problem/1093 , 最短路的SPFA算法. 由于点的限制(10w),只能用邻接表.今天也学了一种邻接表的写法,感觉挺 ...
- 最短路径--SPFA 算法
适用范围:给定的图存在负权边,这时类似Dijkstra等算法便没有了用武之地,而Bellman-Ford算法的复杂度又过高,SPFA算法便派上用场了. 我们约定有向加权图G不存在负权回路,即最短路径一 ...
- Bellman-Ford & SPFA 算法——求解单源点最短路径问题
Bellman-Ford算法与另一个非常著名的Dijkstra算法一样,用于求解单源点最短路径问题.Bellman-ford算法除了可求解边权均非负的问题外,还可以解决存在负权边的问题(意义是什么,好 ...
- 最短路径——SPFA算法
一.前提引入 我们学过了Bellman-Ford算法,现在又要提出这个SPFA算法,为什么呢? 考虑一个随机图(点和边随机生成),除了已确定最短路的顶点与尚未确定最短路的顶点之间的边,其它的边所做的都 ...
- 图的最短路径-----------SPFA算法详解(TjuOj2831_Wormholes)
这次整理了一下SPFA算法,首先相比Dijkstra算法,SPFA可以处理带有负权变的图.(个人认为原因是SPFA在进行松弛操作时可以对某一条边重复进行松弛,如果存在负权边,在多次松弛某边时可以更新该 ...
- 最短路径——Bellman-Ford算法以及SPFA算法
说完dijkstra算法,有提到过朴素dij算法无法处理负权边的情况,这里就需要用到Bellman-Ford算法,抛弃贪心的想法,牺牲时间的基础上,换取负权有向图的处理正确. 单源最短路径 Bellm ...
随机推荐
- Intent跳转到系统应用中的拨号界面、联系人界面、短信界面及其他
现在开发中的功能需要直接跳转到拨号.联系人.短信界面等等,查找了很多资料,自己整理了一下. 首先,我们先看拨号界面,代码如下: Intent intent =new Intent(); intent. ...
- Linux获得命令帮助(学习笔记五)
一.获得命令帮助 1.1.内部命令与外部命令 简单来说,在linux系统中有存储位置的命令为外部命令: 没有存储位置的为内部命令,可以理解为内部命令嵌入在linux的shell中,所以看不到. typ ...
- spring boot 1.5.2 操作mongodb3.4.0
1:build.gradle 添加mongodb依赖 dependencies { compile('org.springframework.boot:spring-boot-starter-web' ...
- 每日一句英语:怎样回答美国人的How is it going问候语?
和中国人"吃了吗"是一个性质,本质上仅仅是个话题的起始点,而不是真的想知道你吃了没有. 美国人打招呼有几种方式: 不太熟的人:How are you? 一 般说 pretty go ...
- 基于vue 的 UI框架 -- Mint UI
网址: http://mint-ui.github.io/docs/#!/zh-cn 官网: http://mint-ui.github.io/#!/zh-cn vue2.0实例: http://bl ...
- bg和fg命令
linux提供的fg和bg命令,可以让我们轻松调度正在运行的任务 假如你发现前天运行的一个程序需要很长的时间,但是需要干前天的事情,你就可以用ctrl-z挂起这个程序,然后可以看到系统的提示: [ ...
- poj 4014 Dice 贪心
//poj 4014 //sep9 #include <iostream> #include <algorithm> using namespace std; int n; s ...
- 〖Linux〗apt-get wait for another apt process
#!/bin/bash i= tput sc >& || \ >&; do )) in ) j="-" ;; ) j="\\" ;; ...
- Q2:Reverse Words in a String
Clarification: What constitutes a word? A sequence of non-space characters constitutes a word. Could ...
- 理解并使用.NET 4.5中的HttpClient(转)
原文地址:http://www.cnblogs.com/wywnet/p/httpclient.html HttpClient介绍HttpClient是.NET4.5引入的一个HTTP客户端库,其命名 ...