NEUQ-ACM预备队-week10-图论

Einstein学画画

题目描述

Einstein 学起了画画。

此人比较懒~~，他希望用最少的笔画画出一张画……

给定一个无向图，包含 $n$ 个顶点（编号 $1\sim n$），$m$ 条边，求最少用多少笔可以画出图中所有的边。

输入格式

第一行两个整数 $n,m$。

接下来 $m$ 行，每行两个数 $a,b$（$a\ne b$），表示 $a,b$ 两点之间有一条边相连。

一条边不会被描述多次。

输出格式

一个数，即问题的答案。

样例 #1

样例输入 #1

5 5
2 3
2 4
2 5
3 4
4 5

样例输出 #1

1

提示

对于 $50\%$ 的数据，$n\le 50$，$m\le 100$。

对于 $100\%$ 的数据，$1\le n\le 1000$，$1\le m\le {10}^5$。

思路

求欧拉路的板子题，特别考虑欧拉回路的情况就好，详细在代码注释

代码

#include<bits/stdc++.h>
using namespace std;
int n, m,ans;
int cnt[1005];
//一笔画问题（无向图一笔画问题）实际上是求欧拉路的问题，在本题中，未要求形成欧拉回路
//因此只需要找最少的欧拉路数即可
//欧拉路需要两个奇点，因此答案是奇点数/2(整除)--向下取整
//若没有奇点，则也可以一笔画（没有奇点是欧拉回路)--可以一笔画完全部的边，回到起点
int main()
{
	cin >> n >> m;
	int u, v;
	for (int i = 0; i < m; i++)
	{
		cin >> u >> v;
		cnt[u]++;
		cnt[v]++;
	}
	for (int i = 1; i <= n; i++)
	{
		if (cnt[i] % 2)
		{
			ans++;
		}
	}
	if (ans == 0)printf("1");
	else
	{
		printf("%d", ans / 2);
	}
	return 0;
}

[蓝桥杯 2017 国 C] 合根植物

题目描述

w 星球的一个种植园，被分成 $m\times n$ 个小格子（东西方向 $m$ 行，南北方向 $n$ 列）。每个格子里种了一株合根植物。

这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。

如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？

输入格式

第一行，两个整数 $m$，$n$，用空格分开，表示格子的行数、列数（$1<m,n<1000$）。

接下来一行，一个整数 $k$，表示下面还有 $k$ 行数据 $(0<k<10^5)$。

接下来 $k$ 行，第行两个整数 $a$，$b$，表示编号为 $a$ 的小格子和编号为 $b$ 的小格子合根了。

格子的编号一行一行，从上到下，从左到右编号。

比如：$5\times 4$ 的小格子，编号：

1  2  3  4
5  6  7  8
9  10 11 12
13 14 15 16
17 18 19 20

输出格式

一行一个整数，表示答案

样例 #1

样例输入 #1

5 4
16
2 3
1 5
5 9
4 8
7 8
9 10
10 11
11 12
10 14
12 16
14 18
17 18
15 19
19 20
9 13
13 17

样例输出 #1

5

提示

样例解释

时限 1 秒, 256M。蓝桥杯 2017 年第八届国赛

思路

使用并查集做本题 同时进行一定的路径压缩（菊花图–将全部子节点的父亲设为最前的祖先，不用链式的）

代码

#include<bits/stdc++.h>
using namespace std;
#define ll long long 
const int maxn = 1e6 + 5;
ll fa[maxn];
ll vis[maxn];
ll n, m, k;
ll ans;
int u, v;
//并查集的模板
int find(long long x);//查询操作
void merge(long long i, long long j);//合并操作
int main()
{
	cin >> n >> m >> k;
	//先将全部节点的父节点设为自己
	for (int i = 1; i <= n * m; i++)
		fa[i] = i;
	for (int i = 1; i <= k; i++)
	{
		cin >> u >> v;
		merge(u, v);
	}
	for (int i = 1; i <= n * m; i++) 
		find(i);
	for (int i = 1; i <= n * m; i++)
	{
		if (vis[fa[i]] == 1) continue;
		vis[fa[i]] = 1;
		ans++;
	}
	cout << ans;
	return 0;
}
//find使用路径压缩 将所有节点的父节点都设为祖先
//不用链式 降低时间复杂度
int find(long long x)
{
	if (fa[x] == x) return x;
	else
	{
		fa[x] = find(fa[x]);
		return fa[x];
	}
}
void merge(long long i, long long j)
{
	fa[find(i)] = find(j);
}

[NOIP2017 提高组] 奶酪

题目背景

NOIP2017 提高组 D2T1

题目描述

