并查集与最小生成树

最新推荐文章于 2022-07-05 01:08:50 发布
最新推荐文章于 2022-07-05 01:08:50 发布
阅读量125 收藏
点赞数
分类专栏： ACM算法 文章标签： 图论 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linjing_zyq/article/details/119917484
版权

文章目录

并查集与最小生成树练习题

前导知识：

并查集，最小生成树

1. 亲戚

传送门

#include <iostream>
using namespace std;
const int MAX_N = 5005;
int n,m,q;
int fa[MAX_N<<1];
int find(int x){
    if(fa[x]!=x) fa[x]=find(fa[x]);
    return fa[x];
}
void unionSet(int x,int y){
    fa[find(y)]=find(x);
}
int main(){
    cin>>n>>m>>q;
    /* 初始化 */
    for(int i=1;i<=n;i++) fa[i]=i;
    
    for(int i=1;i<=m;i++){
        int a,b;
        cin>>a>>b;
        unionSet(a,b);
    }
    for(int i=1;i<=q;i++){
        int c,d;
        cin>>c>>d;
        if(find(c)==find(d)) cout<<"Yes"<<endl;
        else cout<<"No"<<endl;
    }
    return 0;
}

2. 集合

传送门

#include <iostream>
using namespace std;
const int MAX_N = 100000+10;
int a,b,p;
int primes[MAX_N],cnt,ans;
bool notPrimes[MAX_N];
int fa[MAX_N];
int find(int x){
    if(x!=fa[x]) fa[x]=find(fa[x]);
    return fa[x];
}
void unionSet(int x,int y){
    int xx=find(x),yy=find(y);
    if(xx==yy) return;  /* 原本属于一个集合 */
    --ans;
    fa[xx]=yy;
}
int main(){
    std::ios::sync_with_stdio(false);
    cin>>a>>b>>p;
    for(int i=1;i<=b;i++) fa[i]=i;
    for(int i=2;i<=b;i++){
        if(!notPrimes[i]) primes[++cnt]=i;
        for(int j=1;j<=cnt&&primes[j]*i<=b;++j){
            notPrimes[primes[j]*i]=true;
            if(i%primes[j]==0) break;
        }
    }
    ans=b-a+1;
    for(int i=1;i<=cnt;++i){
        if(primes[i]<p) continue;
        int np=(a+primes[i]-1)/primes[i]*primes[i];
        for(int j=np+primes[i];j<=b;j+=primes[i]) unionSet(np,j);
    }
    cout<<ans<<endl;
    return 0;
}

3. 【模板】最小生成树

传送门

prim算法模板：

#include <iostream>
#include <algorithm>
using namespace std;
const int MAX_M=200005;
const int MAX_N=5005;
const int inf=123456789;
struct node{
    int v,w,next;
}e[MAX_M<<1];
int head[MAX_N],dis[MAX_N],cnt,n,m,tot,now=1,ans;
bool vis[MAX_N];
int u,v,w;
/* 建边 */
void add_edge(int u,int v,int w){
    e[++cnt].v=v;
    e[cnt].w=w;
    e[cnt].next=head[u];
    head[u]=cnt;
}
int prim(){
    for(int i=2;i<=n;i++) dis[i]=inf;
    for(int i=head[1];i;i=e[i].next) dis[e[i].v]=min(dis[e[i].v],e[i].w);
    while(++tot<n){
        int min_n=inf;
        vis[now]=true;
        for(int i=1;i<=n;i++){
            if(!vis[i]&&min_n>dis[i]){
                min_n=dis[i];
                now=i;
            }
        }
        ans+=min_n;
        for(int i=head[now];i;i=e[i].next){
            int v=e[i].v;
            if(dis[v]>e[i].w&&!vis[v]) dis[v]=e[i].w;
        }
    }
    return ans;
}
int main(){
    ios::sync_with_stdio(false);
    cin>>n>>m;
    for(int i=1;i<=m;i++){
        cin>>u>>v>>w;
        add_edge(u,v,w),add_edge(v,u,w);
    }
    cout<<prim();
    return 0;
}

prim堆优化：

