洛谷P2738 [USACO4.1]篱笆回路Fence Loops（Floyed求最小环）

最新推荐文章于 2023-11-16 20:19:41 发布
最新推荐文章于 2023-11-16 20:19:41 发布
阅读量655 收藏
点赞数 2
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wzw1376124061/article/details/71272017
本文介绍了一个关于农夫布朗牧场篱笆分割的问题，并通过Floyd算法求解最小周长的区域。文章提供了完整的C++代码实现，展示了如何将篱笆的连接关系转化为节点之间的距离矩阵，最终利用Floyd算法找出所有可能的环形区域中周长最小的一个。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Floyd 多源最短路 && 传递闭包 && 最小环:http://blog.youkuaiyun.com/wzw1376124061/article/details/69870161

题目描述

农夫布朗的牧场上的篱笆已经失去控制了。它们分成了1~200英尺长的线段。只有在线段的端点处才能连接两个线段，有时给定的一个端点上会有两个以上的篱笆。结果篱笆形成了一张网分割了布朗的牧场。布朗想将牧场恢复原样，出于这个考虑，他首先得知道牧场上哪一块区域的周长最小。 布朗将他的每段篱笆从1到N进行了标号（N=线段的总数）。他知道每段篱笆有如下属性：

该段篱笆的长度

该段篱笆的一端所连接的另一段篱笆的标号

该段篱笆的另一端所连接的另一段篱笆的标号

幸运的是，没有篱笆连接它自身。对于一组有关篱笆如何分割牧场的数据，写一个程序来计算出所有分割出的区域中最小的周长。

例如，标号1~10的篱笆由下图的形式组成（下面的数字是篱笆的标号）：

           1
   +---------------+
   |\             /|
  2| \7          / |
   |  \         /  |
   +---+       /   |6
   | 8  \     /10  |
  3|     \9  /     |
   |      \ /      |
   +-------+-------+
       4       5

上图中周长最小的区域是由2，7，8号篱笆形成的。

输入输出格式

输入格式：

第1行: N (1 <= N <= 100)

第2行到第3*N+1行: 每三行为一组，共N组信息:

每组信息的第1行有4个整数: s, 这段篱笆的标号(1 <= s <= N); Ls, 这段篱笆的长度 (1 <= Ls <= 255); N1s (1 <= N1s <= 8) 与本段篱笆的一端 所相邻的篱笆的数量; N2s与本段篱笆的另一端所相邻的篱笆的数量。 (1 <= N2s <= 8).

每组信息的的第2行有 N1s个整数, 分别描述与本段篱笆的一端所相邻的篱笆的标号。

每组信息的的第3行有N2s个整数, 分别描述与本段篱笆的另一端所相邻的篱笆的标号。

输出格式：

输出的内容为单独的一行，用一个整数来表示最小的周长。

输入输出样例

输入样例#1： 
10
1 16 2 2
2 7
10 6
2 3 2 2
1 7
8 3
3 3 2 1
8 2
4
4 8 1 3
3
9 10 5
5 8 3 1
9 10 4
6
6 6 1 2 
5 
1 10
7 5 2 2 
1 2
8 9
8 4 2 2
2 3
7 9
9 5 2 3
7 8
4 5 10
10 10 2 3
1 6
4 9 5
输出样例#1： 
12

说明

题目翻译来自NOCOW。

USACO Training Section 4.1

思路：重点在于预处理把边的编号转换为端点的编号，然后用Floyd求一遍最小环就可以了

/*************************************************************************
    > Author: wzw-cnyali
    > Created Time: 2017/4/9 19:07:01
 ************************************************************************/

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>

using namespace std;

typedef long long LL;

typedef unsigned long long uLL;

#define REP(i, a, b) for(register int i = (a), i##_end_ = (b); i <= i##_end_; ++ i)
#define DREP(i, a, b) for(register int i = (a), i##_end_ = (b); i >= i##_end_; -- i)
#define EREP(i, a) for(register int i = (be[a]); i != -1; i = nxt[i])
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define mem(a, b) memset((a), b, sizeof(a))

template<typename T> inline bool chkmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
template<typename T> inline bool chkmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }

