二分图匹配问题合集

最新推荐文章于 2024-05-29 16:48:11 发布
最新推荐文章于 2024-05-29 16:48:11 发布
阅读量1.3k 收藏 4
点赞数 2
分类专栏： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/monochrome00/article/details/82693248
版权

定理1（Konig 定理）：最小点覆盖数 = 最大匹配数

点覆盖：点集合使得任意一条边至少有一个端点在集合中。

定理2：最大独立集 = 顶点数 - 最大匹配数

独立集：点集合中任何两个顶点都不互相连接。

定理3：最小路径覆盖数 = 顶点数 – 最大匹配数

路径覆盖：任何一个点都属于且仅属于一条路径。

HDU - 1045 - Fire Net

题目链接<http://acm.hdu.edu.cn/showproblem.php?pid=1045>

题意：

给出一张图，‘X’代表墙，‘.’ 代表空地。在空地上放一些炮塔，炮塔不能处在同一行同一列，除非被墙隔开。问最多能放多少个炮塔。

题解：

这题其实可以二进制暴力模拟去做，但也可以用二分图来做。

考虑不存在墙的情况，那么可以把行和列当作两边的点，中间放炮塔当作边，进行二分图匹配即可。换句话说，就是把每一列缩成一点，每一行缩成一点。

如果存在墙，墙的两侧其实就相当于是两个互不相关的点。而对于一个联通串（即中间不存在墙），由于只能放一个炮台的特性，所以相当于一个点。

那么就首先从列出发，对每一列的联通串缩点并染色。然后从行出发同样的对联通串缩点，并与所染色的对应列联通串连边。最后进行二分图匹配即可。

#include<bits/stdc++.h>
using namespace std;
const int N=1e3+7;
struct Edge{
    int u,v,w,nxt;
    Edge(int u=0,int v=0,int w=0,int nxt=0):u(u),v(v),w(w),nxt(nxt){}
}e[N*2];
int p[N],edn;
void add(int u,int v,int w){
    e[++edn]=Edge(u,v,w,p[u]);p[u]=edn;
    e[++edn]=Edge(v,u,w,p[v]);p[v]=edn;
}
int match[N],vis[N];
int n,m;
bool dfs(int u){
    for(int i=p[u];~i;i=e[i].nxt){
        int v=e[i].v;
        if(vis[v]) continue;
        vis[v]=1;
        if(match[v]==-1||dfs(match[v])){
            match[v]=u;
            return true;
        }
    }
    return false;
}
char mp[N][N],col[N][N];
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF){
        if(n==0) break;
        memset(match,-1,sizeof(match));
        memset(p,-1,sizeof(p));edn=-1;
        for(int i=1;i<=n;i++)
            scanf("%s",mp[i]+1);
        int top=1;
        for(int j=1;j<=n;j++){
            for(int i=1;i<=n;i++){
                if(mp[i][j]=='X') top++;
                else col[i][j]=top;
            }
            top++;
        }
        top=1;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(mp[i][j]=='X') top++;
                else add(top,col[i][j]+100,1);
            }
            top++;
        }
        int ans=0;
        for(int i=1;i<=top;i++){
            memset(vis,0,sizeof(vis));
            if(dfs(i)) ans++;
        }
        printf("%d\n",ans);
    }
    return 0;
}

HDU - 2819 - Swap

题目链接<http://acm.hdu.edu.cn/showproblem.php?pid=2819>

题意：

给出一张01矩阵，要求交换若干行若干列后使得主对角线全为1。并输出交换次数和过程。

题解：

根据线代的知识可以得知，只需考虑交换行就行。那么把行列当作点，1当作边，做一个二分图最大匹配。如果匹配书等于n那么就满足。

开一个a[i]数组记录现在第i行放的是初始的第几行。b[i]数组记录初始的第i行现在放在第几行。从头到尾扫一遍，逐一放进匹配行，记录一下交换顺序即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e3+7;
struct Edge{
    int v,nxt;
    Edge(int v=0,int nxt=0):v(v),nxt(nxt){}
}e[N*N*2];
int n,tmp;

