匹配問題總結


1.二分圖

二分圖概念,二分圖判定(dfs,bfs染色),二分圖最大匹配(匈牙利算法(O(M*N)),Hopcroft-Karp算法(O(sqrt(n)*m)),最小點覆蓋,最大獨立集

二分圖相關參考博客:https://www.cnblogs.com/czsharecode/p/9777533.html

對匈牙利算法以及HK算法解析:https://www.cnblogs.com/penseur/archive/2013/06/16/3138981.html

結論總結:

最小路徑覆蓋 = 頂點數最大二分匹配數

相關題目:HDU - 1151 Air Raid(最小路徑覆蓋  GCJ-2009 Round 2C) Stock Charts (最小路徑覆蓋)

最小點覆蓋 = 最大匹配數

無相圖最大匹配數 = 所求 最大匹配數/2 (重邊)

有向圖最大匹配數 = 所求 最大匹配數

相關題目:HDU - 1045 Fire Net (dfs 或 二分圖HDU-1281 棋盤游戲 (二分圖最大匹配

HDU - 1083 Courses (二分圖最大匹配模板HDU-2819 Swap(二分圖最大匹配,路徑記錄

HDU-2389 Rain on your Parade (最大匹配,HK函數

最大獨立集 = 所有頂點數 - 最小頂點覆蓋 = 所有頂點數 -   最大匹配

 (GCJ-2008 Round 3 C) No Cheating(最大獨立集)

匈牙利算法:

//匈牙利算法:(這里用的向前星表示)
//主函數用hungary()獲得最大匹配數
const int maxn = 500;//點數
int
match[maxn];//表示匹配關系(左集合到右集合的匹配)
int vis[maxn];//表示是否被訪問過
//進行匹配
bool Find(int u){ for(int i = head[u]; ~i ;i =edge[i].next){ int v = edge[i].v; if(!vis[v]){ vis[v] = 1; if(!match[v]||Find(match[v])){ match[v] = u; return true; } } } return false; }
//記錄匹配個數

int hungary(){
    int count = 0;
    memset(match,0,sizeof(match));
    for(int i =0;i<=n;i++){
        memset(vis,0,sizeof(vis));
        if(Find(i)) count++;
    }
    return count;
}

 

Hopcroft-Karp算法(HK算法模板)

//主函數種使用HK()即可得到最大匹配個數   

const int INF = 0x3f3f3f3f;
const int maxn = 500;//點數
int bmap[maxn][maxn];//二分圖
int cx[maxn];//左集合i匹配的右集合頂點序號
int cy[maxn];//右集合i匹配的左集合頂點序號                                                                                                                
int n,m;
int dis;
int nx,ny;//左右集合個數
int dx[maxn],dy[maxn];
bool bmask[maxn];
//尋找增廣路徑,HK算法就是從一個點出發想要一次性尋找到多條增廣路徑
//所以使用bfs
 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;                                                                                                 
       //取右側節點                                                                                                         
       for(int v=1;v<=ny;v++)                                                                                               
       {                                                                                                                    
          //右側節點的增廣路徑的距離                                                                                        
          if(bmap[u][v]&&dy[v]==-1)                                                                                         
          {                                                                                                                 
             dy[v]=dx[u]+1; //v對應的距離 為u對應距離加1                                                                    
             if(cy[v]==-1) dis=dy[v];                                                                                       
             else                                                                                                           
             {                                                                                                              
                dx[cy[v]]=dy[v]+1;                                                                                          
                Q.push(cy[v]);                                                                                              
             }                                                                                                              
          }                                                                                                                 
       }                                                                                                                    
    }                                                                                                                       
    return dis!=INF;                                                                                                        
 }                                                                                                                          
                                                                                                                            
 //尋找路徑 深度搜索                                                                                                        
 int findpath(int u)                                                                                                        
 {                                                                                                                          
    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)                                                                                         
          {                                                                                                                 
             continue;                                                                                                      
          }                                                                                                                 
          if(cy[v]==-1||findpath(cy[v]))                                                                                    
          {                                                                                                                 
             cy[v]=u;cx[u]=v;                                                                                               
             return 1;                                                                                                      
          }                                                                                                                 
       }                                                                                                                    
    }                                                                                                                       
    return 0;                                                                                                               
 }                                                                                                                          
                                                                                                                            
 //得到最大匹配的數目                                                                                                       
 int HK()                                                                                                             
 {                                                                                                                          
    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;                                                                                                             
 }

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM