生成树he二分图

1.prime算法
就是迪杰斯特拉的一种类似算法，迪杰斯特拉是求该点到起点的最小值，但是这里是指求到集合的最小值，也就是说，集合中有1,2这两个点，然后e[1,3]=3, e[2,3]=2; 那么就是dist[3]=2;

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


using namespace std;

const int N=503;
int g[N][N];
int n,m;
int dist[N],cnt[N],res;


int prim()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=0;i<n;i++){
        int t=-1;
        for(int j=1;j<=n;j++)
            if(!cnt[j]&&(t==-1||dist[t]>dist[j]))
                t=j; 
        if(i&&dist[t]==0x3f3f3f3f)return 0x3f3f3f3f;
        
        if(i)res+=dist[t];
        cnt[t]=1;
        for(int j=1;j<=n;j++)
            dist[j]=min(dist[j],g[t][j]);
        
    }
    return res;
}
int main(){
    memset(g,0x3f,sizeof g);
    cin.tie(0);
    cin>>n>>m;
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b]=g[b][a]=min(g[a][b],c);
    }
    int k=prim();
    if(k>=0x3f3f3f3f)cout<<"impossible"<<endl;
    else cout<<k<<endl;
}

2.kruskal算法
就是并查集的应用，首先使用结构体存储每一条边，每一个点单独是一个集合，然后将其排序（sort），之后将每一个不连通的点的集合联通，加入边长和边数。

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

using namespace std;

int n,m;
const int N=100010;
int e[N];
struct E{
    int a,b,c;
    bool operator< (const E&k)const{
        return c<k.c;
    }
}ed[2*N];

int find(int a){
    if(e[a]!=a)e[a]=find(e[a]);
    return e[a];
}
int main(){
    cin.tie(0);
    cin>>n>>m;
    int res=0;
    int cnt=0;
    for(int i=0;i<m;i++){
        cin>>ed[i].a>>ed[i].b>>ed[i].c;
    }
    sort(ed,ed+m);
    for(int i=1;i<=n;i++)e[i]=i;
    
    for(int i=0;i<m;i++){
        int a=ed[i].a,b=ed[i].b,c=ed[i].c;
        a=find(a),b=find(b);
        if(a!=b){
            e[a]=b;
            res+=c;
            cnt++;
        }
    }
    if(cnt<n-1)cout<<"impossible"<<endl;
    else cout<<res<<endl;
}

3.染色法判断一个图是不是二分图
就是一个二分图中当且仅当图中没有奇数环，然后就是染色就是第一层是黑色，和黑色点相连的是白色，白色的是黑色，所以染色过程一定不会存在矛盾。

#include<iostream>
#include<cstring>

using namespace std;

const int N=100010;

int h[N],e[2*N],ne[2*N],idx;
int n,m;
int co[N];

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

int dfs(int k,int c){
    co[k]=c;
    int flag=1;
    for(int i=h[k];i!=-1;i=ne[i]){
        int j=e[i];
        if(!co[j]){
            flag=dfs(j,3-c);
            if(!flag)break;
        }
        else if(co[j]==c){
            flag=0;
            return flag;
        }
    }
    return flag;
}
int main(){
    cin.tie(0);
    cin>>n>>m;
    memset(h,-1,sizeof h);
    while(m--){
        int a,b;
        cin>>a>>b;
        add(a,b),add(b,a);
    }
    int k=1;
    for(int i=1;i<=n;i++){
        if(!co[i]){
            k=dfs(i,1);
            if(!k)break;
        }
    }
    if(!k)cout<<"No"<<endl;
    else cout<<"Yes"<<endl;
}

dfs就可以
4.匈牙利算法（二分图的最大匹配）
就是分成左右两边的点，然后只记录从左边指向右边的点，然后我们开始匹配右边的点，如果右边的点已经被匹配就找匹配该点的另一个点，让这个点换一个点匹配。

#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];
int st[N];


void add(int a,int b){
    e[idx]=b;ne[idx]=h[a];h[a]=idx++;
}
int find(int a){
    for(int i=h[a];i!=-1;i=ne[i]){
        int j=e[i];
        if(!st[j]){
            st[j]=1;
            if (match[j] == 0 || find(match[j]))
            {
                match[j] = a;
                return 1;
            }
        }
    }
    return 0;
}
int main(){
    cin.tie();
    cin>>n1>>n2>>m;
    memset(h,-1,sizeof h);
    while(m--){
        int a,b;
        cin>>a>>b;
        add(a,b);
    }
    int res=0;
     for (int i = 1; i <= n1; i ++ )
    {
        memset(st, 0, sizeof st);
        if (find(i)) res ++ ;
    }
    
    cout<<res<<endl;
}