NEUQ-ACM 并查集+二分查找

最新推荐文章于 2024-10-16 19:39:35 发布
最新推荐文章于 2024-10-16 19:39:35 发布
阅读量363 收藏 4
点赞数 6
文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77248923/article/details/135044828
版权

P3367 【模板】并查集

本题算是最基础的并查集问题了，通过find函数通过递归+路径压缩维护并查集即可。

#include<iostream>
using namespace std;
int aa[10009];
int Find(int a)
{
	if (aa[a] == a)return a;
	return aa[a] = Find(aa[a]);
}
int main()
{
	int n, m, a, b, c;
	cin >> n >> m;
	for(int i=1;i<=n;i++)
		aa[i]=i;
	for (int i = 1; i <= m; i++)
	{
		cin >> a >> b >> c;
		if(a==1)
			aa[Find(b)] = Find(c);
		else
			if (Find(b) == Find(c))
				cout << 'Y' << endl;
			else
				cout << 'N' << endl;
	}
	return 0;
}

P8604 [蓝桥杯 2013 国 C] 危险系数

本题要求关键点的个数，本人的做法是通过dfs找出所有的路径，每找到一条路径，就把路径上的点都标记一下，最后通过判断点被标记的次数和总路径数作比较即可找出所有的关键点，注意最终答案需要把起点这个点减去。

#include<iostream>
#include<string.h>
using namespace std;
const int MAXN = 1009;
int n;
int g[MAXN][MAXN];
int u, v;
long long int num[MAXN];
long long int road;
int vis[MAXN];
void dfs(int a)
{
	if (a == v)
	{
		for (int i = 1; i <= n; i++)
			if (vis[i] == 1)num[i]++;
		road++;
		return;
	}
	vis[a] = 1;	
	for (int i = 1; i <= n; i++)
		if (g[a][i] == 1 && vis[i] == 0&&a!=i)
			dfs(i);
	vis[a] = 0;
}
int main()
{
	int k;
	cin >> n >> k;
	while (k--)
	{
		cin >> u >> v;
		g[u][v] = 1;
		g[v][u] = 1;
	}
	cin >> u >> v;
	dfs(u);
	int ans=0;
	for (int i = 1; i <= n; i++)
	{
		if (num[i] == road)
			ans++;
	}
	ans--;
	cout << ans;
	return 0;
}

P1330 封锁阳光大学

本题乍一看没有任何思路，需要找出问题的特点，此问题中，对于一条路，两个点一定有一个没有河蟹，而另一个有河蟹。如果规定一个点有河蟹，那么其他的点是否有河蟹可根据上述规则确定出来，通过递归对点进行染色（被染色的表示有河蟹的点），并不断判断有没有不符合上述规则的点，不符合的话，该情况就不符合。递归的时候顺便几下被染色的点的总是。将所有的点都遍历完，共n个dfs，并比较染色点数即可。注意本题需要用链表记录所有的路。

#include<iostream>
#include<algorithm>
#include<string.h>
#include<cmath>
using namespace std;
struct Edge
{
	int to;
	int nex;
}edge[200009];
int n, m;
int head[10009],vis[10009],sum[2],col[10009];
int cnt;
void add(int a, int b)
{
	cnt++;
	edge[cnt].to = b;
	edge[cnt].nex = head[a];
	head[a] = cnt;
}
bool dfs(int a,int color)
{
	if (vis[a])
	{
		if (col[a] != color)
			return false;
		return true;
	}
	vis[a] = 1;
	sum[color]++;
	col[a] = color;
	bool tf = true;
	for (int i = head[a]; tf && i; i = edge[i].nex)
	{
		tf = tf && dfs(edge[i].to, 1 - color);
	}
	return tf;
}
int main()
{
	int ans = 0;
	cin >> n >> m;
	int u, v;
	while (m--)
	{
		cin >> u >> v;
		add(u, v);
		add(v, u);
	}
	for (int i = 1; i <= n; i++)
	{
		if (vis[i])continue;
		sum[0] = 0; sum[1] = 0;
		if (dfs(i, 0))
			ans += min(sum[0], sum[1]);
		else
		{
			cout << "Impossible";
			return 0;
		}
	}
	cout << ans;
	return 0;
}

