`

【最短路+spfa+有难度】杭电 hdu 2377 Bus Pass

阅读更多

 

/* 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 ;
}
 
0
0
分享到:
评论

相关推荐

    最短路课件(链式前向星+堆优化+SPFA)

    最短路算法进阶(链式前向星+堆优化+SPFA) 本文主要介绍了最短路算法的进阶知识,包括链式前向星、堆优化和SPFA算法的应用。 一、链式前向星 链式前向星是一种存图方式,用于存储有向图中的边信息。这种存图方式...

    前向星+SPFA(很强大,非常强大)

    前向星+SPFA算法详解 本文将详细介绍前向星+SPFA算法的原理、实现和应用,包括SPFA算法的基本概念、前向星的实现细节和SPFA算法在实际问题中的应用。 SPFA算法 SPFA(Shortest Path Faster Algorithm)是一种计算...

    最短路SPFA

    ### 最短路径算法SPFA详解 SPFA(Shortest Path Faster Algorithm)是一种基于Bellman-Ford算法改进的求解单源最短路径问题的算法,它利用队列来加速搜索过程,尤其适用于含有大量负权边但不存在负权回路的情况。在...

    蓝桥杯CJ2-11-图论最短路径问题 Bellman-Ford算法+SPFA.pdf

    在最坏情况下,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,匈牙利算法,朱刘算法等),

    各种算法资料介绍和代码事例(包括2-Sat,A*,SPFA,BFS,DFS,DBFS,Dancing Links,BM,Dijkstra,Dinic,Floyd,Gabow,KMP,Prim,MD5,SAP,RMQ,Tarjan,ST,匈牙利算法,朱刘算法等),还有很多算法,不一一列出,列出这么多,是想...

    队列优化的Bellmanford最短路算法(SPFA)C++实现

    队列优化的Bellman-Ford最短路算法(SPFA,Shortest Path Faster Algorithm)是一种在图论中用于寻找有向图中单源最短路径的算法,它是在经典Bellman-Ford算法基础上进行优化得到的。Bellman-Ford算法本身能够处理...

    c++ SPFA算法

    C++ SPFA算法 SPFA(Shortest Path Faster Algorithm)是一种求解单源最短路径问题的算法,它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径,并且可以处理负边。该算法的基本思想是使用一个队列来维护...

    SPFA.cpp SPFA算法

    最短路SPFA算法。SPFA(Shortest Path Faster Algorithm)算法是求单源最短路径的一种算法,它是Bellman-ford的队列优化,它是一种十分高效的最短路算法。存在负权边时使用。

    图论,ACM SPFA 和Bellman_ford.ppt 最短路算法

    总结来说,SPFA算法是求解带负权边图的最短路径的一种高效方法,虽然在最坏情况下可能不如Bellman-Ford算法稳定,但通常在实践中表现出更好的性能。理解这两种算法的原理和实现细节对于解决图论问题和参加编程竞赛都...

    最短路的Floyd-Dijkstra-Spfa板子

    做ACM最短路问题普遍算法的Floyd-Dijkstra-Spfa板子..

    最短路问题

    该PPT讲了求最短路算法SPFA,Bellman-Ford和Floyed-Warshall算法,还拓展了差分约束。十分适合初学者用

    SPFA算法优化及应用

    SPFA(Shortest Path Faster Algorithm)是一种高效的单源最短路算法,广泛应用于图论和动态规划等领域。下面是对SPFA算法的详细介绍和优化。 基本实现 SPFA算法的基本思想是通过relax操作来更新节点的距离值。...

    ACM-图论-模板资源

    可供直接使用,包括:KM算法、K短路、SPFA、强连通分量、最小生成树、最大最小流、割点和桥、哈密顿回路等等。 包含了图论相关的C++代码模板文件 可供直接使用,包括:KM算法、K短路、SPFA、强连通分量、最小生成树...

    最短路模板(详细注解)

    本篇将详细探讨三种解决最短路问题的经典算法:贝尔曼-福特算法(Bellman-Ford)、迪杰斯特拉算法(Dijkstra's Algorithm)以及SPFA(Shortest Path Faster Algorithm)。这些算法广泛应用于路由选择、网络优化和...

    SPFA.rar_SPFA

    在提供的"最短路之SPFA算法.mht"文件中,很可能包含了关于SPFA算法的具体实现、例子以及分析。这个文件可能包含了用编程语言(如C++、Python等)实现的SPFA算法代码,以及通过实例来解释如何运用该算法求解最短路径...

    最短路全家桶(Floyd,Dijkstra,SPFA)

    相比于Bellman-Ford算法,SPFA在实践中通常更快,但其最坏情况下的时间复杂度仍为O(n^2)。SPFA对于稀疏图,即边的数量远小于节点数量的情况,表现良好。 链式前向星存图是一种常用的图存储结构,它使用邻接表而非...

    C++队列优化的Bellmanford最短路算法(SPFA)

    摘要:VC/C++源码,算法相关,队列优化,最短路径算法 C++队列优化的Bellmanford最短路算法(SPFA),使用C++实现的Queue improved Bellman-Ford单源最短路算法,在国内还被叫做SPFA。这个程序输入一个图,找到图中的一...

    最短路径 之 SPFA算法

    SPFA最短路径算法 SPFA(Shortest Path Faster Algorithm)是一种单源最短路径算法,它的性能非常好,代码实现也并不复杂。特别是当图的规模大,用邻接矩阵存不下的时候,用 SPFA 则可以很方便地面对临接表。每个...

    SPFA算法.ppt

    基本思想 用一个队列来进行维护。初始时将源加入队列。每次从队列中取出一个元素,并对所有与他相邻的点进行松弛,若某个相邻的点松弛成功,则将其入队。...d[i]:起点s到i的临时最短路长度 松驰的结果是使j的d值减小

    SPFA带负权的最短路径算法

    SPFA 算法是 Bellman-Ford算法 的队列优化算法的别称,通常用于求含负权边的单源最短路径,以及判负权环。SPFA 最坏情况下复杂度和朴素 Bellman-Ford 相同,为 O(VE)。

Global site tag (gtag.js) - Google Analytics