#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAX_N=5005;
const int MAX_M=200005;
int k,n,m;
int cnt,sum,head[MAX_N],dis[MAX_N],vis[MAX_N];
int u,v,w;
struct node
{
    int v,w,next;
}e[MAX_M<<1];
void add_edge(int u,int v,int w)
{
    e[++k].v=v;
    e[k].w=w;
    e[k].next=head[u];
    head[u]=k;
}
typedef pair <int,int> pii;
priority_queue <pii,vector<pii>,greater<pii> > q; /* 小根堆 */
void prim()
{
    dis[1]=0;
    q.push(make_pair(0,1));
    while(!q.empty()&&cnt<n)
    {
        int d=q.top().first,u=q.top().second;
        q.pop();
        if(vis[u]) continue;
        cnt++;
        sum+=d;
        vis[u]=1;
        for(int i=head[u];i;i=e[i].next)
            if(e[i].w<dis[e[i].v])
                dis[e[i].v]=e[i].w,q.push(make_pair(dis[e[i].v],e[i].v));
    }
}
int main()
{
    memset(dis,127,sizeof(dis));
    memset(head,0,sizeof(head));
    scanf("%d %d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        add_edge(u,v,w);
        add_edge(v,u,w);
    }
    prim();
    if (cnt==n)printf("%d",sum);
    else printf("orz");
}

Kruskal算法：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAX_N=5005;
const int MAX_M=2000005;
int n,m,tot;
int f[MAX_M>>1];
struct node{
    int u,v,w;
}e[MAX_M];
int ans;
int find(int x){
    if(x!=f[x]) f[x]=find(f[x]);
    return f[x];
}
bool cmp(node a,node b){
    return a.w<b.w;
}
void kruskal(){
    for(int i=1;i<=m;i++){
        int u=find(e[i].u);
        int v=find(e[i].v);
        if(u==v) continue;	/* 如果两个在同一个集合了，就等待下一个循环 */
        ans+=e[i].w;
        f[u]=v;	/* 连接两个集合 */
        tot++;
        if(tot==n-1) break;
    }
}
int main(){
    ios::sync_with_stdio(false);
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        f[i]=i;
    }
    for(int i=1;i<=m;i++) cin>>e[i].u>>e[i].v>>e[i].w;
    sort(e+1,e+m+1,cmp);
    kruskal();
    if(tot==n-1){
        cout<<ans;
    }else
        cout<<"orz";
    return 0;
}

4. 村村通

传送门

#include <iostream>
using namespace std;
const int MAX_N=1e6+5;
int fa[MAX_N],n,m,x,y;
int find(int x){
    if(x!=fa[x])
        fa[x]=find(fa[x]);
    return fa[x];
}
void unionSet(int x,int y){
    fa[find(x)]=find(y);
}
int main(){
    ios::sync_with_stdio(false);
    while(true){
        int ans=0;
        scanf("%d%d",&n,&m);
        if(n==0) return 0;
        for(int i=1;i<=n;i++) fa[i]=i;
        for(int i=1;i<=m;i++){
            scanf("%d %d",&x,&y);
            unionSet(x,y);
        }
        for(int i=1;i<=n;i++){
            if(find(i)==i){
                ans++;
            }
        }
        printf("%d\n",ans-1);
    }
    return 0;
}

5. 部落划分

传送门

#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
struct node{
    int u,v;
    double w;
    friend bool operator<(const node &x,const node &y){
        return x.w<y.w;
    }
}e[1000005];
int n,k,fa[1005],tot;
double nx[1005],ny[1005],ans,sum;
bool flag=0;
int find(int x){
    if(x!=fa[x]) fa[x]=find(fa[x]);
    return fa[x];
}
bool unionSet(int x,int y){
    int xx=find(x);
    int yy=find(y);
    if(xx!=yy){
        sum++;
        fa[xx]=yy;
        return true;
    }
    return false;
}
double cal(double x1,double y1,double x2,double y2){
    return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
}
void kruskal(){
    for(int i=1;i<=tot;i++){
        if(sum==n-k) flag=1;
        if(unionSet(e[i].u,e[i].v)&&flag){
            ans=e[i].w;
            return;
        }
    }
}
int main(){
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++){
        scanf("%lf %lf",&nx[i],&ny[i]);
    }
    for(int i=1;i<=n;i++){
        fa[i]=i;
        for(int j=1;j<i;j++){
            e[++tot].u=i;
            e[tot].v=j;
            e[tot].w=cal(nx[i],ny[i],nx[j],ny[j]);
        }
    }
    sort(e+1,e+tot+1);
    kruskal();
    printf("%.2lf\n",ans);
    return 0;
}

