并查集专题训练

最新推荐文章于 2024-08-26 21:46:59 发布
最新推荐文章于 2024-08-26 21:46:59 发布
阅读量134 收藏
点赞数
分类专栏： codeforces&刷题笔记 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50298155/article/details/115423801
版权
本文探讨了并查集在解决组合优化问题中的应用，如01背包问题、无线网络维护、嫌疑人分析、超市商品选择等。通过维护集合大小、距离信息和权值，实现高效的数据结构操作，解决了一系列复杂问题。并查集的核心在于快速查找元素所属的集合，并在需要时合并集合，同时更新相关属性。
摘要由CSDN通过智能技术生成

搭配购买
并查集+01背包；
先合并分块，然后按照01背包模型求解

#include <iostream>
#include <algorithm>

using namespace std;
const int N = 10010;
int p[N], c[N], d[N];
int v[N], w[N];
int find(int x) {
    if (x != p[x]) p[x] = find(p[x]);
    return p[x];
}
int f[N];
void solve() {
    int n, m, W;
    cin >> n >> m >> W;
    for (int i = 1; i <= n; i++) cin >> c[i] >> d[i], p[i] = i;
    while (m--) {
        int u, v;
        cin >> u >> v;
        if (find(u) == find(v)) continue;
        else {
            c[find(u)] += c[find(v)];
            d[find(u)] += d[find(v)];
            p[find(v)] = find(u);
        }
    }
    int cnt = 1;
    for (int i = 1; i <= n; i++) {
        if (find(i) == i) v[cnt] = c[find(i)], w[cnt] = d[find(i)], cnt++;


    }
    for (int i = 1; i < cnt; i++) {
        for (int j = W; j >= v[i]; j--) {
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
    cout << f[W] << endl;




}
int main() {
    solve();

    return 0;
}

//维护集合大小使用size数组存储大小即可；
维护每个点到根节点的距离：

int find(int x){
    if(x!=p[x]){
        int root=find(p[x]);
        d[x]+=d[p[x]];
        p[x]=root;
    }
    return p[x];
}

Wireless Network
裸并查集+枚举

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 1010;
struct node {
    int x, y;
} pos[N];
int vis[N];//只有已经被维修的电脑才能连在一起；
int p[N];
int find(int x) {
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}
void solve() {
    int n, d;
    scanf("%d%d", &n, &d);
    for (int i = 1; i <= n; i++) p[i] = i, scanf("%d%d", &pos[i].x, &pos[i].y);
    char op[2];
    int m;
    int a, b;
    while (~scanf("%s", op)) {
        if (op[0] == 'O') {
            scanf("%d", &m);
            vis[m] = 1;//被维修；
            for (int i = 1; i <= n; i++) {
                if ((pos[i].x - pos[m].x) * (pos[i].x - pos[m].x) + (pos[i].y - pos[m].y) * (pos[i].y - pos[m].y) <= d * d and vis[i]) {//判断距离
                    int pi = find(i), pm = find(m);
                    p[pi] = pm;
                }
            }
        } else {
            scanf("%d%d", &a, &b);
            if (find(a) == find(b)) puts("SUCCESS");
            else puts("FAIL");
        }
    }
}
int main() {

    solve();
    return 0;
}

The Suspects
维护size的并查集

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

using namespace std;
const int N = 30010;
int p[N], s[N];
int find(int x) {
    if (x != p[x]) p[x] = find(p[x]);
    return p[x];
}
void solve() {
    int n, m;
    while (scanf("%d%d", &n, &m), n) {
        for (int i = 0; i < n; i++) p[i] = i, s[i] = 1;

        while (m--) {
            int k, x, lst;
            scanf("%d", &k);
            int cnt = k;

            while (cnt--) {
                scanf("%d", &x);
                if (cnt == k - 1) {
                    lst = x;

                    continue;
                }
                int px = find(x), pl = find(lst);
                if (px != pl) {

                    s[pl] += s[px];
                    p[px] = pl;
                }
                lst = x;
            }
        }
        printf("%d\n", s[find(0)]);
    }
}
int main() {
    solve();

    return 0;
}

How Many Tables
裸并查集统计个数；

#include <iostream>
#include <algorithm>

using namespace std;
const int N = 1010;
int p[N];
int find(int x){
    if(x!=p[x]) p[x]=find(p[x]);
    return p[x];
}
void solve() {
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) p[i] = i;
    while (m--) {
        int a, b;
        cin >> a >> b;
        int pa = find(a), pb = find(b);
        p[pa] = pb;
    }
    int cnt = 0;
    for (int i = 1; i <= n; i++) {
        if (find(i) == i) cnt ++;
    }
    cout << cnt << endl;
}
int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

How Many Answers Are Wrong
带权并查集，维护到根节点的距离；
假如两个集合不在一起时，需要合并；
如果两个集合属于同一个根，则需要判断；
合并集合的时候只改变根节点的距离；

#include <iostream>
#include <algorithm>

using namespace std;
const int N = 200010;
int p[N], d[N];
int find(int x) {
    if (x != p[x]) {
        int root = find(p[x]);
        d[x] += d[p[x]];
        p[x] = root;
    }
    return p[x];
}
void solve() {
    int n, m;
    while (~scanf("%d%d", &n, &m)) {
        int a, b, s;
        int cnt = 0;
        for (int i = 1; i <= n; i++) p[i] = i, d[i] = 0;
        while (m--) {
            scanf("%d%d%d", &a, &b, &s);
            a--;
            int pa = find(a), pb = find(b);
            if (pa == pb) {
                if (d[b] - d[a] != s) cnt++;
            } else {
                p[pb] = pa;
                d[pb] = d[a] + s - d[b];//假如pb=C，把三角形abc拉成变成一条直线，就能得出这个结论；
            }
        }
        printf("%d\n", cnt);
    }
}
int main() {
    solve();

    return 0;
}

食物链
带权并查集

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 50010;
int p[N], d[N];
int find(int x) {
    if (x != p[x]) {
        int root = find(p[x]);
        d[x] += d[p[x]];
        p[x] = root;
    }
    return p[x];
}
void solve() {

    int n, k;
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++) p[i] = i;
    int res = 0;
    while (k--) {
        int s, a, b;
        scanf("%d%d%d", &s, &a, &b);
        if (a > n or b > n) res++;
        else {
            int pa = find(a), pb = find(b);
            if (s == 1) {
                if (pa == pb and (d[a] - d[b]) % 3) res++;
                else if (pa != pb) {
                    p[pa] = pb;
                    d[pa] = d[b] - d[a];
                }
            } else {
                if (a == b) res++;
                else if (pa == pb and (d[a] - d[b] - 1) % 3) res++;
                else if (pa != pb) {
                    p[pa] = pb;
                    d[pa] = d[b] + 1 - d[a];
                }
            }
        }
    }
    printf("%d\n", res);
}
int main() {

    solve();

    return 0;
}

