二分图匹配(最小顶点覆盖,多重二分图匹配)

最新推荐文章于 2021-10-27 19:52:33 发布
最新推荐文章于 2021-10-27 19:52:33 发布
阅读量560 收藏 1
点赞数
分类专栏： 二分图匹配
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41183791/article/details/81215084
版权

二分图匹配:

最基础的一题:http://acm.hdu.edu.cn/showproblem.php?pid=2063

匈牙利算法的核心是使用used[],每次完成一个选取者的搜索前需要重置used[]

利用used[i]=1和found(boy[i]),来让已经选择了的点绕开这次需要选择的点

 input:

4 3 3

1 1

1 2

2 3

3 1

模拟算法:

1选1    boy[1]=1;

2选3    boy[3]=2;

3想选1    used[1]=1;发现boy[1]=1,尝试found(boy[1]),

found(1),想选1,但是used[1]=1;所以只能绕开它,选择其它的,发现可以选择2(used[2]=0)且boy[2]=0;

boy[2]=1;return 1,然后可以boy[3]=1;

#include<stdio.h>
#include<string.h>
int line[510][510];///矩阵保存关系
int boy[510];
int used[510];
int n,m;
                                      ///*2和*3模拟能否绕开选取
int found(int x)
{
    int i,j;
    for(i=1;i<=m;i++)                 ///遍历所有被选者的编号
    {
        if(line[x][i]==1&&used[i]==0) ///如果 x对i有好感且在这一个阶段选取阶段没有被选取(||假设选取)*1
        {                             
            used[i]=1;                  ///标记被选取(看其它的能否绕开这个选择)*2
            if(boy[i]==0||found(boy[i]))///如果被选者没有归属或他的归属着可以调换
            {                          
                boy[i]=x;                ///将归属定为 x
                return 1;
            }
        }
    }
    return 0;
}
 
int main()
{
    int i,j,k,x,y,sum;
    while(scanf("%d %d %d",&k,&n,&m),k!=0)
    {
       memset(line,0,sizeof(line));
       memset(boy,0,sizeof(boy));
       memset(used,0,sizeof(used));
       for(i=0;i<k;i++)
       {
          scanf("%d %d",&x,&y);
          line[x][y]=1;
       }
       sum=0;          
       for(i=1;i<=n;i++)///遍历选取者
       {
           memset(used,0,sizeof(used));///每次都要清 0
           if(found(i)) sum++;         
       }
       printf("%d\n",sum);
    }
    return 0;
}

邻接表模板:

#include<bits/stdc++.h>
#define MAXN 100005
using namespace std;
vector<int> vc[MAXN];
int boy[510];
int used[510];
int n,m;

int found(int x)
{
    for(int i=0;i<vc[x].size();i++){
        int v=vc[x][i];
        if(used[v]==0){
            used[v]=1;
            if(boy[v]==0||found(boy[v])){
                boy[v]=x;
                return 1;
            }
        }
    }
    return 0;
}

int main()
{
    int k,x,y,sum;
    while(scanf("%d %d %d",&k,&n,&m),k!=0)
    {
        for(int i=0;i<MAXN;i++)
            vc[i].clear();
        memset(boy,0,sizeof(boy));
        memset(used,0,sizeof(used));
        for(int i=0;i<k;i++)
        {
            scanf("%d%d",&x,&y);
            vc[x].push_back(y);
        }
        sum=0;
        for(int i=1;i<=n;i++)///遍历选取者
        {
            memset(used,0,sizeof(used));///每次都要清 0
            if(found(i))
            sum++;
        }
        printf("%d\n",sum);
    }
    return 0;
}

最小顶点覆盖数:

Muddy Fields

用宽度为1长度不限的木板将水洼‘*’盖住而不盖住草‘.'

用匈牙利算法求最大匹配数,需要自己建图

最小覆盖点数=最大匹配数

横着盖：（图中数字表示用的是第几块木板）,rx为至少的横板数

1.2.

.333

444.

. . 5.

竖着盖：ry为至少的竖板数

1.2.

.324

532.

. . 2.

