/* THE PROGRAM IS MADE BY PYY */
/*----------------------------------------------------------------------------//
Copyright (c) 2011 panyanyany All rights reserved.
URL : http://acm.hdu.edu.cn/showproblem.php?pid=2377
Name : 2377 Bus Pass
Date : Tuesday, January 24, 2012
Time Stage : 2 hours
Result:
5290124 2012-01-24 15:02:29 Accepted 2377
375MS 2692K 2336 B
C++ pyy
5289711 2012-01-24 12:12:48 Wrong Answer 2377
375MS 2692K 2292 B
C++ pyy
5289706 2012-01-24 12:07:45 Wrong Answer 2377
390MS 2692K 2282 B
C++ pyy
Test Data :
Review :
话说这题确实是没有思路,只好参考了大牛的代码,原来可以这样做~
大牛题解:http://blog.csdn.net/popopopolo/article/details/6432852
//----------------------------------------------------------------------------*/
#include <cstdio>
#include <CSTRING>
#include <queue>
using namespace std ;
#define MEM(a, v) memset (a, v, sizeof (a)) // a for address, v for value
#define INF (-1)
#define MAXN 10000
struct EDGE {
int v, w, next ;
} ;
bool used[MAXN] ;
int nz, nr, edgeCnt ;
int first[MAXN], max_d[MAXN], dist[MAXN] ;
EDGE edge[20*MAXN] ;
void add (const int u, const int v, const int w)
{
edge[edgeCnt].v = v ;
edge[edgeCnt].w = w ;
edge[edgeCnt].next = first[u] ;
first[u] = edgeCnt++ ;
}
void spfa (const int beg)
{
int i, d, u, v ;
queue<int> q ;
MEM (dist, INF) ;
MEM (used, 0) ;
// 这里不加就WA,考验思维缜密度,搞程序的一定要细心啊!
// 真心不明白为什么要加这里,求解释!
if (max_d[beg] == INF)
max_d[beg] = 1 ;
dist[beg] = 1 ;
used[beg] = 1 ;
q.push (beg) ;
while (!q.empty ())
{
u = q.front () ;
q.pop () ;
used[u] = 0 ;
for (i = first[u] ; i != -1 ; i = edge[i].next)
{
d = dist[u] + edge[i].w ;
v = edge[i].v ;
if (dist[v] == INF || dist[v] > d)
{
dist[v] = d ;
if (max_d[v] == INF || max_d[v] < dist[v])
max_d[v] = dist[v] ;
if (!used[v])
{
q.push (v) ;
used[v] = 1 ;
}
}
}
}
}
int main ()
{
int i, j ;
int u, v, w ;
int tcase, mz, minV, id ;
while (scanf ("%d", &tcase) != EOF)
{
while (tcase--)
{
MEM (first, -1) ;
MEM (max_d, INF) ;
edgeCnt = 0 ;
scanf ("%d%d", &nz, &nr) ;
for (i = 0 ; i < nz ; ++i)
{
scanf ("%d%d", &u, &mz) ;
while (mz--)
{
scanf ("%d", &v) ;
add (v, u, 1) ;
add (u, v, 1) ;
}
}
while (nr--)
{
scanf ("%d", &v) ;
for (i = 0 ; i < v ; ++i)
{
scanf ("%d", &u) ;
spfa (u) ;
}
}
minV = INF ;
id = -1 ;
for (i = 0 ; i < MAXN ; ++i)
if (max_d[i] != INF)
{
if (minV == INF || minV > max_d[i])
{
minV = max_d[i] ;
id = i ;
}
}
printf ("%d %d\n", minV, id) ;
}
}
return 0 ;
}
分享到:
相关推荐
最短路算法进阶(链式前向星+堆优化+SPFA) 本文主要介绍了最短路算法的进阶知识,包括链式前向星、堆优化和SPFA算法的应用。 一、链式前向星 链式前向星是一种存图方式,用于存储有向图中的边信息。这种存图方式...
前向星+SPFA算法详解 本文将详细介绍前向星+SPFA算法的原理、实现和应用,包括SPFA算法的基本概念、前向星的实现细节和SPFA算法在实际问题中的应用。 SPFA算法 SPFA(Shortest Path Faster Algorithm)是一种计算...
### 最短路径算法SPFA详解 SPFA(Shortest Path Faster Algorithm)是一种基于Bellman-Ford算法改进的求解单源最短路径问题的算法,它利用队列来加速搜索过程,尤其适用于含有大量负权边但不存在负权回路的情况。在...
在最坏情况下,SPFA的时间复杂度为O(VE),但在实践中通常比Bellman-Ford算法快得多。对于没有负权重循环的图,其时间复杂度通常接近O(V+E)。 #### 4. 01背包问题 在上述文档中提到了01背包问题,虽然这与最短路径...
各种算法资料介绍和代码事例(包括2-Sat,A*,SPFA,BFS,DFS,DBFS,Dancing Links,BM,Dijkstra,Dinic,Floyd,Gabow,KMP,Prim,MD5,SAP,RMQ,Tarjan,ST,匈牙利算法,朱刘算法等),还有很多算法,不一一列出,列出这么多,是想...
队列优化的Bellman-Ford最短路算法(SPFA,Shortest Path Faster Algorithm)是一种在图论中用于寻找有向图中单源最短路径的算法,它是在经典Bellman-Ford算法基础上进行优化得到的。Bellman-Ford算法本身能够处理...
C++ SPFA算法 SPFA(Shortest Path Faster Algorithm)是一种求解单源最短路径问题的算法,它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径,并且可以处理负边。该算法的基本思想是使用一个队列来维护...
最短路SPFA算法。SPFA(Shortest Path Faster Algorithm)算法是求单源最短路径的一种算法,它是Bellman-ford的队列优化,它是一种十分高效的最短路算法。存在负权边时使用。
总结来说,SPFA算法是求解带负权边图的最短路径的一种高效方法,虽然在最坏情况下可能不如Bellman-Ford算法稳定,但通常在实践中表现出更好的性能。理解这两种算法的原理和实现细节对于解决图论问题和参加编程竞赛都...
做ACM最短路问题普遍算法的Floyd-Dijkstra-Spfa板子..
该PPT讲了求最短路算法SPFA,Bellman-Ford和Floyed-Warshall算法,还拓展了差分约束。十分适合初学者用
SPFA(Shortest Path Faster Algorithm)是一种高效的单源最短路算法,广泛应用于图论和动态规划等领域。下面是对SPFA算法的详细介绍和优化。 基本实现 SPFA算法的基本思想是通过relax操作来更新节点的距离值。...
可供直接使用,包括:KM算法、K短路、SPFA、强连通分量、最小生成树、最大最小流、割点和桥、哈密顿回路等等。 包含了图论相关的C++代码模板文件 可供直接使用,包括:KM算法、K短路、SPFA、强连通分量、最小生成树...
本篇将详细探讨三种解决最短路问题的经典算法:贝尔曼-福特算法(Bellman-Ford)、迪杰斯特拉算法(Dijkstra's Algorithm)以及SPFA(Shortest Path Faster Algorithm)。这些算法广泛应用于路由选择、网络优化和...
在提供的"最短路之SPFA算法.mht"文件中,很可能包含了关于SPFA算法的具体实现、例子以及分析。这个文件可能包含了用编程语言(如C++、Python等)实现的SPFA算法代码,以及通过实例来解释如何运用该算法求解最短路径...
相比于Bellman-Ford算法,SPFA在实践中通常更快,但其最坏情况下的时间复杂度仍为O(n^2)。SPFA对于稀疏图,即边的数量远小于节点数量的情况,表现良好。 链式前向星存图是一种常用的图存储结构,它使用邻接表而非...
摘要:VC/C++源码,算法相关,队列优化,最短路径算法 C++队列优化的Bellmanford最短路算法(SPFA),使用C++实现的Queue improved Bellman-Ford单源最短路算法,在国内还被叫做SPFA。这个程序输入一个图,找到图中的一...
SPFA最短路径算法 SPFA(Shortest Path Faster Algorithm)是一种单源最短路径算法,它的性能非常好,代码实现也并不复杂。特别是当图的规模大,用邻接矩阵存不下的时候,用 SPFA 则可以很方便地面对临接表。每个...
基本思想 用一个队列来进行维护。初始时将源加入队列。每次从队列中取出一个元素,并对所有与他相邻的点进行松弛,若某个相邻的点松弛成功,则将其入队。...d[i]:起点s到i的临时最短路长度 松驰的结果是使j的d值减小
SPFA 算法是 Bellman-Ford算法 的队列优化算法的别称,通常用于求含负权边的单源最短路径,以及判负权环。SPFA 最坏情况下复杂度和朴素 Bellman-Ford 相同,为 O(VE)。