6. 团伙

传送门

#include <iostream>
using namespace std;
const int MAX_N = 1005;
int n,m,a,b,fa[MAX_N<<1],ans;
char ch;
int find(int x){
    if(x!=fa[x]) fa[x]=find(fa[x]);
    return fa[x];
}
void unionSet(int x,int y){
    int xx=find(x);
    int yy=find(y);
    fa[xx]=yy;
}
int main(){
    cin>>n>>m;
    for(int i=1;i<=2*n;i++){
        fa[i]=i;
    }
    for(int i=1;i<=m;i++){
        cin>>ch>>a>>b;
        if(ch=='F') unionSet(a,b);
        else{
            unionSet(a+n,b);
            unionSet(b+n,a);
        }
    }
    for(int i=1;i<=n;i++){
        if(fa[i]==i){
            ans++;
        }
    }
    cout<<ans;
    return 0;
}

7. 关押罪犯

传送门

#include <iostream>
#include <algorithm>
using namespace std;
const int MAX_N=100005;
int n,m;
struct node{
    int u,v,w;
    friend bool operator<(const node &x,const node &y){
        return x.w>y.w;
    }
}f[MAX_N];
int fa[MAX_N<<1],enemy[MAX_N<<1];
int find(int x){
    if(x!=fa[x]) fa[x]=find(fa[x]);
    return fa[x];
}
void unionSet(int x,int y){
    int xx=find(x);
    int yy=find(y);
    fa[xx]=yy;
}
bool check(int x,int y){
    if(find(x)==find(y)) return true;
    return false;
}
int main(){
    cin.tie(0),cout.tie(0);
    cin>>n>>m;
    for(int i=1;i<=n;i++) fa[i]=i;
    for(int i=1;i<=m;i++) cin>>f[i].u>>f[i].v>>f[i].w;
    sort(f+1,f+m+1);
    for(int i=1;i<=m+1;i++){
        if(check(f[i].u,f[i].v)){
            cout<<f[i].w;break;
        }else{
            if(!enemy[f[i].u]) enemy[f[i].u]=f[i].v;
            else unionSet(enemy[f[i].u],f[i].v);
            if(!enemy[f[i].v]) enemy[f[i].v]=f[i].u;
            else unionSet(enemy[f[i].v],f[i].u);
        }
    }
    return 0;
}

8. [NOI2001] 食物链

传送门