P3916 图的遍历

本题N范围较大，通过链表存图。本题选择反向存图，从最大的数开始遍历，将所有经过的数标记，这些经过的数他们的最终答案一定是这个最大的数，按照这个规则，从大往小，进行dfs并进行标记即可。

#include<iostream>
#include<algorithm>
#include<string.h>
#include<cmath>
using namespace std;
struct Edge
{
	int to;
	int nex;
}edge[100009];
int n, m,num;
int head[100009];
int cnt;
int ans[100009];
void dfs(int a)
{
	if (ans[a])
		return;
	ans[a] = num;
	for (int i = head[a]; i; i = edge[i].nex)
	{
		dfs(edge[i].to);
	}
}
void add(int a, int b)
{
	cnt++;
	edge[cnt].to = b;
	edge[cnt].nex = head[a];
	head[a] = cnt;
}
int main()
{
	cin >> n >> m;
	int u, v;
	while (m--)
	{
		cin >> u >> v;
		add(v, u);
	}
	for (num = n; num >= 1; num--)
	{
		dfs(num);
	}
	for (int i = 1; i <= n; i++)
	{
		cout << ans[i];
		if (i != n)cout << " ";
	}
	return 0;
}

P1119 灾后重建

此题本人Floyd还没学，选择用Dijkstra去做，此题对于确定的x，y，t直接套模板即可，值得注意的是，本题从t0到tn-1是不减的，而且输入的t也是不减的，因此，对于每一个t，无需重新构建图，可以利用上一个t对应的图进行修改即可，同时，Dijkstra算法中，也无需for循环到最后，一定是到一个点，之后所有点都还没有修好。通过这些细节进行时间复杂度优化。

#include<iostream>
#include<string.h>
using namespace std;
long long int Map[203][203];
long long int dist[203];
int vis[203];
int tt[203];
long long int map[203][203];
int main()
{
	long long int n, m, u, v, d;
	cin >> n >> m;
	for (int i = 0; i < n; i++)
		cin >> tt[i];
	for (int i = 1; i <= m; i++)
	{
		cin >> u >> v >> d;
		Map[u][v] = d;
		Map[v][u] = d;
	}
	int Q;
	cin >> Q;
	while (Q--)//!0:\n
	{
		int x, y, t;
		cin >> x >> y >> t;
		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++)
			{
				map[i][j] = (tt[i] <= t && tt[j] <= t) ? Map[i][j] : 0;
				if (map[i][j] == 0)
					map[i][j] = 2147483647;
			}
		long long int min = 0;
		int minncul = x;
		int minnnex = x;
		memset(vis, 0, sizeof(vis));
		for (int i = 0; i < n; i++)
			dist[i] = 2147483647;
		dist[x] = 0;
		vis[x] = 1;
		while (min != 2147483647)
		{
			min = 2147483647;
			for (int j = 0; j < n; j++)
			{
				if (vis[j])continue;
				if (map[minncul][j] + dist[minncul] < dist[j])
					dist[j] = map[minncul][j] + dist[minncul];
				if (dist[j] < min)
				{
					min = dist[j];
					minnnex = j;
				}
			}
			vis[minnnex] = 1;
			minncul = minnnex;
			if (minncul == y)break;
		}
		if (dist[y] == 2147483647)
			cout << -1;
		else
			cout << dist[y];
		if (Q != 0)cout << endl;
	}
	return 0;
}

P1525 [NOIP2010 提高组] 关押罪犯

本题需用并查集去做，根据要求需要使市长看到的最小，因此根据贪心思想，将所有怨气值排序，从大到小进行分配即可，知道无法分配时的怨气值即为最小的。

