二分图最大匹配小结

最新推荐文章于 2023-12-27 17:59:03 发布

嘉伟森的猫

最新推荐文章于 2023-12-27 17:59:03 发布

阅读量325

点赞数

分类专栏： OI-总结文章标签：算法小结

本文链接：https://blog.csdn.net/KGV093/article/details/78220294

版权

OI-总结专栏收录该内容

26 篇文章 0 订阅

订阅专栏

重要定理：
二分图最小点覆盖=最大匹配
二分图最小边覆盖=|V|-最大匹配
二分图最大独立集=|V|-最大匹配

匈牙利算法（时间复杂度O(V*E)）模板：
DFS：（hdu 1150 最小点覆盖）

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int MAXN=104;
int n,m,k;
bool vis[MAXN<<1];
int mat[MAXN<<1];
int head[MAXN<<1],etot;
struct EDGE {
    int v,nxt;
}e[MAXN*20];
bool dfs(int p) {
    for (int i=head[p];~i;i=e[i].nxt) {
        int v=e[i].v;
        if (!vis[v]) {
            vis[v]=true;
            if (mat[v]==-1||dfs(mat[v])) {
                mat[v]=p;
                return true;
            }
        }
    }
    return false;
}
inline void adde(int u,int v) {
    e[etot].nxt=head[u],e[etot].v=v,head[u]=etot++;
    e[etot].nxt=head[v],e[etot].v=u,head[v]=etot++;
}
int main() {
    while (scanf("%d",&n)&&n) {
        etot=0;
        memset(head,-1,sizeof(head));
        memset(mat,-1,sizeof(mat));
        scanf("%d%d",&m,&k);
        for (int i=0;i<k;++i) {
            int waste,u,v;
            scanf("%d%d%d",&waste,&u,&v);
            adde(u,n+v);
        }
        int max_match=0;
        for (int i=1;i<=n;++i) {
            memset(vis,false,sizeof(vis));
            if (dfs(i)) ++max_match;
        }
        printf("%d\n",max_match);
    }
    return 0;
}

BFS：（从来还没用过。。。）（转自此处）

queue<int> Q;
int prev[__maxNodes];
int Hungarian()
{
    int ans = 0;
    memset(matching, -1, sizeof(matching));
    memset(check, -1, sizeof(check));
    for (int i=0; i<num_left; ++i) {
        if (matching[i] == -1) {
            while (!Q.empty()) Q.pop();
            Q.push(i);
            prev[i] = -1; // 设 i 为路径起点
            bool flag = false; // 尚未找到增广路
            while (!Q.empty() && !flag) {
                int u = Q.front();
                for (iterator_t ix = G[u].begin(); ix != G[u].end() && !flag; ++ix) {
                    int v = edges[*ix].to;
                    if (check[v] != i) {
                        check[v] = i;
                        Q.push(matching[v]);
                        if (matching[v] >= 0) { // 此点为匹配点
                            prev[matching[v]] = u;
                        } else { // 找到未匹配点，交替路变为增广路
                            flag = true;
                            int d=u, e=v;
                            while (d != -1) {
                                int t = matching[d];
                                matching[d] = e;
                                matching[e] = d;
                                d = prev[d];
                                e = t;
                            }
                        }
                    }
                }
                Q.pop();
            }
            if (matching[i] != -1) ++ans;
        }
    }
    return ans;
}