rx与ry匹配

AC:

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#define MAXN 3005
using namespace std;
char s[MAXN][MAXN];
int r[MAXN][MAXN],c[MAXN][MAXN];
int mp[MAXN][MAXN];
int boy[MAXN],used[MAXN];
int rx,ry;

int found(int x)
{
    for(int i=1;i<=ry;i++){//ry第二种匹配物的个数
        if(mp[x][i]==1&&used[i]==0){
            used[i]=1;
            if(boy[i]==0||found(boy[i])){
                boy[i]=x;
                return 1;
            }
        }
    }
    return 0;
}

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        scanf("%s",s[i]+1);
    rx=0,ry=0;
    for(int i=1;i<=n;i++){//建图
        for(int j=1;j<=m;j++){
            if(s[i][j]=='*'){
                ++rx;
                while(j<=m&&s[i][j]=='*')
                    r[i][j]=rx,j++;
                j=j-1;
            }
        }
    }
    for(int j=1;j<=m;j++){
        for(int i=1;i<=n;i++){
            if(s[i][j]=='*'){
                ++ry;
                while(i<=n&&s[i][j]=='*')
                    c[i][j]=ry,i++;
                i=i-1;
            }
        }
    }
    for(int i=1;i<=n;i++){//建边
        for(int j=1;j<=m;j++){
            if(s[i][j]=='*'){
                mp[r[i][j]][c[i][j]]=1;
            }
        }
    }
    int ans=0;
    for(int i=1;i<=rx;i++)//第一种匹配物个数
    {
        memset(used,0,sizeof(used));
        if(found(i))
            ans++;
    }
    printf("%d\n",ans);
    return 0;
}

POJ - 3041

求最少需要几枪可以击碎所以小行星->求该图的最小顶点覆盖数

3 4               out:2
1 1
1 3
2 2
3 2

由König定理定理可知，二分图的最小顶点覆盖数等于二分图的最大匹配数

ac:

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#define MAXN 100005
using namespace std;
vector<int> vc[MAXN];
int boy[510];
int used[510];
int n,m;

int found(int x)
{
    for(int i=0;i<vc[x].size();i++){
        int v=vc[x][i];
        if(used[v]==0){
            used[v]=1;
            if(boy[v]==0||found(boy[v])){
                boy[v]=x;
                return 1;
            }
        }
    }
    return 0;
}

int main()
{
    int k,x,y,sum;
    while(scanf("%d %d",&n,&k)!=EOF)
    {
        for(int i=0;i<MAXN;i++)
            vc[i].clear();
        memset(boy,0,sizeof(boy));
        memset(used,0,sizeof(used));
        for(int i=0;i<k;i++)
        {
            scanf("%d%d",&x,&y);
            vc[x].push_back(y);
        }
        sum=0;
        for(int i=1;i<=n;i++)///遍历选取者
        {
            memset(used,0,sizeof(used));///每次都要清 0
            if(found(i))
            sum++;
        }
        printf("%d\n",sum);
    }
    return 0;
}

多重二分图匹配:

Jamie's Contact Groups

题意:

n个人,m个通讯录

给定每个人可以去若干个通讯录

求所以通讯录中人数的最大值的最小情况

解析:

最大求最小

二分+二分图多重匹配

ac:

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#define MAXN 1005
using namespace std;
int n,m,mid,x;
char str[20];
int vis[MAXN];
vector<int> vc[MAXN],isin[MAXN];
 
bool Find(int u)
{
    int len=vc[u].size();
    for(int i=0;i<len;i++)
    {
        int v=vc[u][i];
        if(!vis[v])
        {
            vis[v]=1;
            int blen=isin[v].size();
            if(blen<mid)//可以装
            {
                isin[v].push_back(u);
                return 1;
            }
            for(int j=0;j<blen;j++)
            {
                if(Find(isin[v][j]))
                {
                    isin[v][j]=u;
                    return 1;
                }
            }
        }
    }
    return 0;
}
 