#include <iostream>
using namespace std;
inline int read() {
    char c = getchar(); int n = 0;
    while (c < '0' || c > '9') { c = getchar(); }
    while (c >= '0' && c <= '9') { n = (n << 1) + (n << 3) + (c & 15); c = getchar(); }
    return n;
}
const int MAX_N=100005;
int n,m,ans,fa[MAX_N*3];
int find(int x){
    if(x!=fa[x]) fa[x]=find(fa[x]);
    return fa[x];
}
void unionSet(int x,int y){
    int xx=find(x);
    int yy=find(y);
    if(xx==yy) return;
    fa[xx]=yy;
}
int main(){
    n=read();m=read();
    for(int i=1;i<=n*3;i++) fa[i]=i;
    while(m--){
        int opt=read(),u=read(),v=read();
        if(u>n||v>n){
            ans++;
            continue;
        }
        if(opt==1){
            if(find(u+n)==find(v)||find(u)==find(v+n)) ans++;
            else unionSet(u,v),unionSet(u+n,v+n),unionSet(u+n+n,v+n+n);
        }else{
            if(find(u)==find(v)||find(u)==find(v+n)) ans++;
            else unionSet(u+n,v),unionSet(u+n+n,v+n),unionSet(u,v+n+n);
        }
    }
    printf("%d\n",ans);
    return 0;
}
DeeGLMath
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
并查集+最小生成树（prim+kruskal）
qq_39535750的博客
08-04 1214
并查集 并查集，从名字上来看可以知道，是一个集合，而且这个集合可以合并和查询。查询，主要是查询集合中的某一个元素的祖先是谁，某一些元素是不是拥有相同的祖先。合并，是把两个不想交的集合合并为一个集合。 并查集的思想就是朋友的朋友就是朋友（虽然现实生活中并不是这样）。 并查集的第一步初始化，自己是自己的祖先。一个人来到一个陌生的环境谁也不认识，自己的小团体里只有自己一个人。 for （int ...
生成树和最小生成树
jiqiren1994的博客
09-13 2607
一、生成树和最小生成树简介 生成树（Spanning Tree）：在无向连通图中，生成树是将图中所有顶点以 最少的边 连通的子图。 • 图必须是无向连通图，非连通图和有向图都没有生成树的概念 • 生成树是一个连通子图，是给定图的一个子集，它连接了所有节点且没有环 • 生成树不止一种，生成树含有图中全部n个顶点，以及包含图中n-1条边 最小生成树（Minimum Spanning Tree，MST ）：生成树中，边的权值和最小，是“最小权重生成树”的简称。 二、关键边和伪关键边 关键边：如果从图中删去某条边，
并查集——最小生成树算法Kruskal
长期更新Java自学笔记
07-05 1597
连通图： 在无向图中，若任意两个顶点ViV_iVi​和VjV_jVj​都有路径相通，则称该无向图为连通图强连通图： 在有向图中，若任意两个顶点ViV_iVi​和VjV_jVj​都有路径相通，则称该有向图为强连通图连通网： 在连通图中，若图的边具有一定的意义，每一条边都对应着一个数，称为权值，权值代表着连接各个顶点的代价，称这种连通图叫做连通网生成树： 一个连通子图，它包含连通图中全部n个顶点，有n-1条边。如果生成树中再添加一条边，则必定成环最小生成树： 在连通网的所有生成树中，所有边的代价之和最小的生成树
【数据结构】 并查集和最小生成树
Hello World!
03-23 3363
并查集(Union-Find)是一种用来判断一个集合中相互关联的元素属于几个集合，也可以用来判断图结构中的两点是否是连通, 它也是一种树型的数据结构，用于处理一些不相交集合(Disjoint Sets)的合并及查询问题。简而言之，并查集就是合并集合或者在集合里查找元素的算法，可求连通子图、求最小生成树等。
并查集+最小生成树（Kruskal算法）
qq_51699436的博客
06-02 783
并查集 并查集常用于解决一些元素分组问题,管理一系列不相交的集合,主要操作如下: 初始化 将所有节点的祖先初始化为其本身: //初始化祖先节点,par[i]为i点的父节点,n为节点数量 void init(){ for(int i=1;i<=n;i++){ par[i]=i; } return ; } 查询 查找祖先节点并且状态压缩,减小复杂度: int seek(int i){ if(par[i]==i)//若i点的父节点为它本身时,则i点为祖先节点
并查集及优化与最小生成树的两种算法
rwbyblake的博客
06-03 565
虽然名叫“最小生成树”，但这个算法实际是图论分类下的。 我们先来回忆一下树和图的结构都是什么： 树：每一个节点有且仅有一个父节点，拥有数量可以为零的子节点数，便是一个树形结构，如下图： 图：每一个节点都可以和任意个数节点相连，如下图： 但这两种结构并不是水火不相容的结构，我们可以看到如果我们将图结构中的某一些边去掉，就可以将其变成一颗树结构： 那么本篇博客的内容已经呼之欲出了：将一个带权图通过算法进行边的选择，使最后的图成为具有树结构的连通图，且边的权值为最小的树，我们将它成为最小生成树。 最小生成树
最小生成树与次小生成树
等我，等我变的更好就去找你
06-08 339
题意：给出两个不同方案，每个方案使得所有的城堡被连通（形成连通图），同时使边权之和尽量小，问第一个方案与第二个方案的大小关系。 解题思路： 因为m个桥能使n个城堡联通，而两个大爷的方案中至少存在一个桥不相同，那么我们判断这是一个求次小生成树的方法。 求次小生成树模板： https://blog.csdn.net/alice_991/article/details/48225949 枚举+...
并查集与最小生成树 原理讲解、c++代码
10-13
并查集与最小生成树 原理讲解、c++代码。 并查集是⼀一种树型的数据结构，⽤用于处理理⼀一些不不相交集合的合并及查询问题。 一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，...
并查集、最小生成树、最短路.pdf
07-26
"并查集、最小生成树、最短路.pdf" 并查集、最小生成树、最短路是计算机科学中的三个重要概念，广泛应用于图论、算法设计和软件开发等领域。下面，我们将对这三个概念进行详细的解释和分析。 一、并查集（Union-...
最小生成树（用堆+并查集进行优化）
12-02
图的最小生成树算法，用堆+并查集进行优化。
最小生成树算法及实例.zip
05-14
最小生成树算法及实例.zip
最小生成树&并查集
12-28
介绍并查集与最小生成树的简单应用，刚开始就在纠结，明明知道是最小生成树，但是代码写不出来
Kruscal算法+并查集 求解最小生成树
yuanlanjun
02-16 125
http://ac.jobdu.com/problem.php?id=1347 孤岛连通工程 刚开始的时候使用qsort排序函数进行排序提交一直都是TLE，后来无意中改为sort排序函数提交就AC了，真是太神奇了。。。 #include&lt;iostream&gt; #include&lt;algorithm&gt; using namespace std; #include&lt;s...
并查集——最小生成树
qq_46121425的博客
07-21 568
先来了解一下什么叫最小生成树 定义：一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。 通俗的说就是一个能连通所有点且不形成回路的无向图。 再来讲一下求最小生成树的原理 一个图是联通的当且仅当该图上的任意两点相互可达，那我们就可以选取一个点作为所有点的祖先（根），祖先相同的两点必然相互可达。 开始时每个点的祖先都是它自己，已连通的点数为 1 ，每添加一条新边时，判断两端点的祖先是否相同，如不同，则令两点祖先统一，且连通的点数+1，当已连通的点
并查集-算法详解及例题(最小生成树问题)
Gaoithe的博客
06-01 1008
一、并查集的概念： 并查集（Union-find Sets）是一种非常精巧而实用的数据结构，它主要用于处理一些不相交集合的合并问题。一些常见的用途有求连通子图、求最小生成树的 Kruskal 算法和求最近公共祖先（Least Common Ancestors, LCA）等。 使用并查集时，首先会存在一组不相交的动态集合 S={S1,S2,⋯,Sk}S={S1,S2,⋯,Sk}，一般都会使用一...
NOIP2010 关押罪犯（最大生成树）
weixin_30263277的博客
09-22 125
描述 S城现有两座监狱，一共关押着N名罪犯，编号分别为1~N。他们之间的关系自然也极不和谐。很多罪犯之间甚至积怨已久，如果客观条件具备则随时可能爆发冲突。我们用“怨气值”（一个正整数值）来表示某两名罪犯之间的仇恨程度，怨气值越大，则这两名罪犯之间的积怨越多。如果两名怨气值为c的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并造成影响力为c的冲突事件。 每年年末，警察...
codevs1069 关押罪犯（二分图判定+二分答案）
又菜又爱玩
01-13 347
连接：http://codevs.cn/problem/1069/ 题意： 将n名犯人分成两部分，只有处在同一部分中的罪犯之间会产生冲突， 问通过划分所能得到的最大的一组冲突（两个犯人之间） 的最小值。 思路： 因为候选答案集合具有单调性，所以可以考虑二分答案。 假设mid为当前可以产生的最大值，那么凡是相互矛盾<=mid 的犯人可以待在一...
搜索算法（DFS,BFS等）
林景的博客
08-12 1164
文章目录搜索算法及练习题1. 搜索算法概述2. 宽度优先搜索（Breadth First Search,BFS）2.1 Robot in Maze2.2 Yet Another Multiple Problem2.3 马的遍历2.4 Fire!3. 深度优先搜索（Depth First Search,DFS）3.1 八皇后问题3.2 迷宫3.3 奇怪的电梯3.4 [NOIP2017 提高组] 奶酪3.5 [USACO05DEC]Scales S3.6 油田（连通块）4. 剪枝4.1 小木棍 ［数据加强版]4
采用kruskal算法生成最小生成树，并采用并查集的合并优化和查询优化。
最新发布
03-16
Kruskal算法是一种生成最小生成树的算法，它的基本思想是将所有边按照权值从小到大排序，然后依次加入到生成树中，如果加入一条边会形成环，则不加入该边，直到生成树中有n-1条边为止。而并查集的合并优化和查询优化...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

DeeGLMath

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值