template <class T>
T read(T sum = 0, T fg = 0)
{
	char c = getchar();
	while(c < '0' || c > '9') { fg |= c == '-'; c = getchar(); }
	while(c >= '0' && c <= '9') { sum = sum * 10 + c - '0'; c = getchar(); }
	return fg ? -sum : sum;
}

const int inf = 0x3f3f3f3f;

const int Size = 100000;

const int maxn = 10;

const int maxm = 1000;

struct node
{
	int L_id, R_id; //该条路的左右端点编号
	int L[maxn], R[maxn]; //左右端点连接的路
	int Lsum, Rsum;
	int len; //该路的长度
}line[Size];
int id_cnt; //编号

int map[maxm][maxm];
int dist[maxm][maxm];

int floyd() //floyd求最小环
{
	int minCircle = inf;
	REP(k, 1, id_cnt)
	{
		REP(i, 1, k - 1) REP(j, 1, i - 1)
			chkmin(minCircle, dist[i][j] + map[i][k] + map[k][j]);
		REP(i, 1, id_cnt) REP(j, 1, id_cnt)
			chkmin(dist[i][j], dist[i][k] + dist[k][j]);
	}
	return minCircle;
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("input.in", "r", stdin);
	freopen("output.out", "w", stdout);
#endif
	int n = read<int>();
	REP(i, 1, n)
	{
		int id = read<int>();
		line[id].len = read<int>();
		line[id].Lsum = read<int>();
		line[id].Rsum = read<int>();
		REP(j, 1, line[id].Lsum)
			line[id].L[j] = read<int>();
		REP(j, 1, line[id].Rsum)
			line[id].R[j] = read<int>();
	}
	REP(i, 1, n) //枚举每一个端点
	{
		if(!line[i].L_id) line[i].L_id = ++id_cnt; //第i条边左端点编号
		REP(j, 1, line[i].Lsum) //枚举第i条边左端点连接的边j
		{
			int x = line[i].L[j]; bool flag = 0;
			REP(k, 1, line[x].Lsum) //判断第j条边在第i条边的左边还是右边
				if(line[x].L[k] == i) { flag = 1; break; }

			if(flag) line[x].L_id = line[i].L_id;
			else line[x].R_id = line[i].L_id;
		}
		//第i条边右端点编号,处理相同
		if(!line[i].R_id) line[i].R_id = ++id_cnt;
		REP(j, 1, line[i].Rsum)
		{
			int x = line[i].R[j]; bool flag = 0;
			REP(k, 1, line[x].Lsum)
				if(line[x].L[k] == i) { flag = 1; break; }

			if(flag) line[x].L_id = line[i].R_id;
			else line[x].R_id = line[i].R_id;
		}
	}

	mem(dist, inf);
	mem(map, inf);

	REP(i, 1, n) //每条路存入map中
	{
		int L_id = line[i].L_id;
		int R_id = line[i].R_id;
		int len = line[i].len;
		map[R_id][L_id] = map[L_id][R_id] = len;
		dist[R_id][L_id] = dist[L_id][R_id] = len;
	}
	printf("%d\n", floyd());
    return 0;
}