int p[N],edn;
void add(int u,int v){
    e[++edn]=Edge(v,p[u]);p[u]=edn;
}
int vis[N],match[N];
bool dfs(int u){
    for(int i=p[u];~i;i=e[i].nxt){
        int v=e[i].v;
        if(vis[v]) continue;
        vis[v]=1;
        if(match[v]==-1||dfs(match[v])){
            match[v]=u;
            return true;
        }
    }
    return false;
}
int pr[N][2];
int a[N],b[N];
int main(){
    while(scanf("%d",&n)!=EOF){
        memset(p,-1,sizeof(p));edn=-1;
        memset(match,-1,sizeof(match));
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                scanf("%d",&tmp);
                if(tmp) add(i,j);
            }
        }
        int ans=0;
        for(int i=1;i<=n;i++){
            memset(vis,0,sizeof(vis));
            if(dfs(i)) ans++;
        }
        if(ans==n){
            int cnt=0;
            for(int i=1;i<=n;i++) a[i]=i,b[i]=i;
            for(int i=1;i<=n;i++){
                if(match[i]!=a[i]){
                    cnt++;
                    pr[cnt][0]=i;
                    pr[cnt][1]=b[match[i]];
                    swap(b[a[i]],b[match[i]]);
                    swap(a[i],a[pr[cnt][1]]);
                }
            }
            printf("%d\n",cnt);
            for(int i=1;i<=cnt;i++){
                printf("R %d %d\n",pr[i][0],pr[i][1]);
            }
        }
        else printf("-1\n");
    }
}

【HK算法模板】HDU - 2389 - Rain on your Parade

题目链接<http://acm.hdu.edu.cn/showproblem.php?pid=2389>

题意：

二维平面上m个人和n把伞，一把伞只能给一个人。每个人都有自身的速度，问规定时间t内最多有几个人能拿到伞。

(1 <=t <= 5；1 <= m <= 3000；1 <= n <= 3000)

题解：

典型的二分图，人和伞作点，能在规定时间到的连一条边。

但这题的范围比较大。匈牙利算法的复杂度是O(VE)，肯定会超时。

而Hopcroft-Carp适用于多点的情况，复杂度为O(sqrt(V)E)，这样就能过了。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=3e3+7;
const int M=1e7+7;
const int inf=1<<28;
struct Edge{
    int v,nxt;
    Edge(int v=0,int nxt=0):v(v),nxt(nxt){}
}e[M];
int p[N],edn;
void add(int u,int v){
    e[++edn]=Edge(v,p[u]);p[u]=edn;
}
int mx[N],my[N],dx[N],dy[N],dis,n,m;
bool vis[N];
bool bfs(){
    queue<int>q;
    dis=inf;
    memset(dx,-1,sizeof(dx));
    memset(dy,-1,sizeof(dy));
    for(int i=0;i<n;i++){
        if(mx[i]==-1){
            q.push(i);
            dx[i]=0;
        }
    }
    while(!q.empty()){
        int u=q.front();
        q.pop();
        if(dx[u]>dis)  break;
        for(int i=p[u];~i;i=e[i].nxt){
            int v=e[i].v;
            if(dy[v]==-1){
                dy[v]=dx[u]+1;
                if(my[v]==-1) dis=dy[v];
                else{
                    dx[my[v]]=dy[v]+1;
                    q.push(my[v]);
                }
            }
        }
    }
    return dis!=inf;
}
bool dfs(int u){
    for(int i=p[u];~i;i=e[i].nxt){
        int v=e[i].v;
        if(!vis[v]&&dy[v]==dx[u]+1){
            vis[v]=1;
            if(my[v]!=-1&&dy[v]==dis) continue;
            if(my[v]==-1||dfs(my[v])){
                my[v]=u;
                mx[u]=v;
                return 1;
            }
       }
    }
    return 0;
}
int hk(){
    int res=0;
    memset(mx,-1,sizeof(mx));
    memset(my,-1,sizeof(my));
    while(bfs()){
        memset(vis,0,sizeof(vis));
        for(int i=0;i<n;i++){
            if(mx[i]==-1&&dfs(i)) res++;
        }
    }
    return res;
}
struct Node{
    int x,y,z;
}a[N],b[N];
int main(){
    int t,cs=0,lim;
    scanf("%d",&t);
    while(t--){
        memset(p,-1,sizeof(p));edn=-1;
        scanf("%d",&lim);
        scanf("%d",&n);
        for(int i=0;i<n;i++)
            scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].z);
        scanf("%d",&m);
        for(int i=0;i<m;i++)
            scanf("%d%d",&b[i].x,&b[i].y);
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if((a[i].x-b[j].x)*(a[i].x-b[j].x)+(a[i].y-b[j].y)*(a[i].y-b[j].y)<=lim*a[i].z*lim*a[i].z){
                    add(i,j);
                }
            }
        }
        printf("Scenario #%d:\n%d\n\n",++cs,hk());
    }
}

