Hopcroft-Karp算法代码解释:

转载自:https://www.cnblogs.com/penseur/archive/2013/06/16/3138981.html

 #include                                                                                                         
 #include                                                                                                            
 using namespace std;                                                                                                       
 const int MAXN=500;// 最大点数                                                                                             
 const int INF=1<<28;// 距离初始值                                                                                          
 int bmap[MAXN][MAXN];//二分图                                                                                              

 int cx[MAXN];//cx[i]表示左集合i顶点所匹配的右集合的顶点序号                                                                
 int cy[MAXN]; //cy[i]表示右集合i顶点所匹配的左集合的顶点序号                                                               

 int nx,ny;                                                                                                                 
 int dx[MAXN];                //dx,dy是广度搜增广路径时候用来存 距离 左侧未匹配点的距离                                                                                             
 int dy[MAXN];                                                                                                              
 int dis;                     //dis为增广路径的长度                                                                                              
 bool bmask[MAXN];                                                                                                      
 //寻找 增广路径集                                                                                                          
 bool searchpath()                                                                                                          
 {                                                                                                                          
    queue<int>Q;                                                                                                            
    dis=INF;                                                                                                                
    memset(dx,-1,sizeof(dx));                                                                                               
    memset(dy,-1,sizeof(dy));                                                                                               
    for(int i=1;i<=nx;i++)                                                                                                  
    {                                                                                                                       
       //cx[i]表示左集合i顶点所匹配的右集合的顶点序号                                                                       
       if(cx[i]==-1)         //左侧未匹配点进入队列                                                                                               
       {                                                                                                                    
          //将未遍历的节点 入队 并初始化次节点距离为0                                                                       
          Q.push(i);                                                                                                        
          dx[i]=0;                                                                                                          
       }                                                                                                                    
    }                                                                                                                       
    //广度搜索增广路径                                                                                                      
    while(!Q.empty())                                                                                                       
    {                                                                                                                       
       int u=Q.front();                                                                                                     
       Q.pop();                                                                                                             
       if(dx[u]>dis) break;               //dx[u]>dis,因为dis一开始被设为INF,若dx[u]大于dis,则表示已经有增广路径dis了(因为dis肯定是被修改过了才使得dx[u]>dis)                                                                                  
       //取右侧节点                                                                                                         
       for(int v=1;v<=ny;v++)                                                                                               
       {                                                                                                                    
          //右侧节点的增广路径的距离                                                                                        
          if(bmap[u][v]&&dy[v]==-1)      //dy[v]==-1只有v为增广路径未经过的点才进入计算距离                                                                                   
          {                                                                                                                 
             dy[v]=dx[u]+1; //v对应的距离 为u对应距离加1                                                                    
             if(cy[v]==-1) dis=dy[v];                 //cy[v]==-1表示若v为右侧没匹配的点,则当前即是增广路径                                                                      
             else                                                                                                           
             {                                                                                                              
                dx[cy[v]]=dy[v]+1;             //cy[-1]!=-1 表示v已经被匹配了,这时候我们继续搜寻增广路径,并将与v匹配的点cy[v]冲入队列,即增广路径未u-->v-->cy[v]                                                                               
                Q.push(cy[v]);                                                                                              
             }                                                                                                              
          }                                                                                                                 
       }                                                                                                                    
    }                                                                                                                       
    return dis!=INF;               //有增广路径则会修改dis,则不会等于INF                                                                                         
 }                                                                                                                          

 //寻找路径 深度搜索                                                                                                        
 int findpath(int u)                         //由maxmatch知道执行findpath的u肯定是cx[u]=-1的,即未匹配                                                                           
 {                                                                                                                          
    for(int v=1;v<=ny;v++)                                                                                                  
    {                                                                                                                       
       //如果该点没有被遍历过 并且距离为上一节点+1                                                                          
       if(!bmask[v]&&bmap[u][v]&&dy[v]==dx[u]+1)                                                                            
       {                                                                                                                    
          //对该点染色,设置已经经过                                                                                                      
          bmask[v]=1;                                                                                                       
          if(cy[v]!=-1&&dy[v]==dis)    //v已经有匹配,且dy[v]=dis,则dx[cy[v]]=dis+1>dis,此时u-->v--cy[v]肯定不在增广路径上(因为已经超过dis了,而我们是在长度为dis的增广路径)                                                                                   
          {                                                                                                                 
             continue;                                                                                                      
          }                                                                                                                 
          if(cy[v]==-1||findpath(cy[v])) //如果v未匹配 或者 findpath(与v匹配点)返回为真,即可以腾一个位置给它                                                                                   
          {                                                                                                                 
             cy[v]=u;cx[u]=v;                                                                                               
             return 1;                                                                                                      
          }                                                                                                                 
       }                                                                                                                    
    }                                                                                                                       
    return 0;                                                                                                               
 }                                                                                                                          

 //得到最大匹配的数目                                                                                                       
 int MaxMatch()                                                                                                             
 {                                                                                                                          
    int res=0;                                                                                                              
    memset(cx,-1,sizeof(cx));                                                                                               
    memset(cy,-1,sizeof(cy));                                                                                               
    while(searchpath())                                                                                                     
    {                                                                                                                       
       memset(bmask,0,sizeof(bmask));                                                                                       
       for(int i=1;i<=nx;i++)                                                                                               
       {                                                                                                                    
          if(cx[i]==-1)                                                                                                     
          {                                                                                                                 
             res+=findpath(i);                                                                                              
          }                                                                                                                 
       }                                                                                                                    
    }                                                                                                                       
    return res;                                                                                                             
 }                                                                                                                          


 int main()                                                                                                                 
 {                                                                                                                          
    int num;                                                                                                                
    scanf("%d",&num);                                                                                                       
    while(num--)                                                                                                            
    {                                                                                                                       

       memset(bmap,0,sizeof(bmap));                                                                                         
       scanf("%d%d",&nx,&ny);                                                                                               
       for(int i=1;i<=nx;i++)                                                                                               
       {                                                                                                                    
          int snum;                                                                                                         
          scanf("%d",&snum);                                                                                                
          int u;                                                                                                            
          for(int j=1;j<=snum;j++)                                                                                          
          {                                                                                                                 
             scanf("%d",&u);                                                                                                
             bmap[i][u]=1;                                                                                                  
            // bmap[u][i]=1;                                                                                                
          }                                                                                                                 
       }                                                                                                                    
      // cout<
       if(MaxMatch()==nx)                                                                                                   
       {                                                                                                                    
          printf("YES\n");                                                                                                  
       }                                                                                                                    
       else                                                                                                                 
       {                                                                                                                    
          printf("NO\n");                                                                                                   
       }                                                                                                                    
    }                                                                                                                       
    //system("pause");                                                                                                      
    return 0;                                                                                                               
 }  

你可能感兴趣的:(C/C++,算法)