【一百零三】【算法分析与设计】并查集,并查集的实现,P3367 【模板】并查集

妖精七七_

已于 2024-06-03 17:49:15 修改

阅读量251

点赞数 3

分类专栏：算法设计与分析文章标签：算法 c++ 数据结构

于 2024-06-03 16:19:10 首次发布

本文链接：https://blog.csdn.net/m0_74163972/article/details/139418002

版权

算法设计与分析专栏收录该内容

110 篇文章 1 订阅

订阅专栏

并查集的实现

描述

给定一个没有重复值的整形数组arr，初始时认为arr中每一个数各自都是一个单独的集合。请设计一种叫UnionFind的结构，并提供以下两个操作。

boolean isSameSet(int a, int b): 查询a和b这两个数是否属于一个集合

void union(int a, int b): 把a所在的集合与b所在的集合合并在一起，原本两个集合各自的元素以后都算作同一个集合

[要求]

如果调用isSameSet和union的总次数逼近或超过O(N)，请做到单次调用isSameSet或union方法的平均时间复杂度为O(1)

输入描述：

第一行两个整数N, M。分别表示数组大小、操作次数接下来M行，每行有一个整数opt 若opt = 1，后面有两个数x, y，表示查询(x, y)这两个数是否属于同一个集合若opt = 2，后面有两个数x, y，表示把x, y所在的集合合并在一起

输出描述：

对于每个opt = 1的操作，若为真则输出"Yes"，否则输出"No"

示例1

输入：
4 5
1 1 2
2 2 3
2 1 3
1 1 1
1 2 3
复制

输出：
No
Yes
Yes
复制

说明：

每次2操作后的集合为 ({1}, {2}, {3}, {4}) ({1}, {2, 3}, {4}) ({1, 2, 3}, {4})

备注：

$\leqslant N, M \leqslant 10^6\\1⩽N,M⩽10^6$

保证 $\leqslant x, y \leqslant N$
保证 $1 ⩽ x, y ⩽ N$

在这里插入图片描述

一般写法

#include<bits/stdc++.h>
using namespace std;

#define int long long
#define endl '\n'
#define FAST() ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)

#define p pair<int,int> 
#define ff first
#define ss second 

#define ltu(i,a,b) for(int i=a;i<=b;i++)
#define utl(i,a,b) for(int i=a;i>=b;i--)

int n,m; // 定义两个整型变量n和m，表示数组大小和操作次数
struct node{
    int op,x,y; // 定义一个结构体node，包含三个整型变量op, x, y
};
vector<node> readd; // 定义一个存储node结构体的向量readd

vector<int>father; // 定义一个整型向量father，用来存储每个节点的父节点
vector<int>stackk; // 定义一个整型向量stackk，用来存储路径上的节点

// findd函数用于查找节点i的根节点
int findd(int i){
    while(!(father[i]==i)){ // 如果节点i不是自己的父节点
        i=father[i]; // 将i更新为它的父节点
        stackk.push_back(i); // 将节点i压入stackk
    }
    while(!stackk.empty()){ // 当stackk不为空时
        father[stackk.back()]=i; // 将stackk中的每个节点的父节点更新为i
        stackk.pop_back(); // 弹出stackk的最后一个元素
    }

    return i; // 返回根节点
}

// isSameSet函数用于判断两个节点x和y是否属于同一个集合
bool isSameSet(int x,int y){
    return findd(x)==findd(y); // 比较x和y的根节点是否相同
}

// unionn函数用于将两个节点x和y所在的集合合并
void unionn(int x,int y){
    father[findd(x)]=findd(y); // 将x的根节点的父节点设为y的根节点
}

// solve函数用于处理所有的操作
void solve(){
    father.assign(n+5,0); // 初始化father向量，大小为n+5
    stackk.clear(); // 清空stackk
    ltu(i,0,n+5-1){ // 遍历每个节点
        father[i]=i; // 初始化每个节点的父节点为自己
    }

    for(auto&xx:readd){ // 遍历所有的操作
        if(xx.op==1){ // 如果操作类型为1，表示查询操作
            if(isSameSet(xx.x,xx.y)){ // 判断x和y是否属于同一个集合
                cout<<"Yes"<<endl; // 是同一个集合则输出Yes
            }else{
                cout<<"No"<<endl; // 否则输出No
            }
        }else{ // 如果操作类型为2，表示合并操作
            unionn(xx.x,xx.y); // 合并x和y所在的集合
        }
    }
}

// main函数是程序的入口
signed main(){
    FAST(); // 加速输入输出

    cin>>n>>m; // 输入n和m
    readd.clear(); // 清空readd向量
    ltu(i,1,m){ // 遍历m次
        node temp; // 定义一个临时node变量
        cin>>temp.op>>temp.x>>temp.y; // 输入操作类型和对应的x, y
        readd.push_back(temp); // 将temp压入readd向量
    }
    solve(); // 调用solve函数处理操作
}