HDU - 4185 - Oil Skimming

题目链接<http://acm.hdu.edu.cn/showproblem.php?pid=4185>

题意：

一张n*n的二维图，由‘#’和‘.’构成。要求用尽可能多的1*2的矩形去覆盖‘#’，矩形内不能含有‘.’，问最多能覆盖多少个矩形。

注意：这题的n没有题面说的那么大。

题解：

每一个‘#’就是一个点，相邻的‘#’互相连接。由于只与相邻的连接，所以肯定是二分图，跑一边就行了。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e3+7;
const int inf=1<<28;
struct Edge{
    int v,nxt;
    Edge(int v=0,int nxt=0):v(v),nxt(nxt){}
}e[N*4];
int p[N],edn;
void add(int u,int v){
    e[++edn]=Edge(v,p[u]);p[u]=edn;
}
char s[N][N];
int mp[N][N];
int vis[N],match[N];
bool dfs(int u){
    for(int i=p[u];~i;i=e[i].nxt){
        int v=e[i].v;
        if(vis[v]) continue;
        vis[v]=1;
        if(match[v]==-1||dfs(match[v])){
            match[v]=u;
            return true;
        }
    }
    return false;
}
int dir[4][2]={1,0,-1,0,0,1,0,-1};
int main(){
    int t,cs=0,n;
    scanf("%d",&t);
    while(t--){
        memset(p,-1,sizeof(p));edn=-1;
        memset(match,-1,sizeof(match));
        memset(mp,0,sizeof(mp));
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
            scanf("%s",s[i]+1);
        int top=0;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(s[i][j]=='#') mp[i][j]=++top;
            }
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(mp[i][j]){
                    for(int k=0;k<4;k++){
                        int di=i+dir[k][0];
                        int dj=j+dir[k][1];
                        if(mp[di][dj]){
                            add(mp[i][j],mp[di][dj]);
                        }
                    }
                }
            }
        }
        int ans=0;
        for(int i=1;i<=top;i++){
            memset(vis,0,sizeof(vis));
            if(dfs(i)) ans++;
        }
        printf("Case %d: %d\n",++cs,ans/2);
    }
}

【二分图染色判断奇环】Codeforces - 557D - Vitaly and Cycle

题目链接<http://codeforces.com/problemset/problem/557/D>

题意：

在一张无向图中，最少添加多少边，能使得图包含奇环（存在一个环包含奇数个数的点）。并计算出有多少种添边的方案。

题解：

对于本题可以分情况讨论

1）如果图中本身就没有边，那么可以任选三个点连3条边。一共有\binom{n}{2}种方案。

2）如果图中本身就存在奇环，那么答案就是0 1。

关于奇环的判断可以利用黑白染色的进行搜索，如果一条边连了两个同色的那么就存在奇环。

如果不存在奇环，该图就是个二分图。而二分图也分了两种情况。

3）如果图中每个点都最多只连了一条边，也就是每个点的度数都小于等于1。那么只需选出一条边，另外再选一个点，连成三角形即可。所需边数是2，方案数是m*（n-2）。

4）对于每一个连通块进行黑白染色后，黑点与黑点连一条边，白点与白点连一条边也就能构造出奇环。所需添加的边数就是1，每一个连通块对答案的贡献是\binom{black}{2}+\binom{white}{2}