bool maxmatch()
{
    for(int i=0;i<m;i++)
        isin[i].clear();
    for(int i=0;i<n;i++)
    {
        memset(vis,0,sizeof(vis));
        if(!Find(i))
            return 0;//匹配不了,出结果
    }
    return 1;
}
 
int main()
{
    while(~scanf("%d%d",&n,&m)&&(n+m))
    {
        for(int i=0;i<=n;i++)
            vc[i].clear();
        for(int i=0;i<n;i++)
        {
            scanf("%s",str);
            while(scanf("%d",&x)==1)
            {
                vc[i].push_back(x);
                if(getchar()=='\n') break;
            }
        }
        int l=1,r=n,ans=n;
        while(l<=r)//二分找最小
        {
            mid=(l+r)>>1;
            if(maxmatch())
            {
                r=mid-1;
                ans=mid;
            }
            else l=mid+1;
        }
        printf("%d\n",ans);
    }
    return 0;
}

输入数据包含多组测试用例，每组数据的第一行输入n,表示男生的数量，接下来有n行,每行n个数表示第i个女生对第j个男生的好感度(n<=300)

模板代码:

#include<iostream>//slack:匹配
#include<algorithm>//match:松弛
#include<cstring>//gap:差距
#include<cstdio>
#define inf 0x3f3f3f3f
using namespace std;
 
int n;
int love[301][301];
int vis_girl[301],vis_boy[301];
int ex_girl[301],ex_boy[301];
int match[301],slack[301];
 
int dfs(int x)
{
    vis_girl[x]=1;
    for(int i=0;i<n;i++)
    {
        if(vis_boy[i]) continue;
        int gap=ex_girl[x]+ex_boy[i]-love[x][i];
        if(!gap){
            vis_boy[i]=1;
            if(match[i]==-1||dfs(match[i])){
                match[i]=x;
                return 1;
            }
        }
        else slack[i]=min(slack[i],gap);
    }
    return 0;
}
 
void km()
{
    memset(match,-1,sizeof(match));
    memset(ex_boy,0,sizeof(ex_boy));
    for(int i=0;i<n;i++)
    {
        ex_girl[i]=love[i][0];
        for(int j=1;j<n;j++)
            ex_girl[i]=max(ex_girl[i],love[i][j]);
    }
 
    for(int i=0;i<n;i++)
    {
        fill(slack,slack+n,inf);
        while(1){
            memset(vis_boy,0,sizeof(vis_boy));
            memset(vis_girl,0,sizeof(vis_girl));
            if(dfs(i)) break;
            int d=inf;
            for(int j=0;j<n;j++)
                if(!vis_boy[j]) d=min(d,slack[j]);
            for(int j=0;j<n;j++){
                if(vis_girl[j]) ex_girl[j]-=d;
                if(vis_boy[j]) ex_boy[j]+=d;
                else slack[j]-=d;
            }
        }
    }
    int res=0;
    for(int i=0;i<n;i++)
        res+=love[match[i]][i];
    printf("%d\n",res);
}
 
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                scanf("%d",&love[i][j]);
        km();
    }
    return 0;
}

 

