搜索与图论（三）：最小生成树、二分图

最小生成树 

普利姆算法（Prim）：

稠密图：朴素版Prim O(n^2)

例题：Prim算法求最小生成树 

给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环，边权可能为负数。

求最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。

给定一张边带权的无向图 G=(V,E)，其中 V 表示图中点的集合，E 表示图中边的集合，n=|V|，m=|E|

由 V 中的全部 n 个顶点和 E 中 n−1 条边构成的无向连通子图被称为 G 的一棵生成树，其中边的权值之和最小的生成树被称为无向图 G 的最小生成树。

输入格式

第一行包含两个整数 n 和 m。

接下来 m 行，每行包含三个整数 u,v,w表示点 u 和点 v 之间存在一条权值为 w 的边。

输出格式

共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。

数据范围

1≤n≤500
1≤m≤105
图中涉及边的边权的绝对值均不超过 10000

输入样例：

4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4

输出样例：

6

解题代码：

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

using namespace std;

const int N=510,INF=0x3f3f3f3f;

int n,m;
int g[N][N];
int dist[N];
bool st[N];

int prim()
{
    memset(dist,0x3f,sizeof dist);//将距离初始化为无穷
    int res=0;//最小生成树所有边之和
    for(int i=0;i<n;i++)//n次迭代
    {
        int t=-1;
        for(int j=1;j<=n;j++)//每次找到当前集合外的所有点当中距离最小的点
            if(!st[j]&&(t==-1||dist[t]>dist[j]))//必须在集合外并且当前还没找到任何一个点或者当前t的距离大于j的距离
                t=j;
                
        if(i&&dist[t]==INF) return INF;//如果不是第一个点并且距离是无穷大
        
        //dist[t]只要不是第一个点，表示的是当前的点和现在已经连好的生成树里面某一条边的长度，树边
        if(i) res+=dist[t];//只要不是第一个点就加入
        
        //用t来更新一下其他点到集合的距离
        for(int j=1;j<=n;j++) dist[j]=min(dist[j],g[t][j]);
        
        
        st[t]=true;//将解加到集合里去,即加入树里面去了
    }
    
    return res;
}

int main()
{
    scanf("%d%d",&n,&m);
    
    memset(g,0x3f,sizeof g);
    
    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        g[a][b]=g[b][a]=min(g[a][b],c);
    }
    
    int t=prim();
    
    if(t==INF) puts("impossible");
    else printf("%d\n",t);
    
    return 0;
}

稀疏图：堆优化版Prim O(mlogn)（不常用）

克鲁斯卡尔算法（Kruskal）O(mlogm) (稀疏图)

基本思路：

 

例题：Kruskal算法求最小生成树

给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环，边权可能为负数。

求最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。

给定一张边带权的无向图 G=(V,E)，其中 V 表示图中点的集合，E 表示图中边的集合，n=|V|，m=|E|

由 V 中的全部 n 个顶点和 E 中 n−1条边构成的无向连通子图被称为 G 的一棵生成树，其中边的权值之和最小的生成树被称为无向图 G的最小生成树。

输入格式

第一行包含两个整数 n 和 m。

接下来 m 行，每行包含三个整数 u,v,w表示点 u 和点 v 之间存在一条权值为 w 的边。

输出格式

共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。

数据范围

1≤n≤105
1≤m≤2∗105
图中涉及边的边权的绝对值均不超过 1000

输入样例：

4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4

输出样例：

6

解题代码：

 

#include <iostream>
#include <algorithm>

using namespace std;

const int N=200010;

int n,m;
int p[N];

struct Edges
{
    int a,b,w;
    
    bool operator<(const Edges &W)const//按权重排序
    {
        return w<W.w;
    }
}edges[N];

int find(int x)
{
    //并查集模板
    if(p[x]!=x) p[x]=find(p[x]);//如果说怕p[x]不是祖宗节点的话，就一直往上找
    return p[x];
}
int main()
{
    scanf("%d%d",&n,&m);
    
    for(int i=0;i<m;i++)
    {
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
        edges[i]={a,b,w};
    }
    
    sort(edges,edges+m);
    
    for(int i=1;i<=n;i++) p[i]=i;
    
    int res=0,cnt=0;//res最小生成树的所有边权重之和，cnt当前加入多少条边
    for(int i=0;i<m;i++)
    {
        int a=edges[i].a, b=edges[i].b,w=edges[i].w;
        
        a=find(a),b=find(b);//找到祖宗节点
        if(a!=b)//两个祖宗节点不联通
        {
            p[a]=b;//将两集合合并
            res+=w;
            cnt ++;
        }
    }
    
    if(cnt<n-1) puts("impossible");//判断一共加了多少条边
    else printf("%d\n",res);
    
    return 0;
}