#include<iostream>
#include<cstdio>
#include<string.h>
#include<algorithm>
using namespace std;
typedef long long ll;
const ll mod=1e9+7;
const ll N=1e6+7;
ll p[N],edn;
ll num[3],vis[N];
struct Edge{
    ll u,v,nxt;
    Edge(ll u=0,ll v=0,ll nxt=0):u(u),v(v),nxt(nxt){}
}e[N*2];
void add(ll u,ll v){
    e[++edn]=Edge(u,v,p[u]);p[u]=edn;
    e[++edn]=Edge(v,u,p[v]);p[v]=edn;
}
bool dfs(ll u){
    num[vis[u]]++;
    for(ll i=p[u];~i;i=e[i].nxt){
        ll v=e[i].v;
        if(vis[v]){
            if(vis[v]==vis[u]){
                return false;
            }
            continue;
        }
        vis[v]=3-vis[u];
        if(dfs(v)==false) return false;
    }
    return true;
}
int main()
{
    ll n,m,u,v;
    scanf("%lld%lld",&n,&m);
    if(m==0) printf("3 %lld\n",n*(n-1)*(n-2)/6);
    else{
        memset(p,-1,sizeof(p));edn=-1;
        for(ll i=1;i<=m;i++){
            scanf("%lld%lld",&u,&v);
            add(u,v);
        }
        ll ans=0;
        memset(vis,0,sizeof(vis));
        bool flag=true;
        for(ll i=1;i<=n;i++){
            if(!vis[i]){
                num[1]=num[2]=0;
                vis[i]=1;
                flag=dfs(i);
                if(flag==false) break;
                ans=ans+num[1]*(num[1]-1)/2+num[2]*(num[2]-1)/2;
            }
        }
        if(flag){
            if(ans==0) printf("2 %lld\n",m*(n-2));
            else printf("1 %lld\n",ans);
        }
        else printf("0 1\n");
    }
}

POJ - 2594 - Treasure Exploration

题目链接<http://poj.org/problem?id=2594>

题意：

在一张有向无环图中，放置若干个机器人，每个机器人都有一个属于自己的路径。图中每一个节点都可以属于多个路径。问最少需要投放几个机器人才能遍历完图中每个节点。

题解：

粗一看以为是最小路径覆盖裸题，直接wa掉。

因为节点可以属于多个路径，所以不能裸着做，但只需另外floyd一下，把下一个节点能到的点直接连上就行了。

这题还是用矩阵好实现。

#include<iostream>
#include<string.h>
#include<algorithm>
#include<cstdio>
using namespace std;
typedef long long ll;
const int N=5e2+7;
const int inf=1<<28;
int mp[N][N];
int vis[N],match[N];
int n,m,u,v;
bool dfs(int u){
    for(int v=1;v<=n;v++){
        if(mp[u][v]&&!vis[v]){
            vis[v]=1;
            if(match[v]==-1||dfs(match[v])){
                match[v]=u;
                return true;
            }
        }
    }
    return false;
}
int main(){

    while(scanf("%d%d",&n,&m)!=EOF){
        if(n==0&&m==0) break;
        memset(match,-1,sizeof(match));
        memset(mp,0,sizeof(mp));
        for(int i=1;i<=m;i++){
            scanf("%d%d",&u,&v);
            mp[u][v]=1;
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(!mp[i][j]) continue;
                for(int k=1;k<=n;k++){
                    if(!mp[j][k]) continue;
                    mp[i][k]=1; 
                }
            }
        }
        int ans=0;
        for(int i=1;i<=n;i++){
            memset(vis,0,sizeof(vis));
            if(dfs(i)) ans++;
        }
        printf("%d\n",n-ans);
    }
}

HDU - 3829 -Cat VS Dog

题目链接<http://acm.hdu.edu.cn/showproblem.php?pid=3829>

题意：

动物园有若干只狗和猫，每个小朋友都要么喜欢一只狗不喜欢一只猫，要么反过来。现在要移除一些狗和猫，小朋友只有在不移除自己喜欢的动物，移除了自己不喜欢的动物才会开心。问最多能让几个小朋友开心。

题解：

如果把猫和狗当作点怕是没法做的。

其实这题的矛盾在人，如果某个人喜欢的动物另一个人不喜欢，那么这两个人就只能满足一个。

所以可以把人当作节点，矛盾的人连边，做最大独立集即可。

