最小生成树 & 二分图

一、最小生成树

大纲

对应的图都是无向图。

1. 普利姆（$Prim$）算法
   1. 朴素版（稠密图） $O(n^2)$
   2. 堆优化版（稀疏图） $O(mlogn)$ (不常用)
2. 克鲁斯卡尔（$Kruskal$）算法 （稀疏图） $O(mlogm)$

1、朴素版$Prim$算法

/集合s表示当前在连通块中的所有点
dist[i] <- +∞
for(i=0;i<n;i++){
	t <- 找到集合外距离最近的点
    用t来更新其他点到集合的距离
    st[t]=true //把t加入集合中去
}

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

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

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

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

输入格式

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

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

输出格式

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

数据范围

1≤n≤500
1≤m≤10^5
图中涉及边的边权的绝对值均不超过 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,INF,sizeof dist);
    
    int res=0;//存储最小生成树中边的长度之和
    for(int i=0;i<n;i++){//n次循环
        int t=-1;
        for(int j=1;j<=n;j++){//从1~n号点遍历
            if(!st[j] && (t==-1 || dist[t]>dist[j]))
                t=j;
        }   
        //此时t中存储的是 不在树内且距离最小的点
        
        if(i && dist[t]==INF) return INF;//如果不是第一个点且与树之间无边，则图不连通，无最小生成树
        
        if(i) res+=dist[t];//如果这个点不是第一个点，则总边权更新
        //需要在用t更新之前进行这一步操作，否则更新之后dist[t]改变，例如有自环，后续的g[t][t]可能<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,INF,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;
}

2、$Kruskal$算法

1、所有边按照权重从小到大排序（快排）    O(mlogm)
2、从小到大枚举每条边ab，权重c
    if 当前ab不连通
        将这条边加入集合 //并查集

给定一个 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≤10^5,
1≤m≤2∗10^5,
图中涉及边的边权的绝对值均不超过 10001000。

输入样例：

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 Edge{
    int a,b,w;

    bool operator< (const Edge &W)const{//重载运算符<
        return w<W.w;
    }
}edges[N];

int find(int x){
    if(p[x]!=x) p[x]=find(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;//最小生成树的边权之和
    int cnt=0;//当前加入了多少条边
    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);//a,b等于各自的祖宗节点

        if(a != b){
            p[a]=b;//两个集合合并
            res+=w;
            cnt++;
        }
    }

    if(cnt<n-1) puts("impossible");//如果最终的边数小于n-1，则未连通所有的点，图不连通
    else printf("%d\n",res);

    return 0;

}

二、二分图

大纲

1. 染色法 $O(m+n)$
2. 匈牙利算法 最坏：$O(mn)$ 实际运行时间一般远小于$O(mn)$

1、染色法判断一个图是否是二分图

一个图是二分图当且仅当图中不含奇数环

for(i=1;i<=n;i++){
	if i未染色
        dfs(i,1)//1表示颜色
}

2、匈牙利算法

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

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

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

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

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

输入格式

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

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

输出格式

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

数据范围

1≤n1,n2≤500,
1≤u≤n1,
1≤v≤n2,
1≤m≤10^5

输入样例：

2 2 4
1 1
1 2
2 1
2 2

输出样例：

2

#include<iostream>
#include<algorithm>
#include<cstring>
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;//这个点与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;
}