#include<iostream>
#include<algorithm>
using namespace std;
struct Edge
{
	int x, y, z;
}edge[100005];
int n, m, pre[20005], b[20005];
bool cmp(Edge a, Edge b)
{
	return a.z > b.z;
}
int find(int x)
{
	if (pre[x] == x)return x;
	else
		return pre[x] = find(pre[x]);
}
void add(int x, int y)
{
	pre[find(pre[x])] = find(pre[y]);
}
bool check(int x, int y)
{
	if (find(x) == find(y))
		return true;
	else
		return false;
}
int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
		pre[i] = i;
	for (int i = 1; i <= m; i++)
		cin >> edge[i].x >> edge[i].y >> edge[i].z;
	sort(edge + 1, edge + 1 + m, cmp);
	for (int i = 1; i <= m; i++)
	{
		if(check(edge[i].x, edge[i].y))
		{
			cout << edge[i].z; return 0;
		}
		else
		{
			if (!b[edge[i].x])b[edge[i].x] = edge[i].y;
			else
				add(b[edge[i].x], edge[i].y);
			if (!b[edge[i].y])b[edge[i].y] = edge[i].x;
			else
				add(b[edge[i].y], edge[i].x);
		}
	}
	cout << 0;
	return 0;
}

P3386 【模板】二分图最大匹配

#include<iostream>
#include<string.h>
using namespace std;
const int MAXN = 510;
int uN, vN;
int g[MAXN][MAXN];
int linker[MAXN];
bool vis[MAXN];
bool dfs(int u)
{
	for(int v=1;v<=vN;v++)
		if (g[u][v] && !vis[v])
		{
			vis[v] = true;
			if (linker[v] == -1 || dfs(linker[v]))
			{
				linker[v] = u;
				return true;
			}
		}
	return false;
}
int hungary()
{
	int res = 0;
	memset(linker, -1, sizeof(linker));
	for (int u = 1; u <= uN; u++)
	{
		memset(vis, false, sizeof(vis));
		if (dfs(u))res++;
	}
	return res;
}
int main()
{
	int e;
	cin >> uN >> vN>>e;
	int u, v;
	while (e--)
	{
		cin >> u >> v;
		g[u][v] = 1;
	}
	cout << hungary();
}

P1129 [ZJOI2007] 矩阵游戏

此题，可以将行看成x，列看成y，维护一张二分图，如果一个点是黑点，则从这个点的x连到对应的y，可以注意到，无论怎么行交换列交换，二分图的匹配情况是不变的，因此可以任意交换，使得，某一条线的xy相同，因此，只要不重点的所有线的数，即最大匹配数，能够等于n，可以通过交换，使得对角线的数都是1，即符合本题要求。此题就转化成了求二分匹配的题了。

#include<iostream>
#include<string.h>
using namespace std;
const int MAXN = 203;
int uN, vN;
int g[MAXN][MAXN];
int linker[MAXN];
bool vis[MAXN];
bool dfs(int u)
{
	for(int v=0;v<vN;v++)
		if (g[u][v] && !vis[v])
		{
			vis[v] = true;
			if (linker[v] == -1 || dfs(linker[v]))
			{
				linker[v] = u;
				return true;
			}
		}
	return false;
}
int hungary()
{
	int res = 0; memset(linker, -1, sizeof(linker));
	for (int u = 0; u < uN; u++)
	{
		memset(vis, false, sizeof(vis));
		if (dfs(u))res++;
	}
	return res;
}
int main()
{
	int m;
	cin >> m;
	while (m--)
	{
		cin >> uN;
		vN = uN;
		memset(g, 0, sizeof(g));
		for (int i = 0; i < uN; i++)
			for (int j = 0; j < uN; j++)
			{
				cin >> g[i][j];
			}
		if (hungary() == uN)
			cout << "Yes";
		else
			cout << "No";
		if (m != 0)cout << endl;
	}
	return 0;
}