还有没必要尝试读字符串里的数字，数字很有可能到超过个位。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5e2+7;
struct Edge{
    int v,nxt;
    Edge(int v=0,int nxt=0):v(v),nxt(nxt){}
}e[N*N];
int n,tmp;
int p[N],edn;
void add(int u,int v){
    e[++edn]=Edge(v,p[u]);p[u]=edn;
    e[++edn]=Edge(u,p[v]);p[v]=edn;
}
int vis[N],match[N];
bool dfs(int u){
    for(int i=p[u];~i;i=e[i].nxt){
        int v=e[i].v;
        if(vis[v]) continue;
        vis[v]=1;
        if(match[v]==-1||dfs(match[v])){
            match[v]=u;
            return true;
        }
    }
    return false;
}
struct Node{
    char x[5],y[5];
}a[N];
char s1[5],s2[5];
int main(){
    int n,m,k;
    while(scanf("%d%d%d",&n,&m,&k)!=EOF){
        memset(p,-1,sizeof(p));edn=-1;
        memset(match,-1,sizeof(match));
        for(int i=1;i<=k;i++)
            scanf("%s%s",a[i].x,a[i].y);
        for(int i=1;i<=k;i++)
            for(int j=i+1;j<=k;j++)
                if(strcmp(a[j].x,a[i].y)==0||strcmp(a[j].y,a[i].x)==0)
                    add(i,j);
        int ans=0;
        for(int i=1;i<=k;i++){
            memset(vis,0,sizeof(vis));
            if(dfs(i)) ans++;
        }
        printf("%d\n",k-ans/2);
    }
}

 

