zoukankan      html  css  js  c++  java
  • 匹配问题总结

    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;                                                                                                             
     }
  • 相关阅读:
    懒懒的~~
    BigDecimal,注解
    遇到的一点问题些
    npm一点点
    TortoiseSvn问题研究(一)
    关于maven-基本
    HttpServletRequest二三事
    学习迭代1需求分析
    FMDB简单使用
    计算机中的事务、回滚
  • 原文地址:https://www.cnblogs.com/Tianwell/p/11338055.html
Copyright © 2011-2022 走看看