二分图'最大匹配' HK 算法

重要的事->//直接摘抄了博客中的内容。->原博客点我

求二分图最大匹配——Hopcroft-Krap算法

本文是对二分图大讲堂这篇文章中Hopcroft-Krap算法代码实现的详细注释。

下面一段话来自上面一博客* 该段话很重要orz(ToT)/~~~

Hopcroft-Karp算法实现

下面的实现有详细的注释，该算法还是不完美，每次调用searchP()值保留了一个最小的dis值（为什么是最小，因为其是BFS遍历，当同一层次有一个v满足My[v]==-1时，dis就附上相应的层次值），也就是在长度大于dis的层在本次调用时再遍历下去，只能是下次调用searchP()查找，花了好几个小时去理解。

通过上面的分析，易知searchP()是没有遍历层次大于dis的层，也就是说没有把长度大于dis增广路径是没有找到的。当然这样做的好处——防止出现相交的增广路径。

还有个要知道的是dis在下面这个算法中的值只可能是从1逐渐增加偶数变大的，所以这样做是不可能在一次searchP()调用之后DFS出现相交的增广路径的（一定只会是长度小的那个增广路径）。

 

 

HK算法的基本原理

Hopcroft-Karp算法先使用BFS查找多条增广路，然后使用DFS遍历增广路（累加匹配数，修改匹配点集），循环执行，直到没有增广路为止。
Hopcroft-Karp算法的BFS遍历只对点进行分层（不标记是匹配点和未匹配点），然后用DFS遍历看上面的层次哪些是增广路径（最后一个点是未匹配的）。
BFS过程可以看做是图像树结构一样逐层向下遍历，还要防止出现相交的增广路径。

二分图大讲堂中给出了HK算法步骤的通俗解释

设U和V是图G的二分图，M是从U到V的匹配
(1)使用BFS遍历对图的点进行分层，从X中找出一个未匹配点v,（所有v)组成第一层，接下的层是这样形成的——都是查找匹配点（增广路性质），直到在V中找到未匹配点才终止查找，对X其他未匹配点同样进行查找增广路径（BFS只分层不标记是否匹配点）
(2)使用DFS遍历查找(1)形成的增广路，找到就匹配数就累加1
(3)重复(1)(2)操作直到找不出增广路径为止

而二分图最大匹配之Hopcroft-Karp算法里给了比较学术化的步骤，有兴趣可以看一下

// 匈牙利算法时间复杂度O(V*E)  HK复杂度O(sqrt(V)*E)

// 附匈牙利代码

#include<cstdio>
using namespace std;
const int MAXN = 1000+5;
const int MAXM = 3000+5;

int num;
int head[MAXN];
struct node {
    int v, next;
} edge[MAXN*MAXM];

inline void add(int x, int y) {
    edge[num].v = y;
    edge[num].next = head[x];
    head[x] = num++;
}

int n, m;
int nm[MAXN];

int love[MAXM];
bool vis[MAXM];
bool dfs(int u) {
    for(int i = head[u]; i != -1; i = edge[i].next) {
        int v = edge[i].v;
        if(!vis[v]) {
            vis[v] = true;
            if(!love[v] || dfs(love[v])) {
                love[v] = u;
                return true;
            }
        }
    }
    return false;
}

bool solve() {
    for(int i = 1; i <= m; ++i) love[i] = 0;
    for(int i = 1; i <= n; ++i) {
        for(int j = 1; j <= m; ++j) vis[j] = false;
        if(nm[i] && !dfs(i)) return false;
    }
    return true;
}

int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; ++i) head[i] = -1;
        int p;
        for(int i = 1; i <= n; ++i) {
            scanf("%d", &nm[i]);
            for(int j = 0; j != nm[i]; ++j) {
                scanf("%d", &p);
                add(i, p);
            }
        }
        if(solve()) printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

// hdu 1083 HK算法(非典型例题 匈牙利也能做)

#include<cstdio>
#include<cstring>
#include<queue>
#define INF 0x3f3f3f3f
using namespace std;

const int MAXN = 100+5;
const int MAXM = 300+5;

int p, n;
int a[MAXN][MAXM];

int dis;
int cx[MAXN], cy[MAXM];
int dx[MAXN], dy[MAXM];
bool vis[MAXM];

bool bfs_findPath() {
    queue<int> q;
    memset(dx, -1, sizeof(dx));
    memset(dy, -1, sizeof(dy));
    // 使用BFS遍历对图的点进行分层，从X中找出一个未匹配点v
    // (所有v)组成第一层，接下来的层都是这样形成——每次查找
    // 匹配点(增广路性质)，直到在Y中找到未匹配点才停止查找，
    // 对X其他未匹配点同样进行查找增广路径(BFS只分层不标记
    // 是否匹配点)
    // 找出X中的所有未匹配点组成BFS的第一层
    dis = INF;
    for(int i = 1; i <= p; ++i) {
        if(cx[i] == -1) {
            q.push(i);
            dx[i] = 0;
        }
    }
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        if(dx[u] > dis) break;// 该路径长度大于dis，等待下一次BFS扩充
        for(int v = 1; v <= n; ++v) {
            if(a[u][v] && dy[v] == -1) {// (u,v)之间有边且v还没有分层
                dy[v] = dx[u] + 1;
                if(cy[v] == -1) dis = dy[v];// v是未匹配点，停止延伸（查找）,得到本次BFS的最大遍历层次
                else {// v是已匹配点，继续延伸
                    dx[cy[v]] = dy[v] + 1;
                    q.push(cy[v]);
                }
            }
        }
    }
    return dis != INF;// 若dis为INF说明Y中没有未匹配点，也就是没有增广路径了
}

bool dfs(int u) {
    for(int v = 1; v <= n; ++v) {
        if(!vis[v] && a[u][v] && dy[v] == dx[u] + 1) {
            vis[v] = 1;
            // 层次（也就是增广路径的长度）大于本次查找的dis
            // 是bfs中被break的情况，也就是还不确定是否是增广路
            // 只有等再次调用bfs再判断(每次只找最小增广路集)
            if(cy[v] != -1 && dy[v] == dis) continue;
            if(cy[v] == -1 || dfs(cy[v])) {// 是增广路径，更新匹配集
                cy[v] = u;
                cx[u] = v;
                return true;
            }
        }
    }
    return false;
}

int HK() {
    int ans = 0;
    memset(cx, -1, sizeof(cx));
    memset(cy, -1, sizeof(cy));
    while(bfs_findPath()) {// 有增广路
        memset(vis, 0, sizeof(vis));
        for(int i = 1; i <= p; ++i) {
            // 用DFS查找增广路径，增广路径一定从未匹配点开始
            // 如果查找到一个增广路径，匹配数加一
            if(cx[i] == -1 && dfs(i)) ++ans;
        }
    }
    return ans;
}

int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        scanf("%d%d", &p, &n);
        memset(a, 0, sizeof(a));

        for(int i = 1; i <= p; ++i) {
            int nm, x;
            scanf("%d", &nm);
            for(int j = 0; j != nm; ++j) {
                scanf("%d", &x);
                a[i][x] = 1;
            }
        }
        printf("%s\n", HK() == p ? "YES" : "NO");
    }
    return 0;
}