并查集刷题心得：带权并查集，当集合合并时，改变的是未合并时根节点到祖宗节点的距离；这个可以通过三者之间的关系确定；
小希的迷宫
思路，假如两个点已经在同一个集合，那么肯定会有环出现；
最后判断可以判断集合是否只有一个，或者点数减边数等于1；

//点数减边数为1；
//维护size集合；
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
int p[100005], success;
int s[100005];
int edge;
int lst;
void init() {

    for (int i = 0; i < 100005; i++) {
        p[i] = i;
        s[i]=1;
    }
}
int find(int x) {
    return x == p[x] ? x : p[x] = find(p[x]);
}
void merge(int x, int y) {
    int px = find(x);
    int py = find(y);
    if (px != py) {
        s[py]+=s[px];
        p[px] = py;
    } else
        success = 0;
}
bool check(){
    return s[find(lst)]-edge==1;
}
int main() {
    int n, m, a, b;
    while (scanf("%d %d", &n, &m) != EOF) {
        if (m == 0 and n == 0) {
            printf("Yes\n");
            continue;
        }
        init();

        if (m == -1 and n == -1) {
            break;
        }
        merge(m, n);
        edge=1;
        success = 1;
        // vis[n] =  vis[m] = 1;
        while (scanf("%d %d", &a, &b) , a and b) {
            merge(a, b);
            lst=a;
            // vis[a] = 1, vis[b] = 1;
            range++;
        }
        if (success == 0) {
            printf("No\n");
            
        } else {
            if (check()) {
                printf("Yes\n");
            } else {
                printf("No\n");
            }
        }
    }
    return 0;
}
//判断集合是否只有一个
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
int p[100005], success;
int vis[100005];
void init() {

    for (int i = 0; i < 100005; i++) {
        p[i] = i;
        vis[i] = 0;
    }
}
int find(int x) {
    return x == p[x] ? x : p[x] = find(p[x]);
}
void merge(int x, int y) {
    int px = find(x);
    int py = find(y);
    if (px != py) {
        p[px] = py;
    } else
        success = 0;
}
bool check(){
    int sum=0;
    for(int i=1;i<=100005;i++){
        if(vis[i] and p[i]==i) sum++;
    }
    return sum==1;
}
int main() {
    int n, m, a, b;
    while (scanf("%d %d", &n, &m) != EOF) {
        if (m == 0 and n == 0) {
            printf("Yes\n");
            continue;
        }
        init();
        if (m == -1 and n == -1) {
            break;
        }
        merge(m, n);
        success = 1;
        vis[n] =  vis[m] = 1;
        while (scanf("%d %d", &a, &b) , a and b) {
            merge(a, b);
            vis[a] = 1, vis[b] = 1;
        }
        if (success == 0) {
            printf("No\n");
            
        } else {
            if (check()) {
                printf("Yes\n");
            } else {
                printf("No\n");
            }
        }
    }
    return 0;
}