现有一块大奶酪，它的高度为 $h$，它的长度和宽度我们可以认为是无限大的，奶酪中间有许多半径相同的球形空洞。我们可以在这块奶酪中建立空间坐标系，在坐标系中，奶酪的下表面为 $z=0$，奶酪的上表面为 $z=h$。

现在，奶酪的下表面有一只小老鼠 Jerry，它知道奶酪中所有空洞的球心所在的坐标。如果两个空洞相切或是相交，则 Jerry 可以从其中一个空洞跑到另一个空洞，特别地，如果一个空洞与下表面相切或是相交，Jerry 则可以从奶酪下表面跑进空洞；如果一个空洞与上表面相切或是相交，Jerry 则可以从空洞跑到奶酪上表面。

位于奶酪下表面的 Jerry 想知道，在不破坏奶酪的情况下，能否利用已有的空洞跑 到奶酪的上表面去?

空间内两点 $P_1(x_1,y_1,z_1)$、$P2(x_2,y_2,z_2)$ 的距离公式如下：

$$\mathrm{dist}(P_1,P_2)=\sqrt{(x_1-x_2{)}^2+(y_1-y_2{)}^2+(z_1-z_2{)}^2}$$

输入格式

每个输入文件包含多组数据。

第一行，包含一个正整数 $T$，代表该输入文件中所含的数据组数。

接下来是 $T$ 组数据，每组数据的格式如下： 第一行包含三个正整数 $n,h,r$，两个数之间以一个空格分开，分别代表奶酪中空洞的数量，奶酪的高度和空洞的半径。

接下来的 $n$ 行，每行包含三个整数 $x,y,z$，两个数之间以一个空格分开，表示空洞球心坐标为 $(x,y,z)$。

输出格式

$T$ 行，分别对应 $T$ 组数据的答案，如果在第 $i$ 组数据中，Jerry 能从下表面跑到上表面，则输出 Yes，如果不能，则输出 No。

样例 #1

样例输入 #1

3 
2 4 1 
0 0 1 
0 0 3 
2 5 1 
0 0 1 
0 0 4 
2 5 2 
0 0 2 
2 0 4

样例输出 #1

Yes
No
Yes

提示

【输入输出样例 $1$ 说明】

第一组数据,由奶酪的剖面图可见：

第一个空洞在 $(0,0,0)$ 与下表面相切；

第二个空洞在 $(0,0,4)$ 与上表面相切；

两个空洞在 $(0,0,2)$ 相切。

输出 Yes。

第二组数据,由奶酪的剖面图可见：

两个空洞既不相交也不相切。

输出 No。

第三组数据,由奶酪的剖面图可见：

两个空洞相交，且与上下表面相切或相交。

输出 Yes。

【数据规模与约定】

对于 $20\%$ 的数据，$n=1$，$1\le h$，$r\le 10^4$，坐标的绝对值不超过 $10^4$。

对于 $40\%$ 的数据，$1\le n\le 8$，$1\le h$，$r\le 10^4$，坐标的绝对值不超过 $10^4$。

对于 $80\%$ 的数据，$1\le n\le 10^3$，$1\le h,r\le 10^4$，坐标的绝对值不超过 $10^4$。

对于 $100\%$ 的数据，$1\le n\le 1\times 10^3$，$1\le h,r\le 10^9$，$T\le 20$，坐标的绝对值不超过 $10^9$。

思路

同样是并查集 板子基本上可以和上题通用 主要是判断球和球之间能不能想切或者相交 从而判断这俩球能不能相连