wzw-yali
关注
【USACO题库】4.1.3 Fence Loops篱笆回路
Hello,I'm Proking.
04-24 1066
题目描述 农夫布朗的牧场上的篱笆已经失去控制了。它们分成了1~200英尺长的线段。只有在线段的端点处才能连接两个线段，有时给定的一个端点上会有两个以上的篱笆。结果篱笆形成了一张网分割了布朗的牧场。布朗想将牧场恢复原样，出于这个考虑，他首先得知道牧场上哪一块区域的周长最小。 1 +---------------+ |\ /| 2| \7 / | | \ / | +---+ / |6
P1090 [NOIP2004 提高组] 合并果子 / [USACO06NOV] Fence Repair G【哈夫曼树+优先队列】
海岛Blog
07-29 854
在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n−1次合并之后， 就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。因为还要花大力气把这些果子搬回家，所以多多在合并果子时要尽可能地节省体力。假定每个果子重量都为1。
洛谷P2738 [USACO4.1]篱笆回路Fence Loops
weixin_30745641的博客
10-17 138
P2738 [USACO4.1]篱笆回路Fence Loops 11通过 21提交 题目提供者该用户不存在 标签USACO 难度提高+/省选- 提交讨论题解 最新讨论 暂时没有讨论 题目描述 农夫布朗的牧场上的篱笆已经失去控制了。它们分成了1~200英尺长的线段。只有在线段的端点处才能连接两个线段，有时给定的一个端点上会有两个以上的...
[洛谷P2738] [USACO4.1]篱笆回路Fence Loops
dengtun2502的博客
02-18 174
洛谷题目链接:[USACO4.1]篱笆回路Fence Loops 题目描述 农夫布朗的牧场上的篱笆已经失去控制了。它们分成了1~200英尺长的线段。只有在线段的端点处才能连接两个线段，有时给定的一个端点上会有两个以上的篱笆。结果篱笆形成了一张网分割了布朗的牧场。布朗想将牧场恢复原样，出于这个考虑，他首先得知道牧场上哪一块区域的周长最小。 布朗将他的每段篱笆从1到N进行了标号（N=线段的总...
[USACO4.1]篱笆回路Fence Loops
07-28 139
题目：USACO Training 4.1（在官网上提交需加文件输入输出）、洛谷P2738。 题目大意：给你一张图里的边集，让你求出这张图的最小环。 解题思路：求最小环很简单，用Floyd即可。最重要的是，该题给你的是边集而不是点集，所以构图是关键。 我是这么构图的：设当前边的编号为$x$，我们先把它左端点编号设为$2x-1$，右端点编号设为$2x$，然后用$dy[p]$表示编号为...
USACO4.1 篱笆回路Fence Loops
A_Bright_CH的博客
06-03 395
【题意】有N(1&lt;=N&lt;=100)条双向边，我们知道每条边的三个属性：边的长度，边的一端所连接的边，边的另一端所连接的边。边不连接自身，且只在端点处连接其他边。求其中的最小环。输入格式第一行：N（1&lt;=N&lt;=100）。第2到3*N+1行：每三行为一组：每组第一行有四个整数：边的标号s(1&lt;=s&lt;=N)，长度L(1&lt;=L&lt;=255)，一端连接的边的数量...
洛谷 P2872 [USACO07DEC]Building Roads S
01-03
P2872 [USACO07DEC]Building Roads S 题目链接-P2872 [USACO07DEC]Building Roads S 解题思路 KruskalKruskalKruskal板子题 枚举每一个点，求出两点间的距离，连边，用结构体储存，并按照升序排序 对于之前已有...
[洛谷 P2986 USACO10MAR] Great Cow Gathering G (换根dp 经典)
qq_49494204的博客
11-06 327
[洛谷 P2986 USACO10MAR] Great Cow Gathering G 题目链接 大致题意: 有一颗树，你可以选定一个根节点，这个根节点的代价是∑c[i]∗dis[i]，c[i]表示点i的点权值,dis[i]表示点i到根节点的距离 解题思路: 二次扫描换根法 操作1: 先处理出以1为根节点的时候的代价 定义状态方程: f[i]表示i子树中所有点到i的代价 转移方程:f[u] += f[v] + w * cnt[v] (cnt[i]表示i的子树中所有点权和) 操作2: 重新定义状态方程
洛谷 P3128 [USACO15DEC] Max Flow P
qq_17807067的博客
11-16 242
洛谷 P3128 [USACO15DEC] Max Flow P，树上差分+倍增LCA
usaco 4.1 Fence Loops(floyd求最小环)
志当存高远
07-22 963
Fence Loops The fences that surround Farmer Brown's collection of pastures have gotten out of control. They are made up of straight segments from 1 through 200 feet long that join together only a
洛谷P2738[USACO4.1]篱笆回路Fence Loops
diyu0610的博客
07-06 166
简单的图论题 方法一：Floyd求最小环 难点：建图 技巧： ①运算符重载operator ②map映射 代码： #include <iostream> #include <algorithm> #include <cstring> #include <map> using namespace std; co...
USACO-Section4.1 Fence Loops【Floyd算法】
tjj1998的博客
03-03 290
题目描述： 农夫布朗的牧场上的篱笆已经失去控制了。它们分成了1~200英尺长的线段。只有在线段的端点处才能连接两个线段，有时给定的一个端点上会有两个以上的篱笆。结果篱笆形成了一张网分割了布朗的牧场。布朗想将牧场恢复原样，出于这个考虑，他首先得知道牧场上哪一块区域的周长最小。 布朗将他的每段篱笆从1到N进行了标号（N=线段的总数）。他知道每段篱笆有如下属性： 该段篱笆的长度 该段篱笆的一端所连...
【USACO4.1.3】篱笆回路 无向图最小环
ACMer不要报考高校代码为13627的移通学院！
05-11 933
题目意思就是让你求无向图最小环，但是给数据的方式非常恶心。 我的用并查集+暴力的方式…… 先给每个边的顶点标号，然后……  把A能到B，B也能到A的边的点，给并为一个点…… 然后floyd求最小环。 floyd最小环我自己还不是非常理解…… 但是先用着，上课再想 Executing... Test 1: TEST OK [0.00
Section 4.1 Fence Loops
china1000的专栏
02-03 510
/*ID: niepeng1PROG: fence6LANG: C++*/#include #define Max1 102#define MMax 0x7fffffffstruct Node{ int link[2][10]; int len;};Node map[Max1];int minlen = MMax;bool cond[Max1]={false};int n;int min,star
洛谷P2738 [USACO4.1]篱笆回路Fence Loops 题解
q779的博客
05-14 190
无向图最小环练习题 qwq
USACO 4.1.3 篱笆回路 （floyd找最小环）
Mogician_Evian的博客
10-28 568
【USACO4.1.3】Fence Loops篱笆回路问题描述 农夫布朗的牧场上的篱笆已经失去控制了。它们分成了1~200英尺长的线段。只有在线段的端点处才能连接两个线段，有时给定的一个端点上会有两个以上的篱笆。结果篱笆形成了一张网分割了布朗的牧场。布朗想将牧场恢复原样，出于这个考虑，他首先得知道牧场上哪一块区域的周长最小。布朗将他的每段篱笆从1到N进行了标号（N=线段的总数）。他知道每段篱笆有
最短路径 floyd最小环 洛谷2738 篱笆回路 网上题解
StoneXieAC的博客
09-03 185
/* https://www.luogu.org/blog/quadnucyard/solution-p2738 */ #include <cstdio> #include <cstring> #define MAXN 210 using namespace std; int n,m,l[MAXN],g[MAXN][MAXN],dist[MAXN...
USACO Fence Loops 解题报告
thestoryofsnow的专栏
01-08 762
这道题是看了网上的思路做出来的。之前尝试过（最小）生成树的方法，这似乎是获取所有“基本环”的标准方法，时间复杂度也更低，但由于我不知道怎么证明加之懒惰，没有这样实现。 这道题的思路是：逐一去掉一条边(把这条边的length设为无穷大)，然后求从这条边的左端点到右端点的最短路径(使用Dijkstra)，这样通过该边的最小基本环的长度就是这条边的长度与最短路径之和。所有的边遍历完后，最小基本环中最
求最小环
weixin_30786617的博客
08-15 385
floyd求最小环 2011-08-14 9:42 1 定义: 通常来说最小环是针对有向图而言 从一个点出发,经过一条简单路径回到起点成为环.图的最小环就是所有环中长度最小的. 2.怎样求最小环呢? 1传统的解决方法(dijkstra): 任意一个环的权值，我们都可以看成两个有边相连的结点i、j的直接距离加上i、j间不包含边(边i->j)的最短路...
洛谷P1700 [USACO19OPEN] Milk Factory B怎么用c++做
最新发布
08-09
<think>题目：洛谷P1700 [USACO19OPEN] Milk Factory B 题目描述：有一个牛奶加工厂，有N个站点（编号1到N），站点之间有传送带，传送带是单向的。现在要找一个站点，使得从这个站点出发，能够到达所有其他站点（允许通过传送带间接到达）。如果存在多个这样的站点，则选择编号最小的。如果没有这样的站点，则输出-1。 输入格式： 第一行：整数N（1≤N≤100），表示站点的数量。 接下来N-1行：每行两个整数a和b，表示有一条从a到b的传送带（注意是单向边，方向是a->b）。 输出格式： 输出满足条件的站点编号，如果没有则输出-1。 分析： 题目要求找到一个点，使得从这个点出发可以到达所有其他点。实际上，这就是在图中寻找一个“根”节点，使得从该节点出发可以遍历整个图（注意图是有向的，且边数为N-1，所以图是树？但注意：题目中并没有保证是树，因为可能有多个父节点？但题目只给了N-1条边，所以实际上是一个有向图，且边数比节点数少1，因此它可能是一个有向无环图（DAG）或者有环？但题目没有说，不过N-1条边，如果有环则无法形成连通图（因为树是无环的），但这里是有向图，所以可能形成树或者森林？然而题目要求能够到达所有其他站点，所以图必须是连通的（弱连通？）。 注意：题目中只给出了N-1条边，所以整个图是一个有向图，且边数比节点数少1，那么它可能是一棵有向树（但方向不一定是从根向叶子，因为题目输入是a->b，所以可能是从a指向b）。但是，题目没有保证边的方向是从根向叶子，所以我们需要考虑。 由于图只有N-1条边，所以整个图可能是一个有向无环图（DAG）并且是一棵树（即基图是一棵树，但方向任意）。但注意：树中边的方向通常是从根向叶子，但这里可能反过来？所以我们需要判断。 然而，题目要求的是：存在一个点，从它出发可以到达所有其他点。那么我们可以尝试对每一个点进行DFS/BFS，检查从这个点出发能否遍历所有节点。因为N最大为100，所以对每个点做一次DFS/BFS，总时间复杂度为O(N*(N+E)) = O(100*(100+99)) ≈ 100*200 = 20000，可以接受。 步骤： 1. 读入N。 2. 构建图：使用邻接表。 3. 对于每个节点i（从1到N），执行BFS/DFS，记录从i出发能够访问到的节点数。 4. 如果能够访问到所有N个节点（包括自己），则记录这个节点。 5. 在记录的所有节点中，选择编号最小的输出；如果没有，输出-1。 注意：图是有向的，所以边a->b，只能从a到b，不能反向。 代码实现： 我们将使用BFS，因为BFS使用队列，非递归，且对于100个节点来说很安全。 具体步骤： 1. 读入N，然后读入N-1行，每行两个整数a和b，构建有向边：graph[a].push_back(b) （注意：题目中传送带方向是a->b）。 2. 对于每个节点i（1~N）： 初始化visited数组（大小为N+1，全部为false），初始化队列，将i入队，标记visited[i]=true。 然后进行BFS：每次从队列中取出一个节点u，遍历u的所有邻居v，如果v没有被访问过，则标记并加入队列。 统计访问过的节点数（count）。 3. 如果count等于N，则说明节点i满足条件。 4. 遍历完所有节点后，如果存在满足条件的节点，输出最小的节点编号；否则输出-1。 注意：可能存在多个满足条件的节点，我们只需要最小的那个，所以一旦找到一个满足条件的节点，我们可以记录它的编号，然后继续找，最后取最小的（或者我们按节点编号从小到大遍历，那么第一个满足条件的节点就是最小的，但题目要求多个时取最小，所以我们可以按节点编号从小到大遍历，找到第一个满足条件的就输出并退出？不行，因为可能有多个，但我们需要最小的，所以即使找到一个，后面可能有更小的？不对，节点编号是从1到N，我们从小到大遍历，所以第一个满足条件的节点就是最小的节点？不对，因为节点编号是1,2,...,N，我们按节点编号顺序遍历，那么第一个满足条件的节点就是最小的节点吗？但是，我们遍历的顺序是1,2,...,N，所以当我们找到第一个满足条件的节点时，它一定是编号最小的（因为编号小的先遍历）。所以我们可以这样：从1到N遍历，一旦找到一个节点满足条件，就记录答案并跳出循环？不行，因为可能节点1不满足，节点2满足，但节点3也满足，而节点2比节点3小，所以我们应该记录所有满足条件的节点？然后取最小值？或者因为我们是按从小到大的顺序遍历，所以第一个满足条件的节点就是最小的？不对，因为节点1满足条件，那么它就是最小的；节点1不满足，节点2满足，那么节点2就是当前最小的；节点3满足条件但是比节点2大，所以我们在遍历到节点2时就可以记录并继续找更小的？不对，因为节点编号是递增的，后面不会出现比2更小的节点了。所以当我们按节点编号从小到大遍历时，第一个满足条件的节点就是最小的节点，可以直接输出并结束？不对，因为可能节点1不满足，节点2满足，然后节点3也满足，但是节点2比节点3小，所以我们在节点2满足时就可以输出节点2并结束循环（因为后面节点编号都比2大，所以最小的就是2）。因此，我们可以按节点编号从小到大遍历，一旦遇到一个满足条件的节点，就输出它并结束程序（因为后面即使有满足条件的节点，编号也更大，所以第一个满足条件的节点就是最小的）。如果没有遇到，最后输出-1。 但是，如果我们从1到N遍历，那么第一个满足条件的节点就是最小的，所以我们可以： for (int i=1; i<=N; i++) { 进行BFS，统计从i出发能到达的节点数count if (count == N) { cout << i << endl; return 0; // 结束程序 } } // 如果循环结束还没找到 cout << -1 << endl; 这样是可行的。 但是，注意：题目要求是“如果存在多个这样的站点，则选择编号最小的”，而我们的遍历顺序是1到N，所以第一个找到的满足条件的节点就是最小的，然后直接输出并结束程序。 代码实现： 注意：图可能有环吗？题目中只有N-1条边，所以不可能有环（因为环的存在需要至少与节点数相同的边数，比如一个环需要n条边，而这里只有n-1条边），所以图是无环的，因此不会出现重复访问的问题（但我们的BFS已经用visited数组避免重复访问了，所以即使有环也没关系）。 但是，图可能是不连通的吗？题目要求能够到达所有站点，所以如果图不连通，那么任何一个节点出发都不可能到达所有节点。所以我们的BFS在某个节点开始，如果访问的节点数不足N，就跳过。 由于边数只有N-1，所以整个图可能是一个有向树（基图是无向树，但边有方向）。但是，方向可能不是从根向叶子，所以可能有些节点有多个入度？题目没有说，所以按照输入处理。 我们按照上述思路编写代码。 注意：输入是N-1行，每行两个整数a和b，表示a->b的边。 代码示例：</think>### 解法思路 对于洛谷P1700 [USACO19OPEN] Milk Factory B 问题，需要找到一个站点（节点），使得从该站点出发能通过单向传送带到达所有其他站点。由于图只有 N-1 条边（树形结构），可能存在多个解，需输出编号最小的解，若无解则输出 -1。 #### 关键点 1. **图建模**：将站点视为节点，传送带视为有向边（a→b）。 2. **连通性检查**：对每个节点进行 BFS/DFS，检查是否能访问所有节点。 3. **最优选择**：从小到大遍历节点，找到第一个满足条件的节点即可（因编号递增）。 ### C++ 代码实现 ```cpp #include <iostream> #include <vector> #include <queue> #include <cstring> using namespace std; int main() { int N; cin >> N; vector<vector<int>> graph(N + 1); // 邻接表（索引0不使用） // 构建有向图（注意：共N-1条边） for (int i = 0; i < N - 1; i++) { int a, b; cin >> a >> b; graph[a].push_back(b); // 添加边 a→b } // 检查每个节点作为起点 for (int start = 1; start <= N; start++) { vector<bool> visited(N + 1, false); // 访问标记数组 queue<int> q; int count = 0; // 统计可达节点数 // BFS初始化 q.push(start); visited[start] = true; while (!q.empty()) { int u = q.front(); q.pop(); count++; // 遍历当前节点的所有出边 for (int v : graph[u]) { if (!visited[v]) { visited[v] = true; q.push(v); } } } // 若可达所有节点，输出并结束 if (count == N) { cout << start << endl; return 0; } } // 无解情况 cout << -1 << endl; return 0; } ``` ### 代码解释 1. **输入处理**： - 读取站点数 `N`。 - 构建邻接表 `graph`，存储每条有向边（`a→b` 对应 `graph[a].push_back(b)`）。 2. **BFS遍历**： - 对每个节点 `start` (1 到 N) 进行 BFS： - 初始化 `visited` 数组记录访问状态。 - 使用队列 `q` 进行广度优先搜索，统计可达节点数 `count`。 - 若 `count == N`，说明从 `start` 可达所有节点，输出 `start` 并结束程序。 3. **无解处理**： - 若遍历完所有节点均未找到解，输出 `-1`。 ### 复杂度分析 - **时间复杂度**：O(N²)，最坏情况下对每个节点进行 BFS（每个节点遍历所有边）。 - **空间复杂度**：O(N)，用于存储邻接表和访问标记。 ### 相关问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值