图论2(最小生成树&染色法&匈牙利)

 最小生成树

最小生成树是一副连通加权无向图中一棵权值最小的生成树。

在一给定的无向图G = (V, E) 中，(u, v) 代表连接顶点 u 与顶点 v 的边，而 w(u, v) 代表此边的权重，若存在 T 为 E 的子集，且 (V, T) 为树，使得

的 w(T) 最小，则此 T 为 G 的最小生成树。最小生成树其实是最小权重生成树的简称。一个连通图可能有多个生成树。当图中的边具有权值时，总会有一个生成树的边的权值之和小于或者等于其它生成树的边的权值之和。广义上而言，对于非连通无向图来说，它的每一连通分量同样有最小生成树，它们的并被称为最小生成森林。

引自维基百科

朴素版prim算法(稠密图)

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

using namespace std;

const int N=520,inf=0x3f3f3f3f;
int g[N][N];
int dis[N];
bool vis[N];
int n,m;

int prim()
{
    memset(dis,0x3f,sizeof dis);
    int res=0;
    
    for(int i=0;i<n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
            if(!vis[j]&&(t==-1||dis[j]<dis[t]))
                 t=j;
                 
        if(i&&dis[t]==inf) return inf;
        if(i) res+=dis[t];
        vis[t]=1;
        
        for(int j=1;j<=n;j++) dis[j]=min(dis[j],g[t][j]);
    }
    return res;
}

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

Kruskal(基于并查集)

#include <iostream>
#include <algorithm>

using namespace std;

const int N=2e5+10;
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,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);
        if(a!=b)
        {
            p[a]=b;
            res+=w;
            cnt++;
        }
    }
    
    if(cnt<n-1) printf("impossible\n");//小于n-1条边入集合，不存在最小生成树
    else printf("%d\n",res);
    
    return 0;
}

二分图

二分图定义(百度百科)

染色法判定二分图

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

using namespace std;

const int N=1e5+5;
int h[N],ne[N*2],e[N*2],idx;
int color[N];
int n,m;

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

bool dfs(int u,int c)  //u表示节点，c表示颜色
{
    color[u]=c;
    
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(color[j]==-1)//没有染色
        {
            if(!dfs(j,!c)) return false;  //染另一种颜色
        }
        else if(color[j]==c) return false; //已经染上色，但是颜色矛盾
    }
    return true;
}

int main()
{
    scanf("%d%d",&n,&m);
    
    memset(h,-1,sizeof h);
    memset(color,-1,sizeof color);
    
    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]==-1)
        {
            if(!dfs(i,1))
            {
                flag=false;
                break;
            }
        }
    }
    if(flag) puts("Yes");
    else puts("No");
    return 0;
}

匈牙利算法(求二分图的最大匹配)

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

using namespace std;

const int N=510,M=1e5+5;
int h[N],e[M],ne[M],idx;  //只需要看左边的情况
int match[N];  //存储右边集合与左边集合的匹配点
int n1,n2,m;
bool vis[N];  //右边点是否已经被匹配

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

bool find(int u)
{
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!vis[j])
        {
            vis[j]=true;
            if(match[j]==0||find(match[j])) //以此枚举，若未匹配，或已匹配的点还有其他匹配
            {
                match[j]=u;
                return true;
            }
        }
    }
    return false;
}

int main()
{
    memset(h,-1,sizeof h);
    scanf("%d%d%d",&n1,&n2,&m);
    
    while(m--)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b);
    }
    
    int res=0;
    for(int i=1;i<=n1;i++)
    {
        memset(vis,0,sizeof vis);
        if(find(i)) res++;
    }
    printf("%d\n",res);
    
    return 0;
}