进阶写法

在这里插入图片描述

#include<bits/stdc++.h> // 引入所有标准库头文件
using namespace std;

#define int long long // 使用长整型定义int，方便处理大数
#define endl '\n' // 定义换行符
#define FAST() ios::sync_with_stdio(0),cin.tie(0),cout.tie(0) // 加速输入输出

#define p pair<int,int> // 定义一个整型对的类型别名
#define ff first // 定义first的别名
#define ss second // 定义second的别名

#define ltu(i,a,b) for(int i=a;i<=b;i++) // 定义从a到b的循环
#define utl(i,a,b) for(int i=a;i>=b;i--) // 定义从a到b的逆向循环

int n,m; // 定义两个长整型变量n和m，表示元素个数和操作次数
struct node{
    int op,x,y; // 定义一个结构体node，包含三个长整型变量op, x, y
};
vector<node> readd; // 定义一个存储node结构体的向量readd
vector<int> father; // 定义一个长整型向量father，用来存储每个节点的父节点

// findd函数用于查找节点i的根节点
int findd(int i){
    if(father[i]!=i) father[i]=findd(father[i]); // 如果节点i不是自己的父节点，递归查找父节点并路径压缩
    return father[i]; // 返回根节点
}

// solve函数用于处理所有的操作
void solve(){
    father.assign(n+5,0); // 初始化father向量，大小为n+5
    ltu(i,0,n+5-1){ // 遍历每个节点
        father[i]=i; // 初始化每个节点的父节点为自己
    }

    for(auto& xx : readd){ // 遍历所有的操作
        if(xx.op == 1){ // 如果操作类型为1，表示查询操作
            if(findd(xx.x) == findd(xx.y)){ // 判断x和y的根节点是否相同
                cout << "Yes" << endl; // 是同一个集合则输出Yes
            } else {
                cout << "No" << endl; // 否则输出No
            }
        } else { // 如果操作类型为2，表示合并操作
            father[findd(xx.x)] = findd(xx.y); // 将x的根节点的父节点设为y的根节点
        }
    }
}

// main函数是程序的入口
signed main(){
    FAST(); // 加速输入输出

    cin >> n >> m; // 输入n和m
    readd.clear(); // 清空readd向量
    ltu(i,1,m){ // 遍历m次
        node temp; // 定义一个临时node变量
        cin >> temp.op >> temp.x >> temp.y; // 输入操作类型和对应的x, y
        readd.push_back(temp); // 将temp压入readd向量
    }
    solve(); // 调用solve函数处理操作
}

P3367 【模板】并查集

【模板】并查集

题目描述

如题，现在有一个并查集，你需要完成合并和查询操作。

输入格式

第一行包含两个整数 $N, M$ ,表示共有 $N$ 个元i素和 $M$ 个操作。

接下来 $M$ 行，每行包含三个整数 $Z\_i,X\_i,Y\_i$ 。

当 $Z\_i=1$ 时，将 $X\_i$ 与 $Y\_i$ 所在的集合合并。

当 $Z\_i=2$ 时，输出 $X\_i$ 与 $Y\_i$ 是否在同一集合内，是的输出 Y ；否则输出 N 。

输出格式

对于每一个 $Z\_i=2$ 的操作，都有一行输出，每行包含一个大写字母，为 Y 或者 N 。

样例 #1

样例输入 #1
4 7
2 1 2
1 1 2
2 1 2
1 3 4
2 1 4
1 2 3
2 1 4
样例输出 #1
N
Y
N
Y
提示

对于 $30\%$ 的数据， $\le 10，M \le 20$ 。

对于 $70\%$ 的数据， $\le 100，M \le 10^3$ 。

对于 $100\%$ 的数据， $1\le N \le 10^4$ ， $1\le M \le 2\times 10^5$ ， $\le X\_i, Y\_i \le N$ ， $Z\_i \in \{ 1, 2 \}$ 。

一般写法

#include<bits/stdc++.h>
using namespace std;

#define int long long // 使用长整型定义int，方便处理大数
#define endl '\n' // 定义换行符
#define FAST() ios::sync_with_stdio(0),cin.tie(0),cout.tie(0) // 加速输入输出

#define p pair<int,int>
#define ff first
#define ss second 
#define ltu(i,a,b) for(int i=a;i<=b;i++) // 定义从a到b的循环
#define utl(i,a,b) for(int i=a;i>=b;i--) // 定义从a到b的逆向循环

int n, m; // 定义两个长整型变量n和m，表示元素个数和操作次数
struct node {
    int op, x, y; // 定义一个结构体node，包含三个长整型变量op, x, y
};
vector<node> readd; // 定义一个存储node结构体的向量readd

