蓝桥杯上岸必背！！！(并查集补更)
大家好 我是寸铁💪
冲刺蓝桥杯省一模板大全来啦 🔥
蓝桥杯4月8号就要开始了 🙏
距离蓝桥杯省赛倒数第3天 ❗️ ❗️ ❗️
还没背熟模板的伙伴们背起来 💪 💪 💪
真题千千万万遍，蓝桥省一自然现！ ✌️
日更3000里，蓝桥眷顾你 🌟
暴力出奇迹，打表过样例 👊
祝大家4月8号蓝桥杯上岸 ☀️
不清楚蓝桥杯考什么的点点下方👇
考点秘籍
想背纯享模版的伙伴们点点下方👇
蓝桥杯省一你一定不能错过的模板大全(第一期)
蓝桥杯省一你一定不能错过的模板大全（第二期）
蓝桥杯省一你一定不能错过的模板大全（第三期）
蓝桥杯省一你一定不能错过的模板大全（第四期）！！！
想背注释模版的伙伴们点点下方👇
蓝桥杯必背第一期
蓝桥杯必背第二期
往期精彩回顾
蓝桥杯上岸每日N题 第一期(一)！！！
蓝桥杯上岸每日N题第一期(二)！！！
蓝桥杯上岸每日N题第一期(三)！！！
蓝桥杯上岸每日N题第二期(一)！！！
蓝桥杯上岸每日N题第三期(一)！！！
蓝桥杯上岸每日N题 第四期(最少刷题数)！！！
蓝桥杯上岸每日N题 第五期(山)！！！
蓝桥杯上岸每日N题 第六期(求阶乘)！！！
操作系统期末题库 第九期(完结)
LeetCode Hot100 刷题(第三期)
idea创建SpringBoot项目报错解决方案
数据库SQL语句（期末冲刺）
想看JavaB组填空题的伙伴们点点下方 👇
填空题
竞赛干货
算法竞赛字符串常用操作大全
蓝桥杯上岸必刷！！！(模拟/枚举专题)
蓝桥杯上岸必背！！！ (第三期 DP)
蓝桥杯上岸必背！！！(第四期DFS)
蓝桥杯上岸必背！！！(第五期BFS)
蓝桥杯上岸必背！！！(第六期树与图的遍历)
蓝桥杯上岸必背！！！(第七期 最短路算法)
蓝桥杯上岸必背！！！(第八期 简单数论)
前言
喜欢的小伙伴可以关注我，关注寸铁，我们一起上岸4.8蓝桥杯！！！
并查集
合并集合
基本思想：
每个集合用一颗树来表示，树根的编号就是整个集合的编号。
每个节点存储它的父节点，p[x]表示x的父节点。
#三个问题
P1：如何判断树根
if(p[x]==x)即根节点和输入的集合编号(它本身)相等
P2:如何求x的集合编号
if(p[x]==x) return p[x];
P3：如何合并两个集合
p[x]是x的集合编号，p[y]是y的集合编号
那么，需要让p[x]接上y，即x的祖宗节点为y的一个子节点。
返回祖宗节点：
return p[x];
如果p[x]等于x的话，就返回p[x]即根节点x，此时的返回值为常量x。
路径压缩:
if(p[x]!=x)p[x]=find(p[x]);
代码解读：
如果p[x]不等于x的话，就进行路径压缩操作，即让每个p[x]与自身进行比较，很明显相等，返回的均是x，这样就实现了路径压缩。
分析过程图
#代码
import java.util.*;
public class Main{
static int N=100010;
static int p[]=new int[N];
public static int find(int x){//返回祖宗节点+路径压缩
//条件：节点的父节点p[x]为x(祖宗节点)
//换句话来说，即只有祖宗节点等于它本身x
if(p[x]!=x)p[x]=find(p[x]);//路径压缩
return p[x];//返回祖宗节点
}
//等同于如下代码：
public static int find (int x){
if(p[x]==x)return x;
else{
p[x]=find p[x];
}
return p[x];
}
public static void main(String []args){
Scanner in = new Scanner(System.in);
int n=in.nextInt();
int m=in.nextInt();
//初始化：即让当前数据的父节点指向其本身，将父节点设置为自己。
for(int i=1;i<=n;i++)p[i]=i;
while(m-->0){
String s=in.next();
int a=in.nextInt();
int b=in.nextInt();
//合并，将a的祖宗节点作为b的一个子节点插入
if(s.equals("M"))p[find(a)]=find(b);
else{//查找b和a的集合编号是否一致
if(find(b)==find(a)){
System.out.println("Yes");
}
else{
System.out.println("No");
}
}
}
}
}
#参考资源
https://b23.tv/UDjPN9Y
https://b23.tv/13OXh8I
连通块中点的数量
思路
判断两节点是否在同一连通块中,就是看他们的祖宗节点是否相同。
合并操作使用并查集，将两个连通块合并成一个连通块。
还需要多维护一个size[]数组，用于统计节点所在连通块的数目。
我们在求解某个点在连通块中的数量时，由于是连通块，一个点所在的块的点都会被包含在内,我们可以直接找到他的祖宗节点，用祖宗节点记录块中点的个数，再返回他的祖宗节点的个数即可。
注意
size[find(b)]+=size[find(a)];
p[find(a)]=find(b);
顺序是先加后合并，先合并后加可能会造成结果出错！
注：这里的a、b顺序需要反着写
就比如size[]中是find(b)、find(a)
p[]中是find(a)、find(b)
解释：我们在将a的祖宗节点指向b的祖宗节点时，是将a合并到b中。
所以，size数量时，应该是b的数量合并a的数量。
反之，也成立。
不清楚的同学可以看这篇题解：
https://www.acwing.com/activity/content/code/content/5333512/
ACcode
import java.util.*;
public class Main{
static int N=100010;
static int size[]=new int[N];
static int p[]=new int[N];
public static int find(int x){
if(p[x]!=x)p[x]=find(p[x]);
return p[x];
}
public static void main(String []args){
Scanner in = new Scanner(System.in);
int n=in.nextInt();
int m=in.nextInt();
for(int i=1;i<=n;i++){
size[i]=1;
//初始时自己也算做一个点
//多维护一个size[]数组，用于记录点的个数。
p[i]=i;
}
while(m-->0){
String s=in.next();
if(s.equals("C")){
int a=in.nextInt();
int b=in.nextInt();
if(find(a)!=find(b)){
//合并两个节点
size[find(b)]+=size[find(a)];
//b的祖宗节点点数加上a的祖宗节点个数
p[find(a)]=find(b);
//a的祖宗节点为b的祖宗节点，合并成一个连通块
}
}
else if(s.equals("Q1")){
int a=in.nextInt();
int b=in.nextInt();
if(find(a)==find(b))System.out.println("Yes");
else System.out.println("No");
}
else if(s.equals("Q2")){
int a=in.nextInt();
System.out.println(size[find(a)]);
}
}
}
}
食物链
核心思想：
运用并查集，去维护每一个点到根节点的距离，根据同余定理，判断两个点(动物)的关系。
除了维护p[]数组，还需额外维护d[]数组去计算点到根节点的距离，再根据各个点到根节点距离差%3的余数来确定两个点的关系。
余数关系：
余数为1，表示吃根节点。
余数为2，表示可以被根节点吃。
余数为0，表示和根节点是同类。
可以进一步引申出x吃y,则x到根节点的距离比y到根节点的距离多1
分析图
理解题意
find()方法
询问t为1(x、y同类)
询问t为2（x吃y)
代码
import java.util.*;
import java.io.*;
public class Main{
static int N=50010;
static int n,m;
static int []p=new int[N];
static int []d=new int[N];
public static int find(int x) {
if(p[x]!=x) {
int t = find(p[x]);//记录根节点
d[x]+=d[p[x]];//计算x到根节点的距离
p[x]=t;//x的父节点直接指向根节点
}
return p[x];
}
public static void main(String []args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String []str=in.readLine().split(" ");
n=Integer.parseInt(str[0]);
m=Integer.parseInt(str[1]);
for(int i=0;i<n;i++) {
p[i]=i;//初始化每个点
}
int res=0;//假话个数
while(m-->0) {
String []strs=in.readLine().split(" ");
int t = Integer.parseInt(strs[0]);
int x = Integer.parseInt(strs[1]);
int y=Integer.parseInt(strs[2]);
if(x>n||y>n)res++;// >n表示假话
else {//均在1-n这个集合内
int px=find(x),py=find(y);//先找到x、y的父节点
//询问是1，同类关系
if(t==1) {
//在同一集合内
if(px==py&&(d[x]-d[y])%3!=0)res++;//不是同类，为假话
//不在同一集合内
else if(px!=py) {
p[px]=py;//先合并两个集合
//距离相等，为同类
d[px]=d[y]-d[x];
}
}
//询问是2，吃的关系
else {
//在同一集合内，不满足x吃y的关系，即距离差%3不为0
if(px==py&&(d[x]-d[y]-1)%3!=0)res++;
//不在同一集合内
else if(px!=py)
{
p[px]=py;//先合并两个集合
//p[px]=p[y];
//满足吃的关系，更新d[px]
d[px]=d[y]+1-d[x];
}
}
}
}
System.out.println(res);
}
}
亲戚
公共祖先(亲戚):并查集
分析
判断两个人是不是亲戚，直接判断他们的祖宗是不是同一个人即可。
判断公共祖宗/祖先，用并查集即可
运行时间:4458 ms
没有快读快写,会暴 TLE，只能过8个案例。
快读快写后,可以AC,通过全部案例。
注意：flush()放置在整个while循环之外,不然每一次循环就flush()刷新，需要耗费k倍的刷新时间导致TLE,只需要刷新一次即可。
不清楚并查集的同学可以看这篇题解：
https://www.acwing.com/activity/content/code/content/5321411/
import java.io.*;
public class Main{
static int N=20010;
static int p[]=new int[N];
public static int find(int x) {
if(p[x]!=x)p[x]=find(p[x]);
return p[x];
}
public static void main(String []args)throws IOException {
BufferedReader re=new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
String str[]=re.readLine().split(" ");
int n=Integer.parseInt(str[0]);
int m=Integer.parseInt(str[1]);
for(int i=1;i<=n;i++) {
p[i]=i;
}
while(m-->0) {
String s[]=re.readLine().split(" ");
int a=Integer.parseInt(s[0]);
int b=Integer.parseInt(s[1]);
if(find(a)!=find(b))p[find(a)]=find(b);
}
String s1[]=re.readLine().split(" ");
int k=Integer.parseInt(s1[0]);
while(k-->0) {
String s2[]=re.readLine().split(" ");
int q1=Integer.parseInt(s2[0]);
int q2=Integer.parseInt(s2[1]);
if(find(q1)==find(q2)) {
pw.println("Yes");
}
else {
pw.println("No");
}
}
pw.flush();//刷新流的位置放在整个while循环外
}
}
✨ ✨ ✨
看到这里，不妨点个关注 💖
