二分图相关知识(来自kuangbin博客)

二分图匹配(匈牙利算法)

1.一个二分图中的最大匹配数等于这个图中的最小点覆盖数

König定理是一个二分图中很重要的定理,它的意思是,一个二分图中的最大匹配数等于这个图中的最小点覆盖数。如果你还不知道什么是最小点覆盖,我也在这里说一下:假如选了一个点就相当于覆盖了以它为端点的所有边,你需要选择最少的点来覆盖所有的边。

2.最小路径覆盖=最小路径覆盖=|G|-最大匹配数

在一个N*N的有向图中,路径覆盖就是在图中找一些路经,使之覆盖了图中的所有顶点,
且任何一个顶点有且只有一条路径与之关联;(如果把这些路径中的每条路径从它的起始点走到它的终点,
那么恰好可以经过图中的每个顶点一次且仅一次);如果不考虑图中存在回路,那么每每条路径就是一个弱连通子集.

路径覆盖与二分图匹配的关系:最小路径覆盖=|G|-最大匹配数;

3.二分图最大独立集=顶点数-二分图最大匹配

独立集:图中任意两个顶点都不相连的顶点集合。

二分图模板:

模板一:匈牙利算法

/* **************************************************************************
//二分图匹配(匈牙利算法的DFS实现)
//初始化:g[][]两边顶点的划分情况
//建立g[i][j]表示i->j的有向边就可以了,是左边向右边的匹配
//g没有边相连则初始化为0
//uN是匹配左边的顶点数,vN是匹配右边的顶点数
//调用:res=hungary();输出最大匹配数
//优点:适用于稠密图,DFS找增广路,实现简洁易于理解
//时间复杂度:O(VE)
//***************************************************************************/
//顶点编号从0开始的
const int MAXN=510;
int uN,vN;//u,v数目
int g[MAXN][MAXN];
int linker[MAXN];
bool used[MAXN];
bool dfs(int u)//从左边开始找增广路径
{
 int v;
 for(v=0;v<vN;v++)//这个顶点编号从0开始,若要从1开始需要修改
 if(g[u][v]&&!used[v])
 {
 used[v]=true;
 if(linker[v]==-1||dfs(linker[v]))
 {//找增广路,反向
 linker[v]=u;
 return true;
 }
 }
 return false;//这个不要忘了,经常忘记这句
}
int hungary()
{
 int res=0;
 int u;
 memset(linker,-1,sizeof(linker));
 for(u=0;u<uN;u++)
 {
 memset(used,0,sizeof(used));
 if(dfs(u)) res++;
 }
 return res;
}
//******************************************************************************/

模板二: Hopcroft-Carp算法

这个算法比匈牙利算法的时间复杂度要小,大数据可以采用这个算法

/* ********************************************* 二分图匹配(Hopcroft-Carp的算法)。 初始化:g[][]邻接矩阵 调用:res=MaxMatch(); Nx,Ny要初始化!!! 时间复杂大为 O(V^0.5 E) 适用于数据较大的二分匹配 需要queue头文件 ********************************************** */
const int MAXN=3000;
const int INF=1<<28;
int g[MAXN][MAXN],Mx[MAXN],My[MAXN],Nx,Ny;
int dx[MAXN],dy[MAXN],dis;
bool vst[MAXN];
bool searchP()
{
    queue<int>Q;
    dis=INF;
    memset(dx,-1,sizeof(dx));
    memset(dy,-1,sizeof(dy));
    for(int i=0;i<Nx;i++)
        if(Mx[i]==-1)
        {
            Q.push(i);
            dx[i]=0;
        }
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        if(dx[u]>dis)  break;
        for(int v=0;v<Ny;v++)
            if(g[u][v]&&dy[v]==-1)
            {
                dy[v]=dx[u]+1;
                if(My[v]==-1)  dis=dy[v];
                else
                {
                    dx[My[v]]=dy[v]+1;
                    Q.push(My[v]);
                }
            }
    }
    return dis!=INF;
}
bool DFS(int u)
{
    for(int v=0;v<Ny;v++)
       if(!vst[v]&&g[u][v]&&dy[v]==dx[u]+1)
       {
           vst[v]=1;
           if(My[v]!=-1&&dy[v]==dis) continue;
           if(My[v]==-1||DFS(My[v]))
           {
               My[v]=u;
               Mx[u]=v;
               return 1;
           }
       }
    return 0;
}
int MaxMatch()
{
    int res=0;
    memset(Mx,-1,sizeof(Mx));
    memset(My,-1,sizeof(My));
    while(searchP())
    {
        memset(vst,0,sizeof(vst));
        for(int i=0;i<Nx;i++)
          if(Mx[i]==-1&&DFS(i))  res++;
    }
    return res;
}
//**************************************************************************/

下面的程序效率很高。是用vector实现邻接表的匈牙利算法。

处理点比较多的效率很高。1500的点都没有问题

/* HDU 1054 用STL中的vector建立邻接表实现匈牙利算法 效率比较高 G++ 578ms 580K */

#include<stdio.h>

#include<iostream>

#include<algorithm>

#include<string.h>

#include<vector>

using namespace std;



//************************************************

const int MAXN=1505;//这个值要超过两边个数的较大者,因为有linker

int linker[MAXN];

bool used[MAXN];

vector<int>map[MAXN];

int uN;

bool dfs(int u)

{

    for(int i=0;i<map[u].size();i++)

    {

        if(!used[map[u][i]])

        {

            used[map[u][i]]=true;

            if(linker[map[u][i]]==-1||dfs(linker[map[u][i]]))

            {

                linker[map[u][i]]=u;

                return true;

            }

        }

    }

    return false;

}

inthungary()

{

    int u;

    int res=0;

    memset(linker,-1,sizeof(linker));

    for(u=0;u<uN;u++)

    {

        memset(used,false,sizeof(used));

        if(dfs(u)) res++;

    }

    return res;

}

//*****************************************************

int main()

{

    int u,k,v;

    int n;

    while(scanf("%d",&n)!=EOF)

    {

        for(int i=0;i<MAXN;i++)

           map[i].clear();

        for(int i=0;i<n;i++)

        {

            scanf("%d:(%d)",&u,&k);

            while(k--)

            {

                scanf("%d",&v);

                map[u].push_back(v);

                map[v].push_back(u);

            }

        }

        uN=n;

        printf("%d\n",hungary()/2);

    }

    return 0;

}

你可能感兴趣的:(二分图相关知识(来自kuangbin博客))