vector<int> father; // 定义一个长整型向量father，用来存储每个节点的父节点
vector<int> st; // 定义一个长整型向量st，用来存储路径上的节点

// findd函数用于查找节点i的根节点
int findd(int i) {
    while (!(father[i] == i)) { // 如果节点i不是自己的父节点
        i = father[i]; // 将i更新为它的父节点
        st.push_back(i); // 将节点i压入st
    }

    while (!st.empty()) { // 当st不为空时
        father[st.back()] = i; // 将st中的每个节点的父节点更新为i
        st.pop_back(); // 弹出st的最后一个元素
    }
    return i; // 返回根节点
}

// isSameSet函数用于判断两个节点x和y是否属于同一个集合
bool isSameSet(int x, int y) {
    return findd(x) == findd(y); // 比较x和y的根节点是否相同
}

// unionn函数用于将两个节点x和y所在的集合合并
void unionn(int x, int y) {
    father[findd(x)] = findd(y); // 将x的根节点的父节点设为y的根节点
}

// solve函数用于处理所有的操作
void solve() {
    father.assign(n + 5, 0); // 初始化father向量，大小为n+5
    ltu(i, 0, n + 5 - 1) { // 遍历每个节点
        father[i] = i; // 初始化每个节点的父节点为自己
    }
    st.clear(); // 清空st

    for (auto& xx : readd) { // 遍历所有的操作
        int op = xx.op, x = xx.x, y = xx.y; // 获取操作类型和对应的x, y
        if (op == 1) { // 如果操作类型为1，表示合并操作
            unionn(x, y); // 合并x和y所在的集合
        } else { // 如果操作类型为2，表示查询操作
            if (isSameSet(x, y)) cout << "Y" << endl; // 是同一个集合则输出Y
            else cout << "N" << endl; // 否则输出N
        }
    }
}

// main函数是程序的入口
signed main() {
    FAST(); // 加速输入输出

    cin >> n >> m; // 输入n和m
    readd.clear(); // 清空readd向量
    ltu(i, 1, m) { // 遍历m次
        node temp; // 定义一个临时node变量
        cin >> temp.op >> temp.x >> temp.y; // 输入操作类型和对应的x, y
        readd.push_back(temp); // 将temp压入readd向量
    }
    solve(); // 调用solve函数处理操作
}

进阶写法

#include<bits/stdc++.h> // 引入所有标准库头文件
using namespace std;

#define int long long // 使用长整型定义int，方便处理大数
#define endl '\n' // 定义换行符
#define FAST() ios::sync_with_stdio(0) // 加速输入输出

#define p pair<int,int> // 定义一个整型对的类型别名
#define ff first // 定义first的别名
#define ss second // 定义second的别名

#define ltu(i,a,b) for(int i=a;i<=b;i++) // 定义从a到b的循环
#define utl(i,a,b) for(int i=a;i>=b;i--) // 定义从a到b的逆向循环

int n, m; // 定义两个长整型变量n和m，表示元素个数和操作次数
struct node {
    int op, x, y; // 定义一个结构体node，包含三个长整型变量op, x, y
};
vector<node> readd; // 定义一个存储node结构体的向量readd
vector<int> father; // 定义一个长整型向量father，用来存储每个节点的父节点

// findd函数用于查找节点i的根节点
int findd(int i) {
    if (father[i] != i) father[i] = findd(father[i]); // 如果节点i不是自己的父节点，递归查找父节点并路径压缩
    return father[i]; // 返回根节点
}

// solve函数用于处理所有的操作
void solve() {
    father.assign(n + 5, 0); // 初始化father向量，大小为n+5
    ltu(i, 0, n + 5 - 1) father[i] = i; // 初始化每个节点的父节点为自己

    for (auto& xx : readd) { // 遍历所有的操作
        if (xx.op == 1) { // 如果操作类型为1，表示合并操作
            father[findd(xx.x)] = findd(xx.y); // 将x的根节点的父节点设为y的根节点
        } else { // 如果操作类型为2，表示查询操作
            if (findd(xx.x) == findd(xx.y)) cout << "Y" << endl; // 是同一个集合则输出Y
            else cout << "N" << endl; // 否则输出N
        }
    }
}

// main函数是程序的入口
signed main() {
    FAST(); // 加速输入输出

    cin >> n >> m; // 输入n和m
    ltu(i, 1, m) { // 遍历m次
        node temp; // 定义一个临时node变量
        cin >> temp.op >> temp.x >> temp.y; // 输入操作类型和对应的x, y
        readd.push_back(temp); // 将temp压入readd向量
    }
    solve(); // 调用solve函数处理操作
}