二分图

如何判别一个图是不是二分图：染色法 O(n+m)

基本思路：一条边的两个端点染色颜色不能相同

 

例题：染色法判定二分图

给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环。

请你判断这个图是否是二分图。

输入格式

第一行包含两个整数 n 和 m。

接下来 m 行，每行包含两个整数 u 和 v，表示点 u和点 v 之间存在一条边。

输出格式

如果给定图是二分图，则输出 Yes，否则输出 No。

数据范围

1≤n,m≤105

输入样例：

4 4
1 3
1 4
2 3
2 4

输出样例：

Yes

解题代码：

 

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

using namespace std;

const int N=100010,M=200010;//M是边

int h[N],e[M],ne[M],idx;//邻接表存储
int color[N];
int n,m;

void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx ++;
}

bool dfs(int u,int c)
{
    color[u]=c;//记录下当前的颜色
    
    for(int i=h[u];i!=-1;i=ne[i])//从前往后遍历当前点所有的邻点
    {
        int j=e[i];
        if(!color[j])//如果当前点没有染色
        {
            if(!dfs(j,3-c)) return false;
        }
        else if(color[j]==c) return false;
    }
    
    return true;
}

int main()
{
    scanf("%d%d",&n,&m);
    
    memset(h,-1,sizeof h);
    
    while(m--)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b),add(b,a);
    }
    
    //染色
    bool flag=true;
    for(int i=1;i<=n;i++)
        if(!color[i])//如果当前点没有染色
        {
            if(!dfs(i,1))
            {
                flag=false;
                break;
            }
        }
        
    if(flag) puts("Yes");
    else puts("No");
    
    return 0;
}

求二分图的最大匹配：匈牙利算法 O(mn),实际运行时间远小于O(mn)

基本思路:

 

例题:二分图的最大匹配

给定一个二分图，其中左半部包含 n1个点（编号 1∼n1），右半部包含 n2个点（编号 1∼n2），二分图共包含 m 条边。

数据保证任意一条边的两个端点都不可能在同一部分中。

请你求出二分图的最大匹配数。

二分图的匹配：给定一个二分图 G，在 G 的一个子图 M 中，M 的边集 {E}中的任意两条边都不依附于同一个顶点，则称 M 是一个匹配。

二分图的最大匹配：所有匹配中包含边数最多的一组匹配被称为二分图的最大匹配，其边数即为最大匹配数。

输入格式

第一行包含三个整数 n1、 n2和 m。

接下来 m 行，每行包含两个整数 u 和 v，表示左半部点集中的点 u 和右半部点集中的点 v 之间存在一条边。

输出格式

输出一个整数，表示二分图的最大匹配数。

数据范围

1≤n1,n2≤500
1≤u≤n1
1≤v≤n2
1≤m≤105

输入样例：

2 2 4
1 1
1 2
2 1
2 2

输出样例：

2

解题代码：

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

using namespace std;

const int N=510,M=100010;

int n1,n2,m;
int h[N],e[M],ne[M],idx;
int match[N];//妹子点对应的男生点
bool st[N];//防止重复搜索一个点

void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

bool find(int x)//判断该男生找到合适的妹子
{
    for(int i=h[x];i!=-1;i=ne[i])//该男生所有看上的妹子
    {
        int j=e[i];
        if(!st[j])//该妹子之前没考虑过
        {
            st[j]=true;
            if(match[j]==0||find(match[j]))//如果该妹子没有匹配过男生，或者说有匹配的男生，但是这个男生可以找到下家
            {
                match[j]=x;
                return true;
            }
        }
    }
    
    return false;
}

int main()
{
    scanf("%d%d%d",&n1,&n2,&m);
    
    memset(h,-1,sizeof h);
    
    while(m--)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b);
    }
    
    int res=0;//当前匹配数量
    for(int i=1;i<=n1;i++)//依次分析男生该找哪个妹子
    {
        memset(st,false,sizeof st);//把所有妹子清空
        if(find(i)) res++;//找到了妹子了
        
    }
    
    printf("%d\n",res);
    
    return 0;
}