Supermarket

//这里并查集的作用是用于记录时间点；
//贪心思路：按照利润大小排序；然后选择最大的利润再让p[px]=px-1;
//说明假如还有同一个时间点的就排到前一个位置；
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
const int N = 10010;
int p[N];
struct node {
    int x, d;
} a[N];
bool cmp(node a, node b) {
    return a.x > b.x;
}
int find(int x) {
    if (x != p[x]) p[x] = find(p[x]);
    return p[x];
}
void inti() {
    for (int i = 1; i <= N; i++) p[i] = i;
}
void solve() {
    int n;
    while (~scanf("%d", &n)) {
        inti();
        for (int i = 1; i <= n; i++) {
            scanf("%d%d", &a[i].x, &a[i].d);
        }
        sort(a + 1, a + 1 + n, cmp);
        int ans = 0;
        for (int i = 1; i <= n; i++) {
            int pa = find(a[i].d);
            if (pa > 0) {
                ans += a[i].x;
                p[pa] = pa - 1;
            }
        }
        printf("%d\n", ans);
    }
}
int main() {

    solve();
    return 0;
}

A Bug’s Life
带权分类并查集

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
int p[2010], d[2010];
int Case = 1;
int find(int x) {
    if (x != p[x]) {
        int root = find(p[x]);
        d[x] += d[p[x]];
        p[x] = root;
    }
    return p[x];
}

void join(int a, int b) {
    int pa = find(a), pb = find(b);
    p[pa] = pb;
    d[pa] = d[b] - d[a] + 1;
}
void solve() {
    int n, m;
    int check = 1;
    scanf("%d%d", &n, &m);
    int a, b;
    for (int i = 1; i <= n; i++) p[i] = i,d[i]=0;
    while (m--) {
        scanf("%d%d", &a, &b);
        int pa = find(a), pb = find(b);
        if (pa != pb) join(a, b);
        else if (pa == pb) {
            if (abs(d[a] % 2 - d[b] % 2) == 0) check = 0;
        }
    }

    printf("Scenario #%d:\n", Case++);
    if (check) printf("No suspicious bugs found!\n");
    else printf("Suspicious bugs found!\n");
    putchar('\n');
}
int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        solve();
    }

    return 0;
}