最后构想能从底到顶的情况，显然是球与球相交/切并在奶酪中形成通路 也就是奶酪底的父亲和奶酪顶的父亲相同

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e3 + 5;
ll fa[maxn];
ll n, h, r, T;
ll X[maxn], Y[maxn], Z[maxn], x, y, z;
ll ans;
void init();//初始化
int find(ll x);//查询操作
void merge(ll i, ll j);//合并操作
bool check(ll x1, ll x2, ll y1, ll y2, ll z1, ll z2,ll r);
int main()
{
	
	cin >> T;
	for (int i = 1; i <= T; i++)
	{
		cin >> n >> h >> r;
		memset(X, 0, sizeof(X));
		memset(Y, 0, sizeof(Y));
		memset(Z, 0, sizeof(Z));
		for (int j = 1; j <= n; j++)
		{
			cin >> x >> y >> z;
			X[j] = x, Y[j] = y, Z[j] = z;
		}
		//先将节点的父亲设为自己
		init();
		for (int j = 1; j <= n; j++)
		{
			//球心高低于或等于半径表明与底部相交或者相切
			if (Z[j] <= r) 
				merge(j, 0);
			//同理与顶部相交或者相切
			if (Z[j] + r >= h)
				merge(j, 1001);
		}
		for (int j = 1; j <= n; j++)
		{
			for (int k = j + 1; k <= n; k++)
			{
				if (check(X[j], X[k], Y[j], Y[k], Z[j], Z[k], r))
					merge(j, k);
			}
		}
		if (find(0) == find(1001)) 
			cout << "Yes" << endl;
		else 
			cout << "No" << endl;
	}

	return 0;
}
//板子
void init()
{
	for (int i = 1; i <= n; i++)
		fa[i] = i;
	//根据数据 设置一个奶酪顶和奶酪底 最后查这两个的祖先是否相同
	fa[0] = 0;
	fa[1001] = 1001;
}
int find(ll x)
{
	if (fa[x] == x) return x;
	else
	{
		fa[x] = find(fa[x]);
		return fa[x];
	}
}
void merge(ll i, ll j)
{
	fa[find(i)] = find(j);
}
bool check(ll x1, ll x2, ll y1, ll y2, ll z1, ll z2, ll r)
{
	//判断球相切相交
	return  (x1-x2)*(x1 - x2)+(y1-y2)*(y1-y2)+(z1-z2)*(z1-z2)<= 4 * r * r;
}

灾后重建

题目背景

B 地区在地震过后，所有村庄都造成了一定的损毁，而这场地震却没对公路造成什么影响。但是在村庄重建好之前，所有与未重建完成的村庄的公路均无法通车。换句话说，只有连接着两个重建完成的村庄的公路才能通车，只能到达重建完成的村庄。

题目描述

给出 B 地区的村庄数 $N$，村庄编号从 $0$ 到 $N-1$，和所有 $M$ 条公路的长度，公路是双向的。并给出第 $i$ 个村庄重建完成的时间 $t_i$，你可以认为是同时开始重建并在第 $t_i$ 天重建完成，并且在当天即可通车。若 $t_i$ 为 $0$ 则说明地震未对此地区造成损坏，一开始就可以通车。之后有 $Q$ 个询问 $(x,y,t)$，对于每个询问你要回答在第 $t$ 天，从村庄 $x$ 到村庄 $y$ 的最短路径长度为多少。如果无法找到从 $x$ 村庄到 $y$ 村庄的路径，经过若干个已重建完成的村庄，或者村庄 $x$ 或村庄 $y$ 在第 $t$ 天仍未重建完成，则需要返回 -1。

输入格式

第一行包含两个正整数$N,M$，表示了村庄的数目与公路的数量。

第二行包含$N$个非负整数$t_0,t_1,\dots ,t_{N-1}$，表示了每个村庄重建完成的时间，数据保证了$t_0\le t_1\le \dots \le t_{N-1}$。

接下来$M$行，每行$3$个非负整数$i,j,w$，$w$为不超过$10000$的正整数，表示了有一条连接村庄$i$与村庄$j$的道路，长度为$w$，保证$i\ne j$，且对于任意一对村庄只会存在一条道路。

接下来一行也就是$M+3$行包含一个正整数$Q$，表示$Q$个询问。

接下来$Q$行，每行$3$个非负整数$x,y,t$，询问在第$t$天，从村庄$x$到村庄$y$的最短路径长度为多少，数据保证了$t$是不下降的。

输出格式

共$Q$行，对每一个询问$(x,y,t)$输出对应的答案，即在第$t$天，从村庄$x$到村庄$y$的最短路径长度为多少。如果在第t天无法找到从$x$村庄到$y$村庄的路径，经过若干个已重建完成的村庄，或者村庄x或村庄$y$在第$t$天仍未修复完成，则输出$-1$。

样例 #1

样例输入 #1

4 5
1 2 3 4
0 2 1
2 3 1
3 1 2
2 1 4
0 3 5
4
2 0 2
0 1 2
0 1 3
0 1 4

样例输出 #1

-1
-1
5
4

提示

对于$30\%$的数据，有$N\le 50$；

对于$30\%$的数据，有$t_i=0$，其中有$20\%$的数据有$t_i=0$且$N>50$；

对于$50\%$的数据，有$Q\le 100$；

对于$100\%$的数据，有$N\le 200$，$M\le N\times (N-1)/2$，$Q\le 50000$，所有输入数据涉及整数均不超过$100000$。

思路

重点是关注在Floyd算法的k层无须重置，不必每次询问每次遍历（时间不减）

代码