2301_77248923
关注
NUEQ-ACM2021年度预备队题解仓库_NEUQ-ACM-Solution.zip
08-24
NUEQ-ACM2021年度预备队题解仓库_NEUQ-ACM-Solution
NEUQ-ACM预备队蓝桥杯题解提交处.zip
01-24
全国电子设计大赛、全国大学生智能汽车竞赛、蓝桥杯、集成电路创新创业大赛、光电设计竞赛、挑战杯、大创项目、互联网+、三创赛、计算机设计竞赛、创新创业大赛、ACM-ICPC国际大学生程序设计竞赛、全国大学生数学...
Henrik-Yao#NEUQ-ACM-Solution#题解59
07-25
1.最大子段和 2.汉诺塔问题 3.汉诺塔3 4.汉诺塔2 5.简单的归并 6.字符串的全排列 7. 逆序对 8.二分查找
Henrik-Yao#NEUQ-ACM-Solution#题解23
07-25
题解先设置一个字符组，将字符存入，设置一个大循环，对于每一次输入的字符组将其存入，依次和原字符组进行比较，最后统计相同即可。long long ans(long
Henrik-Yao#NEUQ-ACM-Solution#Week 9 题解1
07-25
1.一个1*1的块和a[n-1]组合 2.一个2*1的块和a[n-2]组合 3.一个3*1的块和a[n-3]组合
图算法之Floyd-Warshall 算法（全点对最短路径）详细解读
m0_61840987的博客
10-11 803
Floyd-Warshall 算法是求解全点对最短路径的经典算法，适用于需要处理负权边的场景。它的时间复杂度较高，因此适合处理顶点较少的密集图，而不是稀疏图。如果图中存在负权环，该算法可以用来检测。
数据结构常考基础代码题-数组倒置
qq_52291558的博客
10-16 285
根据题目中的“将数组中的元素顺序反转”，我们需要实现一个函数Reverse，用于反转数组中从start到end的元素。// 函数用于反转数组A中从start到end的元素int temp;// 使用while循环进行元素交换，直到start和end相遇或交叉// 保存A[start]的值// 将A[end]的值赋给A[start]// 将temp（原A[start]的值）赋给A[end]start++;// 移动start指针end--;// 移动end指针。
【从零开始的LeetCode-算法】3099. 哈沙德数
qq_40878316的博客
10-15 149
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
【刷题册】2024.10.13 - 2024.10.15
yj20040627的博客
10-16 504
BC153 [NOIP2010]数字统计 NC313 两个数组的交集 AB5 点击消除 BC64牛牛的快递 DP4 最小花费爬楼梯 数组中最小两个字符串的最小距离 BC149 简写单词 dd爱框框 除2！
【鸟类识别系统】Python+卷积神经网络算法+人工智能+深度学习+ResNet50算法+计算机课设项目
子午的博客
10-12 873
鸟类识别系统。本系统采用Python作为主要开发语言，通过使用加利福利亚大学开源的200种鸟类图像作为数据集。使用TensorFlow搭建ResNet50卷积神经网络算法模型，然后进行模型的迭代训练，得到一个识别精度较高的模型，然后在保存为本地的H5格式文件。在使用Django开发Web网页端操作界面，实现用户上传一张鸟类图像，识别其名称。本项目通过人工智能技术实现对鸟类图像的自动识别，满足用户在日常生活中快速、准确地识别鸟类的需求。
端盘子问题（二分查找+广度优先）
u012011912的博客
10-16 148
终于中午放学铃声打响了，小明想要尽快地前往食堂打自己最喜欢吃的菜。小明觉得，他会准备好若干个盘子再出发，带了几个盘子就打几份菜。但是一路上人群拥挤程度不同，如果太过拥挤，小明会拿不稳太多盘子。经过观察，小明发现食堂的地形可以用一个(1,1)(n,n)小明行走，并且每次可以花费 1 秒，从当前位置(i, j)移动到相邻的(i+1, j)(i, j+1)(i-1, j)或(i, j-1)。(1,1)(n,n)如果无论如何也不能在规定时间内到达终点，输出0。第一行包含两个整数n和Tnn × nT接下来n。
【C语言】一维数组应用Fibonacci数列
我的我的博客
10-16 76
前两项为1，从第三项开始，每一项为前两项的和。可以知道连续三项的关系：f[i]=f[i-1]+f[i-2]使用数组进行存储，十分方便。可以知道前n项的fibonacci数。
27.数据结构与算法-图的遍历（DFS,BFS）
q1312022158的博客
10-10 381
遍历定义与遍历实质 图的特点 图的常用遍历方法 深度优先搜索-DFS 邻接矩阵表示的无向图深度遍历实现 DFS算法效率分析 非连通图的遍历 广度优先搜索遍历-BFS 邻接表表示的无向图广度遍历实现 BFS算法效率分析 非连通图的广度遍历 DFS和BFS算法效率比较
水库抽样算法（大数据算法作业）
C_K_Y的博客
10-12 322
水库抽样技术归根到底就是在总体容量未知的情况下，仅通过单遍扫描数据集便能生成等概率抽样集合的一种均匀抽样技术。代码或许很简单，但是其中的数学知识以及思想方法是很值得学习的！
「4.4」祖孙询问
最新发布
no_play_no_games的博客
10-16 172
有 m 个询问，每个询问给出了一对节点的编号 x 和 y，询问 x 与 y 的祖孙关系。接下来 n 行每行一对整数对 a 和 b 表示 a 和 b 之间有连边。对于每一个询问，若 x 是 y 的祖先则输出 1，若 y 是 x 的祖先则输出 2，否则输出 0。对于 100% 的数据，1≤n,m≤4×10^4，每个节点的编号都不超过 4×10^4。接下来 m 行，每行两个正整数 x 和 y，表示一个询问。第 n+2 行是一个整数 m 表示询问个数；对于 30% 的数据，1≤n,m≤10^3；
【优选算法】（第三十一篇）
weixin_73861555的博客
10-10 670
对于⼀个⼦串⽽⾔，如果它是回⽂串，并且⻓度⼤于2，那么将它⾸尾的两个字⺟去除之后，它仍然是个回⽂串。我们可以先找出前两个的最⻓公共前缀，然后拿这个最⻓公共前缀依次与后⾯的字符串⽐较，这样就可以找出所有字符串的最⻓公共前缀。题⽬要求多个字符串的公共前缀，我们可以逐位⽐较这些字符串，哪⼀位出现了不同，就在哪⼀位截⽌。输⼊：strs=["flower","flow","flight"]输⼊：strs=["dog","racecar","car"]给你⼀个字符串s，找到s中最⻓的回⽂⼦串。输⼊：s="babad"
【数据结构】时间、空间复杂度详解
weixin_64178283的博客
10-16 705
时间复杂度和空间复杂度是评估程序性能的重要指标。时间复杂度关注程序运行时间，空间复杂度关注程序内存消耗。选择合适的算法，可以有效降低时间复杂度和空间复杂度，提高程序效率。希望这篇文章能够帮助你更好地理解时间复杂度和空间复杂度，让你在编写代码时更加得心应手！
BWA-mem Smith-Waterman 算法
2302_80012625的博客
10-13 702
Smith-Waterman 算法是一种强大的局部序列比对工具，它通过动态规划方法找到最优的局部比对区域，允许插入、缺失和错配。Smith-Waterman 算法通过构建一个得分矩阵，从两个序列中找到得分最高的局部比对，即找到序列中最相似的子序列，哪怕这些序列之间存在错配或 indels（插入和缺失）。Smith-Waterman 算法将会找到最相似的局部子序列，并返回局部比对结果。通过矩阵得分最高的区域，我们可以回溯找到局部最优的比对区域。我们将通过填充比对网格，找到它们之间的最优局部比对。
Leetcode 乘积最大子数组
985小菜鸡
10-13 406
该算法的目的是求出一个整数数组中乘积最大的连续子数组。
2021 NUEQ-ACM预备队题解集锦_NEUQ-ACM-Solution解压缩包
资源摘要信息:"NEUQ-ACM2021年度预备队题解仓库 NEUQ-ACM-Solution.zip" 知识点概述: 本资源是NEUQ（东北大学秦皇岛分校）ACM（Association for Computing Machinery）俱乐部在2021年度为预备队成员提供的题解仓库...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值