无权二分图的最大匹配

最新推荐文章于 2023-11-12 22:18:30 发布

2016cxg

最新推荐文章于 2023-11-12 22:18:30 发布

阅读量290

点赞数

分类专栏：图论

本文链接：https://blog.csdn.net/qq_33785671/article/details/76585560

版权

图论专栏收录该内容

21 篇文章 0 订阅

订阅专栏

//poj2063
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std ;

/*
交替路：从一个未匹配节点出发，依次经过未匹配边，匹配边，未匹配边，匹配边，形成的路径是交替路
增广路：从一个未匹配节点处罚，走交替路，如果途径另一个未匹配节点，则这条路就是增广路
*/ 


//匈牙利算法求无权二分图的最大匹配 
//复杂度 O(VE) 
//Linker存储最大匹配的边 

const int MAXN=1000;
//二分图两边点数 
int uN,vN; 
int g[MAXN][MAXN];
int linker[MAXN];
bool used[MAXN];
bool dfs(int u){
    //对于u所连接的边，可能得到一个匹配 
    for(int v=1;v<=vN;v++)
        if(g[u][v]&&!used[v]){
            used[v]=true;
            //如果之前v节点没有匹配，则u的匹配就是边<u,v>，否则，将v之前的匹配撤销，将v之前的匹配的起点重新匹配一个Y节点内的他所连接的另外一个节点，如果不能完成匹配，那么说明u节点不能匹配，那么res就不能+1。注意是回溯的算法，所以在没有完成匹配的时候是不会修改linker数组的，所以linker依旧代表匹配的边 
            //如果发生修改一定会在Y集合里面重新选一个点添加到匹配里面，但是这个点不一定是u所连接的点
            //u能够发生匹配，一定存在u所连接的在Y里面的点之前没有被匹配过（第一个条件），或者u开始有一个增广路（第二个条件） 
            if(linker[v]==-1||dfs(linker[v])){
                //u和v匹配 
                linker[v]=u;
                return true;
            }    
        }  
    return false;  
}    
int hungary(){
    int res=0;
    //对于一个图的左边的点集X和右边的点集Y，linker存储右边的边集的前向点，也就是linker数组保存最大匹配的选中的边 
    memset(linker,-1,sizeof(linker));
    for(int u=1;u<=uN;u++){
        //在线处理，对每个X集合中的点，如果他能得到一个匹配，res+1 
        memset(used,0,sizeof(used));
        //u节点能够得到一个匹配的边 
        if(dfs(u)){
            res++;
        }
    } 
    //最大匹配数 
    return res;   
}

int main(){
    int k , u , v ;
    while( scanf("%d" , & k ) && k ){
        scanf("%d%d" , & uN , & vN ) ;
        memset( g , 0 , sizeof( g )) ;
        while( k -- ){
            scanf("%d%d" , & u , & v ) ;
            g[u][v] = 1;
        }
        printf("%d\n" , hungary() ) ;
    }
    return 0 ;
}

//poj2063
//更快的算法
/**********************************************
二分图匹配（Hopcroft-Carp的算法）。
初始化：g[][]邻接矩阵
调用：res=MaxMatch();  Nx,Ny要初始化！！！
时间复杂大为 O(V^0.5 E)

适用于数据较大的无权二分图最大匹配 
***********************************************/ 

//HopCroft - Carp算法 ： 大数据无权二分图最大匹配
//复杂度 O（sqrt(V) E)
//Mx和My存储最大匹配的边 


#include<iostream>
#include<cstdio> 
#include<cstring>
#include<cmath>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std ;


const int MAXN=500 + 10;
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;   
}

int main(){
    int k , u , v ;
    while( scanf("%d" , & k ) && k ){
        scanf("%d%d" , & Nx , & Ny ) ;
        memset( g , 0 , sizeof( g )) ;
        while( k -- ){
            scanf("%d%d" , & u , & v ) ;
            g[u - 1][v - 1] = 1;
        }
        printf("%d\n" , MaxMatch() ) ;
    }
    return 0 ;
}