#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e2 + 5;
int n, m;
int u, v, w;
int h[maxn];
int dis[maxn][maxn];
int q;
int main()
{
	memset(dis, 0x3f, sizeof(dis));
	cin >> n >> m;
	for (int i = 0; i < n; i++)
	{
		cin >> h[i];
		dis[i][i] = 0;
	}
	for (int i = 0; i < m; i++)
	{
		//邻接矩阵无向边存图
		cin >> u >> v >> w;
		dis[u][v] = w;
		dis[v][u] = w;
	}
	cin >> q;
	int k = 0;
	//时间单调不减 在Floyd的第三层（k层）无须重复计算
	while (q--)
	{
		int x, y, t;
		cin >> x >> y >> t;
		while (h[k] <= t&&k<n)
		{
			for(int i=0;i<n;i++)
				for (int j = 0; j < n; j++)
				{
					dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
				}
			k++;
		}
		if (dis[x][y] == 0x3f3f3f3f || h[x] > t || h[y] > t)
			printf("-1\n");
		else printf("%d\n", dis[x][y]);
	}
	return 0;
}

[HAOI2006]聪明的猴子

题目描述

在一个热带雨林中生存着一群猴子，它们以树上的果子为生。昨天下了一场大雨，现在雨过天晴，但整个雨林的地表还是被大水淹没着，部分植物的树冠露在水面上。猴子不会游泳，但跳跃能力比较强，它们仍然可以在露出水面的不同树冠上来回穿梭，以找到喜欢吃的果实。

现在，在这个地区露出水面的有N棵树，假设每棵树本身的直径都很小，可以忽略不计。我们在这块区域上建立直角坐标系，则每一棵树的位置由其所对应的坐标表示(任意两棵树的坐标都不相同)。

在这个地区住着的猴子有M个，下雨时，它们都躲到了茂密高大的树冠中，没有被大水冲走。由于各个猴子的年龄不同、身体素质不同，它们跳跃的能力不同。有的猴子跳跃的距离比较远(当然也可以跳到较近的树上)，而有些猴子跳跃的距离就比较近。这些猴子非常聪明，它们通过目测就可以准确地判断出自己能否跳到对面的树上。

【问题】现已知猴子的数量及每一个猴子的最大跳跃距离，还知道露出水面的每一棵树的坐标，你的任务是统计有多少个猴子可以在这个地区露出水面的所有树冠上觅食。

输入格式

输入文件monkey.in包括：

第1行为一个整数，表示猴子的个数M(2<=M<=500)；

第2行为M个整数，依次表示猴子的最大跳跃距离（每个整数值在1–1000之间）；

第3行为一个整数表示树的总棵数N(2<=N<=1000)；

第4行至第N+3行为N棵树的坐标（横纵坐标均为整数，范围为：-1000–1000）。

（同一行的整数间用空格分开）

输出格式

输出文件monkey.out包括一个整数，表示可以在这个地区的所有树冠上觅食的猴子数。

样例 #1

样例输入 #1

4
 1 2 3 4
6
0 0
1 0
1 2
-1 -1
-2 0
2 2

样例输出 #1

3

提示

【数据规模】

对于40%的数据，保证有2<=N <=100，1<=M<=100

对于全部的数据，保证有2<=N <= 1000，1<=M=500

感谢@charlie003 修正数据

代码

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
int n, m, ans;
int d[maxn];
int fa[maxn];
int x[maxn], y[maxn];
struct Node {
	int x, y;
	double dis;
}node[maxn*maxn];
bool cmp(Node a, Node b);
void init();
int find(int x);
void merge(int i, int j);
int main()
{
	cin >> m;
	//跳跃距离
	for (int i = 1; i <= m; i++)
		cin >> d[i];
	cin >> n;
	for (int i = 1; i <= n; i++)
		cin >> x[i] >> y[i];
	int cnt=0;
	for(int i=1;i<=n;i++)
		for (int j = i+1; j <= n; j++)
		{
			cnt++;
			node[cnt].x = i;
			node[cnt].y = j;
			node[cnt].dis= sqrt((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]));
		}
	sort(node + 1, node + 1 + cnt, cmp);
	init();
	double M;
	for (int i = 1; i <= cnt; i++)
	{
		if (find(node[i].x) != find(node[i].y))
		{
			merge(node[i].x, node[i].y);
			M = max(M, node[i].dis);
		}
	}
	for (int i = 1; i <= n; i++)
	{
		if (d[i] >= M)ans++;
	}
	cout << ans;
	return 0;
}
bool cmp(Node a, Node b)
{
	return a.dis < b.dis;
}
void init()
{
	for (int i = 1; i <= n; i++)
		fa[i] = i;
}
int find(int x)
{
	if (fa[x] == x) return x;
	else
	{
		fa[x] = find(fa[x]);
		return fa[x];
	}
}
void merge(int i, int j)
{
	fa[find(i)] = find(j);
}