Elliott__
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
二分图 最大匹配 入门题
fan233的博客
10-20 3186
【问题背景】 n只公牛和m只母牛， 某些公牛和某些母牛互相喜欢。 但最后一只公牛只能和一只母牛建立一对一匹配。 要使得最后牛群匹配对数最大。 【输入】 第一行三个整数n, m，k( 1 下来k行，每行两个整数 x，y，表示一条边，连接X集合中x点和Y集合的y点。 【输出】 只有一行。输出一个整数，表示牛群匹配对数最大值. input: 5 5 9 1 2 2
二分匹配题集
夏天的风
07-24 5457
普通匹配,多重匹配 【HDU】 1068 Girls and Boys 最大匹配★ 1150 Machine Schedule 最小点覆盖★ 1151 Air Raid 最小路径覆盖★ 1179 Ollivanders 最大匹配★ 1281 棋盘游戏 行列匹配+求关键点★★ 1498 50 years, 50 colors 行列匹配★ 1507 Uncle Tom's Inhe
二分图的匹配问题-匈牙利算法
最新发布
m0_75103840的博客
05-29 806
是。
二分图匹配及例题
weixin_45735431的博客
07-15 1110
https://blog.csdn.net/sunny_hun/article/details/80627351
利用匈牙利算法&Hopcroft-Karp算法解决二分图中的最大二分匹配问题 例poj 1469 COURSES...
weixin_30448603的博客
06-16 287
首先介绍一下题意：已知，有N个学生和P门课程，每个学生可以选0门，1门或者多门课程，要求在N个学生中选出P个学生使得这P个学生与P门课程一一对应。 这个问题既可以利用最大流算法解决也可以用匈牙利算法解决。如果用最大流算法中的Edmonds-karp算法解决，因为时间复杂度为O(n*m*m),n为点数，m为边数，会超时，利用匈牙利算法，时间复杂度为O(n*m)，时间复杂度小，不会超...
二分图与匹配问题
weixin_42374938的博客
09-01 1225
一、二分图的定义 给定图G=(V,E)。如果顶点集V可分为两个互不相交的非空子集X和Y，并且图中的每条边（i，j）的两个端点i和j分别属于这两个不同的顶点子集，那么就称图G为一个二分图，记为G=(X,E,Y)。如果在子集X中的任一顶点i和子集Y中的任一顶点j之间都存在一条边,那么就称图G为一个完全二分图。如下图所示： 在网络科学研究中，二分图也称为二分网络、从属网络和二模网络。 二、二分图的判断方法 在网络中任意选取一点，把该节点以及与该节点距离为偶数的所有其他节点的集合记为X，把与该节点的距离为奇数的节
二分图最优匹配matlab代码.zip
07-11
二分图最优匹配是图论中的一个重要概念，它在许多实际问题中有着广泛的应用，比如分配问题、网络流问题、任务调度等。在本压缩包中，提供的是一组使用MATLAB语言实现的二分图最优匹配算法代码。MATLAB作为一种强大的...
二分图匹配题解1
08-03
在这些题目中，二分图被用来解决资源分配或匹配问题。 1. POJ1274: 农夫John的高科技谷仓问题实质上是一个二分图的最大匹配问题。奶牛和畜栏分别代表二分图的两边，如果一头奶牛可以去某个畜栏产奶，那么就在它们...
二分图匹配算法总结1
08-03
二分图匹配算法是一种在图论中寻找最大匹配的高效方法，特别适用于解决最大独立集问题。在二分图中，顶点被分为两个集合X和Y，所有边都连接X集合的顶点与Y集合的顶点。最大匹配是指在图中找到边数最多的匹配，即尽...
code_最近邻二分图匹配_
10-03
最近邻二分图匹配是一种在图论中的优化问题，它在计算机科学，特别是算法设计与分析领域具有广泛应用。在这个场景中，我们面对的是一个二分图，其中的顶点被分成两个集合，通常称为左顶点和右顶点。我们的目标是找到...
ACM算法练习题单： 二分图问题
ccutyear的博客
02-28 1339
经过了整整一个寒假我总算是完成图论算法中的一块---二分图问题。在这个寒假即将结束时候写一篇二分图问题的总结。 首先我指的二分图问题包括二分图染色、二分图匹配、一般图匹配。我在二分图染色的中指练习了图中结点的染色。然后，在二分图匹配中除了包括最大匹配、最小边覆盖、最大独立集、最小顶点覆盖还有二分图多重匹配和二分图最佳匹配。一般图匹配就只有一个带花树算法了。
二分图匹配
weixin_44017787的博客
08-22 505
二分图匹配 给定一个二分图G，在G的一个子图M中，M的边集{E}中的任意两条边都不依附于同一个顶点，则称M是一个匹配。 定义 极大匹配(Maximal Matching)是指在当前已完成的匹配下,无法再通过增加未完成匹配的边的方式来增加匹配的边数。最大匹配(maximum matching)是所有极大匹配当中边数最大的一个匹配。选择这样的边数最大的子集称为图的最大匹配问题。 如果一个匹配中，图中的...
二分图匹配练习题
zhj_fly的博客
07-17 1024
关于二分图匹配的讲解见文章二分图匹配。 本文练习两个简单的二分图匹配，分别对应于文章中的dfs和bfs的Hungary算法。 1、HDU1150  题意：两台机器A和B，每台都有许多工作模式。有多个任务，每个任务可以在A机器的某个模式或者在B机器的某个模式完成。问最少需要重启几次机器。 分析：该问题即最小点覆盖，即选取最少的点，使任意一条边至少有一个端点被选择，任务相当于边。最小点覆盖数=
二分图问题
zixiangzhan的博客
02-21 333
二分图问题 一个图G=(V,E)中的V若可以分为两个集合(V1,V2)使得在V1内部和V2内部任意两点不可达，则称这个图为二分图。下面出现的V1,V2即分别表示内部任意两点不可达的两个集合。 开门见山，直接开始介绍二分图中几个关系： 最大匹配=最小点覆盖=|V|-最大独立集=|V|-最小边覆盖 有不详细的地方请参看其余资料，这里只是提供一个简要纲领性质的讲解，更适合用于复习而不是用于学习新算法。 一、最大匹配 1.定义：当一些边不存在公共点，则将这些边及其端点构成的子图M称为一个匹配，其中的点、边称为匹配
二分图匹配问题
__surtr的博客
09-17 361
二分图匹配问题 定义 ：无向图中n个节点分成A，B两个非空集合， A∩B = ∅，并且同一集合内点互不相连， 称此无向图为二分图，A中的点称左部点， B中的点称右部点。 二分图的判定：当且仅当图中不存在长度为奇数的环。 染色法： void dfs(int x,int color){ v[x] = color; for(int i = head[x]; i; i = Next[i]){ in...
图论：二分图问题
qq_51704853的博客
07-22 216
染色法判段二分图，匈牙利算法
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值