二分图的最大匹配以及带权匹配【匈牙利算法+KM算法】

二分图算法包括 匈牙利算法 与 KM算法。

匈牙利算法

在这里写上模板。

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2063

 #include<stdio.h>
 #include<string.h>
 #define mem(a, b) memset(a, b, sizeof(a))

 int head[], cnt;
 int k, m, n; //k为组合数,m为女生人数,n为男生人数
 int used[], master[];

 struct Edge
 {
     int to, next;
 }edge[];

 void add(int a, int b)
 {
     edge[++ cnt].to = b;
     edge[cnt].next = head[a];
     head[a] = cnt;
 }

 int find(int x)
 {
     for(int i = head[x]; i != -; i = edge[i].next)
     {
         int to = edge[i].to;
         if(used[to] == -)
         {
             used[to] = ;
             if(master[to] == - || find(master[to]))
             {
                 master[to] = x;
                 return ;
             }
         }
     }
     return ;
 }

 int main()
 {
     int ans;
     while(scanf("%d", &k)!=EOF)
     {
         if(k == )
             break;
         cnt = ans = ;
         mem(head, -), mem(master, -);
         scanf("%d%d", &m, &n);
         for(int i = ; i <= k; i ++)
         {
             int a, b;
             scanf("%d%d", &a, &b);
             add(a, b);
         }
         for(int i = ; i <= m; i ++)
         {
             mem(used, -);
             if(find(i))
                 ans ++;
         }
         printf("%d\n", ans);
     }
     return ;
 }

KM算法

KM算法是用来解决带权问题的最大匹配. （用邻接矩阵实现, 首先因为带权的话, X部,Y部都有边,一般是稠密图,其次邻接表并不好实现）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2255

 #include<stdio.h>
 #include<string.h>
 #define mem(a, b) memset(a, b, sizeof(a))
 const int inf = 0x3f3f3f3f;

 int n, nx, ny;
 int lx[], ly[];//x部点的值,y部点的值
 int visx[], visy[];//标记x,y部的点是否在相等子图中,用于更新点的值
 int slack[];//松弛量, 用于优化KM算法 优化后复杂度为 n^3
 int goal[], weight[][];

 int find(int x)//新增的x部的点
 {
     visx[x] = ;
     for(int j = ; j <= ny; j ++)
     {
         if(!visy[j])
         {
             int t = lx[x] + ly[j] - weight[x][j]; //匹配到的标准是 x部 + y部点的值等于边权值
             if(t == )
             {
                 visy[j] = ;
                 if(goal[j] == - || find(goal[j]))
                 {
                     goal[j] = x;
                     return ;
                 }
             }
             else if(slack[j] > t)//没被匹配到的点记录最小slack
                 slack[j] = t;
         }
     }
     return ;
 }

 int km()
 {
     mem(ly, ); //y部的初始化为0
     mem(lx, );
     mem(goal, -);
     for(int i = ; i <= nx; i ++)//x部点的值初始化为与y部相连的最大值
         for(int j = ; j <= ny; j ++)
             if(weight[i][j] > lx[i])
                 lx[i] = weight[i][j];
     for(int i = ; i <= nx; i ++)
     {//每次扩充一个点, 都要重新初始化y部的slack,因为需要在相等子图中找到最大的权值匹配
         for(int j = ; j <= ny; j ++)
             slack[j] = inf;
         while()
         {
             mem(visx, );
             mem(visy, );
             if(find(i))  //如果当前子图可以匹配的到就跳出, 扩充下一个x部的点继续匹配
                 break;
             //如果当前子图没匹配到,就用slack更新值再循环while寻找当前子图的最大权值匹配
             int d = inf;
             for(int j = ; j <= ny; j ++)
                 if(!visy[j] && d > slack[j])
                     d = slack[j];//找到一个最小的差值 在未尝试匹配的y部中找
             for(int j = ; j <= ny; j ++)
                 if(!visy[j])
                     slack[j] -= d;
             for(int j = ; j <= n; j ++)//参与匹配的点x部的减 ,y部的加
             {
                 if(visy[j])
                     ly[j] += d;
                 if(visx[j])
                     lx[j] -= d;
             }
         }
     }
     int ans = ;
     for(int j = ; j <= ny; j ++)
         if(goal[j] != -)
             ans += weight[goal[j]][j];
     return ans;
 }

 int main()
 {
     while(scanf("%d", &n)!=EOF)
     {
         nx = n, ny = n;
         for(int i = ; i <= n; i ++)
             for(int j = ; j <= n; j ++)
                 scanf("%d", &weight[i][j]);
         int ans = km();
         printf("%d\n", ans);
     }
     return ;
 }

对于KM算法求最小匹配, 只需要在最大匹配的模板上改动几个地方即可,

在存图时将边权全记为负边权,那么会发现在对lx顶标记录最大值的时候实际上是绝对值最小的负值,也就是最小匹配了. 将lx[]数组初始化为-inf,然后对于最后的答案取负号就可以了.