is a tree?
判断是不是树的条件；
1.除了根节点剩下的入度都是1；（有向）
2.只有一个根节点；
3.空树也算，环不能算，包括自环；

//以后保证再不改代码了，越改越乱qwq
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
int p[100005], success;
int vis[100005];
int d[100005];
int edge;
int lst;
int Case=1;
void init() {
    for (int i = 0; i < 100005; i++) {
        p[i] = i;
        vis[i]=0;
        d[i]=0;
    }
}
int find(int x) {
    return x == p[x] ? x : p[x] = find(p[x]);
}
void merge(int x, int y) {
    int px = find(x);
    int py = find(y);
    if(x==y) success=0;
    else if (px != py and !d[y]) {
        // s[px]+=s[py];
        p[py] = px;
        d[y]=1;
    } else
        success = 0;
}
bool check(){
    int sum=0;
    for(int i=1;i<=100005;i++){
        if(find(i)==i and vis[i]) sum++;
    }
    
    return sum==1;
}
int main() {
    int n, m, a, b;
    while (scanf("%d %d", &n, &m) != EOF) {
        
        if (m == 0 and n == 0) {
            printf("Case %d is a tree.\n",Case++);
            continue;
        }
        init();

        if (m == -1 and n == -1) {
            break;
        }
        success = 1;
        merge(n, m);
        edge=1;
        
        vis[n] =  vis[m] = 1;
        while (scanf("%d %d", &a, &b) , a and b) {
            merge(a, b);
            lst=a;
            vis[a] = 1, vis[b] = 1;
            edge++;
        }
        
        printf("Case %d ",Case++);
        if (success == 0) {
            printf("is not a tree.\n");
            
        } else {
            if (check()) {
                printf("is a tree.\n");
            } else {
                printf("is not a tree.\n");
            }
        }
    }
    return 0;
}
_Koto
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【并查集】练习题以及解答
小酷Miki的专栏
05-11 1066
核心代码（C++版本） const int MAXNUM = 500000 + 10; int id[MAXNUM]; int Size[MAXNUM]; int Count; // 初始化 void make_set(int n){ for(int i = 0 ; i &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt; n; i++){ id[i] = i; Size[i] = 1; ...
并查集算法总结&专题训练
Plozia 的小窝
11-23 348
1.概述 并查集是一种数据结构，用于图论之中（更多时候用于树），通常用来维护一张无向图内 O(1)O(1)O(1) 判断两个点是否在同一个连通块内，有很多的用法，扩展性也比较高。 2.例题 下面还是通过一道例题讲解并查集的用法。 link 我们假设这 4 个元素分别表示 4 个人。假设每个人都会在一个群内，第 iii 个人的群主表示为 faifa_ifai​ （其实如果抽象成一棵树，就是 iii 的父亲节点） 初始时，每一个人单独在一个群内，则令 fai=ifa_i=ifai​=i （这一步是并查集的初始化
【算法与数据结构】—— 并查集
热门推荐
酱懵静的博客
03-26 15万+
并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题（即所谓的并、查）。比如说，我们可以用并查集来判断一个森林中有几棵树、某个节点是否属于某棵树等。并查集主要由一个整型数组pre[ ]和两个函数find( )、join( )构成。 数组 pre[ ] 记录了每个点的前驱节点是谁，函数 find(x) 用于查找指定节点 x 属于哪个集合，函数 join(x,y) 用于合并两个节点 x 和 y 。
并查集专题练习：好朋友(未完待续)
行步至春深
08-11 124
输入样例1 4 2 1 4 2 3 样例输出1 2 输入样例2 7 5 1 2 2 3 3 1 1 4 5 6
并查集入门+初级专题训练
TK_wang_的博客
04-13 498
介绍 摘自罗勇军，郭卫斌的《算法竞赛入门到进阶》上的说明： 并查集(Disjoint Set)是一种非常精巧而且食用的数据结构，它主要用于处理一些不相交集合的合并问题。经典的例子有连通子图、最小生成树Kruskal算法和最近公共祖先(Lowser Common Ancestors, LCA)等。在欧拉路上也常常会用到并查集。 并查集：将编号分别为1-n的n个对象划分为不相交集合，在每个集合中，选择...
【并查集】专题练习
m0_74183164的博客
05-31 307
判断点是否在一个集合中。
专题训练——并查集
luna_sama的博客
10-15 112
并查集 分类: #mermaid-svg-XFMSSLLMqpqg3iIV .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color:#333}#mermaid-svg-XFMSSLLMqpqg3iIV .label text{fill:#333}#mermaid-svg-XFMSSLLMqpqg3iIV .node rect,#mermaid-svg-XF
算法训练——并查集专题
qq_44090228的博客
10-21 130
1
算法训练 - 并查集
RichardGreenh的博客
02-18 306
这个是我做 kuangbin带你飞专题训练的第三个专题，对应的是 kuangbin带你飞专题五，这个专题是并查集专题，包含14道题目。 并查集属于树形结构，是一种用来管理元素分组情况的数据结构。并查集可以高效的进行如下操作： 查询元素 a 和元素 b 是否属于同一个组 合并元素 a 和元素 b 所在的分组 值得注意的是，并查集虽然可以进行合并操作，但是不能进行分割操作。当然了这并不意味着...
【专题讲解】并查集union-find
遍地跑小鸡的博客
04-08 175
我们还是一道题目为例子。 这是399题，除法求值。是一道带权值的并查集题目。 并查集算法是说可以将相互连通的节点都归类到一个根节点上。这样可以很快的判断两个触电之间时候属于同一类（是否连通）。 一般的算法包括普通的并查集算法，带权值的quick-union算法，和含有路径压缩的算法。这道题目还一个难点在于定义每条边的权值。这里的每个value是当前节点相对于父节点的大小。具体的可以参考算法4. 这...
2021届（新高考）高三全科专题练习系列Ⅰ（语文）.zip
12-31
《2021届新高考高三全科专题练习系列Ⅰ（语文）》是一个针对即将参加新高考的高三学生设计的语文复习资料合集。这个压缩包文件包含了全面的语文专题练习，旨在帮助学生深入理解和掌握高考语文的各项知识点，提高备考...
sql server专题实验4 复杂查询.rar
05-24
在SQL Server专题实验4中，我们通过一系列实际案例和练习，将理论知识与实践操作相结合，逐步提高在处理复杂查询时的效率和准确性。这将有助于我们在数据库管理和数据分析领域中更好地应对各种挑战。通过深入学习和...
SQL专题(SQL数据查询与SQL数据库表的管理)教案.pdf
03-04
在本门名为“SQL专题：SQL数据查询与SQL数据库表的管理”的教程中，课程的主要目的是帮助学生精通T-SQL语言，特别是在数据查询和数据库表管理方面。这90分钟的课程将涵盖五个主要部分，旨在使学员能够熟练地执行各种...
论文研究-一种有效的专题信息集中和检索策略.pdf
07-22
提出一种基于锚文本和标题信息过滤并结合网页内容相关度判断的HITS专题检索策略，利用专题训练集判断主题相关度，很好地解决了只依靠查询字符串判断的弊端。实验表明，此策略能很好地提高专题信息汇聚精确度和检索的...
趣味算法------试用 6 和 9 组成的最大数字
最新发布
markingyi的博客
08-26 253
给出一个数字，反转其中一位使数字最大化，递归求解。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 372
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
算法日记day 45（单调栈之每日温度|接雨水）
m0_74980681的博客
08-22 893
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
7-7 数组中能被5整除的数的和
Virgo_616的博客
08-26 133
在一维数组中有10个整数，求出其中能被5整除的所有数的和。
算法025：前缀和
m0_62319039的博客
08-22 231
算法025：前缀和
宫水三叶的刷题日记：并查集专项教程与实战
该专题合集的目的是帮助读者通过系统的学习和练习来提升算法能力，特别是针对并查集这种经典的数据结构和算法。 在使用这个合集时，用户应遵循以下步骤： 1. 导航至资源：首先，访问宫水三叶在Github或Gitee上的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值