Tao_oc
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二分图大讲堂——彻底搞定最大匹配数（最小覆盖数）、最大独立数、最小路径覆盖、带权最优匹配...
qiudesuo的专栏
10-04 1479
二分图大讲堂——彻底搞定最大匹配数（最小覆盖数）、最大独立数、最小路径覆盖、带权最优匹配 文本内容框架： §1图论点、边集和二分图的相关概念和性质 §2二分图最大匹配求解 匈牙利算法、Hopcroft-Karp算法 §3二分图最小覆盖集和最大独立集的构造 §4二分图最小路径覆盖求解 §5二分图带权最优匹配求解 Kuhn-Munkers算法 §6小结 每章节都...
二分图大合集——二分图最大匹配（最小覆盖数），完美匹配以及最优匹配（带权最大匹配）
热门推荐
ling_wang的博客
04-06 4万+
二分图： 定义：二分图又称作二部图，是图论的一种特殊模型。设G=(V, E)是一个无向图，如果顶点V可分割为两个互不相交的子集（A , B），且图中的每条边（i, j）所关联的两个定点分别属于这两个不同的顶点集（i in A, j in B），则称图G为一个二分图。 简单的说，一个图被分成了两部分，相同的部分没有边，那这个图就是二分图，二分图是特殊的图。（不含奇环） 由定义可知，二分图没有自...
poj2226（最小顶点覆盖）
gronkie的博客
10-27 372
（相当于是poj3041的进阶版，不过难度还好） 题目大概意思为将一个矩阵中的泥泞部分给覆盖起来，可以横着覆盖也可以竖着覆盖，但不能覆盖到其他草地部分，覆盖的板子长度随意，宽度为1，可以重复覆盖，求最少需要的板子数量 解题思路：把板子当成图的顶点，把泥泞的点当作连接对应板子（一个横着的，一个竖着的）的边，这样转化之后，求最少需要的板子数量，即相当于我们对于任意边，都至少需要一个该边的端点，即转为成了求最小顶点覆盖问题。 由于所有的泥泞的点，连接的都是横着的和竖着的，所以这是二分图，在二分图中，|最小顶点覆盖
Muddy Fields POJ - 2226（最小点覆盖）
rainbowsea_1的博客
05-20 189
Muddy Fields POJ - 2226 Rain has pummeled the cows’ field, a rectangular grid of R rows and C columns (1 <= R <= 50, 1 <= C <= 50). While good for the grass, the rain makes some patches of bare earth quite muddy. The cows, being meticulous graz
poj 2226
weixin_30691871的博客
09-01 126
Muddy Fields Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 13386 Accepted: 4923 Description Rain has pummeled the cows' field, a rectangular grid of R...
大班图论第8,11次作业1
08-03
- 对于正则二分图，即每个顶点度数相同的二分图，可以进行边着色。如果图的最小度数为δ，我们可以为边进行δ着色，使得每个顶点的所有邻接边颜色都不同。这可以通过匈牙利算法实现，确保存在一个完备匹配，即每个...
数学建模-11.8-11.11 图论算法的相关课件.zip
05-03
在二分图中，最大匹配可以转化为求最大流问题，Kuhn-Munkres算法（也称Kuhn算法或KM算法）是解决这个问题的有效手段。 最后，我们还会接触到图的染色问题，比如四色定理，它表明任何平面图都可以用四种颜色进行染色...
ACM学习资料-图论专题的内容
08-13
在ACM中，图论的应用广泛，主要包括最短路径问题、最小生成树、拓扑排序、二分图匹配等。例如，Dijkstra算法和Floyd-Warshall算法是解决单源最短路径问题的常用方法；Prim和Kruskal算法则用于寻找图的最小生成树，以...
常用算法 (2).pdf
03-28
1. **二分图匹配**：匈牙利算法解决二分图的完美匹配问题。 2. **最小路径覆盖**：寻找图中最小的边集合，使得所有顶点至少包含一条路径。 3. **网络流**：最大流量问题，如最大流最小割定理。 4. **最小费用流**：...
图论练习题
11-01
标题"图论练习题"暗示了这是一个包含一系列关于图论问题的练习集，可能涵盖了各种类型的图论问题，例如最短路径、最小生成树、拓扑排序、网络流、二分图匹配、染色问题、欧拉路径和哈密顿回路等。这些题目旨在帮助...
POJ2226
Yedl的专栏
07-02 747
题意：给定一个矩阵,其中有一些地方有水,现在有一些长度任意,宽为1的木板，要求在所有板不跨越任何坑的前提下，用一些木板盖住这些有水的地方,问至少需要几块板子？ 思路：      然后你们懂的，二分匹配好了。 代码如下： #include #include #include #include using namespace std; const int N = 600; int n,
【poj2226】Muddy Fields 二分图
DQS的树洞
03-02 1008
DescriptionRain has pummeled the cows’ field, a rectangular grid of R rows and C columns (1 <= R <= 50, 1 <= C <= 50). While good for the grass, the rain makes some patches of bare earth quite muddy. T
poj 2226 二分图匹配
sky_zdk的博客
04-01 380
#include #define N 1000 int map[N][N],vis[N],match[N]; int R,C,nx=0,ny=0; int dfs(int x) { int i; for(i=1;i<=ny;i++) { if(!vis[i]&&map[x][i]) { vis[i]=1; if(match[i]==-1||dfs(match[i]))
二分图的最大匹配和最小点覆盖问题
wanwandebaba的博客
12-30 965
最大匹配： 首先写一下我自己对最大匹配的理解，首先举个找对象的例子，这个例子在我计算机科学中的数学基础的老师龙环的课上讲过，就是男女分成两部分，一个男的喜欢多个女的，一个女的也可以喜欢多个男的，这时候我们要找出能够匹配出最大对数的方法，这个就是最大匹配。 求最大匹配的算法就是匈牙利算法很简单的递归算法，就是对于每个男生，扫描他所中意的女生，若是那个女生没有匹配对象的话，我们就直接
poj 3041 Asteroids (最小点覆盖)
happy_lcj
10-07 800
题意：有一个n*n的矩阵,在矩阵上有m个行星,一个武器可以消灭同一行或者同一列的星星 求最小的要用多少武器消灭所有的星星 思路：把方阵看做一个特殊的二分图（以行列分别作为两个顶点集V1、V2，其中|V1|=|V2|） 然后把每行x或者每列y看成一个点，而障碍物(x,y)可以看做连接x和y的边。按照这种思路建图，问题就转化成为选择最少的一些
POJ 2226 Muddy Fields（二分匹配【最大流】）
Re-moved
07-28 261
150行样例~ 欢迎test
poj2226 二分图经典建图求最小点覆盖
喵 喵 喵~
08-31 419
题意：：给出一个N行M列的图，’*’代表稀泥，’.’代表草地，现在要用一些木板把所有的稀泥盖住，但是不能盖住草地。一张木板只能盖住一行或者一列中的一部分，求至少要用多少木板把所有的稀泥盖住。 把横向连续的点压在一起作为L，把列向连续的点压在一起作为R，如果两者有交集，就从L到R连一条边。求最小点覆盖(==最大匹配数) #include &lt;cstdio&gt; #include &lt;c...
POJ题单 二分图
qq_26518655的博客
09-11 145
POJ题单 二分图 文章目录POJ题单 二分图Asteroids POJ - 3041题目思路代码Antenna Placement POJ - 3020题目思路代码总结 Asteroids POJ - 3041 题目 思路 就是很套路的做法，把每一个点拆成横坐标和纵坐标两个点，然后连线得到一张二分图，如果要消灭所有的星星，其实就是在二分图中选出若干个点能包含所有的边，有一个定理就是二分图最小点覆盖=最大匹配，跑一次hungary就行了 代码 #include <cstdio> #includ
并查集(POJ1988)
liuzhan214的博客
07-14 2367
Language: Cube Stacking Time Limit: 2000MS Memory Limit: 30000K Total Submissions: 23340 Accepted: 8182 Case Time Limit: 1000MS Description Farmer John and Betsy are playing a game with N (1 <
基于匈牙利算法的二分图匹配模型
最新发布
05-02
基于匈牙利算法的二分图匹配模型是一种经典的图论算法，它用于解决二分图最大匹配问题。在二分图中，将所有顶点分为两个集合，如果一个顶点属于集合A，则与之相连的所有顶点都属于集合B。二分图匹配的目标是找到尽可能多的边，使得每个顶点都与一条边相连。 匈牙利算法是一种基于增广路的贪心算法，它通过寻找增广路来不断增加匹配数。具体实现过程是从一个未匹配顶点开始，寻找增广路，如果能找到一条增广路，则将路径上的边加入匹配中，否则终止算法。 下面是基于匈牙利算法的二分图匹配模型的具体实现过程： 1. 对所有未匹配顶点进行遍历，找到一个未匹配顶点 2. 以该顶点为起点，使用深度优先搜索或广度优先搜索寻找增广路 3. 如果找到了增广路，则将路径上的边加入匹配中，否则终止算法

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值