二分图相关定理

最新推荐文章于 2021-09-28 11:01:41 发布
最新推荐文章于 2021-09-28 11:01:41 发布
阅读量345 收藏
点赞数
分类专栏： 憨批的图论 文章标签： 二分图
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35802619/article/details/100783550
版权

本篇博客不提供基本二分图匹配算法（匈牙利算法、网络流）

二分图最小点覆盖

给定一个二分图，求出最小的点集S，使得图中任意一条边都至少有一个端点属于S。这个点集，就是二分图最小点覆盖

Konig定理：

二分图的最小点覆盖包含的点数等于二分图的最大匹配包含的边数。

这样就让我们可以用二分图匹配算法来解此类问题。

例1：poj-1325 Machine Schedule
二分图最小点覆盖模型的主要两个要素（实际一种）：

1.每个边都有两个端点（废话）
2.一个边的两个端点至少选一个。

这种抽象模型倒是让我想起了以前做的一个树形dp的题。这个题也符合这个模型，但是它是树形的，可以使用树形dp，对于更广泛的二分图，不适用的。
所以真的例1，我们将机器的模式a[i],b[i]当成二分图的两个点集，每一个任务则是一条边。则可以看出符合这个模型。
下面是ac代码：

 #include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <map>
#include <queue>
#define ll long long
using namespace std;
const int N = 1e5+5;
int tot;
int he[2024], ne[2024], ver[2024];
int ho[2024], gg[2024], match[2024];
bool vis[2024];
int n, m, k;
int ans;
void add(int x, int y)
{
    ver[++tot] = y;
    ne[tot] = he[x];
    he[x] = tot;
}
void init()
{
    memset(vis, 0, sizeof(vis));
    memset(he, 0, sizeof(he));
    tot = 1;
    ans = 0;
    memset(match, 0, sizeof(match));
}
bool dfs(int x)
{
    for (int i = he[x]; i; i = ne[i])
    {
        int y = ver[i];
        if (!vis[y])
        {
            vis[y] = 1;
            if (!match[y] || dfs(match[y]))
            {
                match[y] = x;
                return 1;
            }
        }
    }
    return 0;
}
void getans()
{
   for (int i = 1; i <= n; i++)
	{
        memset(vis, 0, sizeof(vis));
        if (dfs(i)) ans++;
    }
}
int main()
{
    while(scanf("%d", &n), n)
 	{
 		init();
 		scanf("%d%d", &m, &k);
	    for (int i = 0; i < k; i++)
	    {
	    	int te;
	    	int a, b;
	    	scanf("%d%d%d", &te, &a, &b);
	    	if (a == 0 || b == 0) continue;
	    	add(a, b + n);
		}
		getans();
		printf("%d\n", ans);
	}
	return 0;
}

ps.一个被我忽略的地方，跑匈牙利，只要从一个点集建边至另一个点集的单向边dfs第一个点集即可。

例2:poj-2226 Muddy Fields
在这个题中，我们认定：每个点，都要被一个竖着的木板或者横着的木板盖上。我们则把这个点所属的连续横块和连续竖块连边，随有模型。
下面是ac代码：

 #include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <map>
#include <queue>
#define ll long long
using namespace std;
const int N = 1e5+5;
int tot;
int he[2024], ne[2024], ver[2024];
int ho[2024], gg[2024], match[2024];
char mp[64][64];
int mpn[64][64], mpm[64][64];
int cntn, cntm;
bool vis[2024];
int n, m, k;
int ans;
void add(int x, int y)
{
    ver[++tot] = y;
    ne[tot] = he[x];
    he[x] = tot;
}
void init()
{
    memset(vis, 0, sizeof(vis));
    memset(he, 0, sizeof(he));
    tot = 1;
    ans = 0;
    cntn = cntm = 0;
    memset(match, 0, sizeof(match));
}
bool dfs(int x)
{
    for (int i = he[x]; i; i = ne[i])
    {
        int y = ver[i];
        if (!vis[y])
        {
            vis[y] = 1;
            if (!match[y] || dfs(match[y]))
            {
                match[y] = x;
                return 1;
            }
        }
    }
    return 0;
}
void getans(int nn)
{
   for (int i = 1; i <= nn; i++)
	{
        memset(vis, 0, sizeof(vis));
        if (dfs(i)) ans++;
    }
}
int main()
{
    while(~scanf("%d%d", &n, &m))
    {
        init();
        for (int i = 1; i <= n; i++)
            scanf("%s", mp[i]+1);
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++)
            {
                if (mp[i][j] == '*' &&( mp[i][j-1] == '.' || mp[i][j-1] == 0))
                    cntn++;
                mpn[i][j] = cntn;
            }
        }
        cntm = cntn;
        for (int i = 1; i <= m; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                if (mp[j][i] == '*' &&( mp[j-1][i] == '.' || mp[j-1][i] == 0))
                    cntm++;
                mpm[j][i] = cntm;
            }
        }
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
                if (mp[i][j] == '*') add(mpn[i][j], mpm[i][j]);
        getans(cntn);
        printf("%d\n", ans);
    }
	return 0;
}
二分图最大独立集与最大团

图的独立集就是“任意两点之间都没有边相连”的点集。
图的团就是“任意两点之间均有边相连”的点集。

对于一个一般图的最大独立集与最大团，目前没有现行有效的算法求出，只有通过暴力搜索。不过这里有几条

定理1：

无向图的最大团等于其补图的最大独立集。

定理2：

对于一个二分图，其最大独立集等于：该图的顶点数减最大匹配数。

例3：牛客 骑士放置
我们观察国际象棋：骑士每次走，都垮两种颜色。故我们把2*3的每个格子的对角线用边链接，构成的图为二分图。我们直接跑一边匈牙利即可。
下面是ac代码：

 #include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <map>
#include <queue>
#define ll long long
using namespace std;
const int N = 1e5+5;
int tot =1;
int he[80024], ne[80024], ver[80024];
int ho[80024], gg[80024], match[80024];
bool vis[20240];
bool mp[128][128];
int ff[128][128];
int n, m, t;
int cnt;
int ans;
void add(int x, int y)
{
    ver[++tot] = y;
    ne[tot] = he[x];
    he[x] = tot;
}
void init()
{
    memset(vis, 0, sizeof(vis));
    memset(he, 0, sizeof(he));
    memset(mp, 0, sizeof(mp));
    memset(ff, 0, sizeof(ff));
    ans = 0;
    cnt = 0;
    memset(match, 0, sizeof(match));
}
bool dfs(int x)
{
    for (int i = he[x]; i; i = ne[i])
    {
        int y = ver[i];
        if (!vis[y])
        {
            vis[y] = 1;
            if (!match[y] || dfs(match[y]))
            {
                match[y] = x;
                return 1;
            }
        }
    }
    return 0;
}
void getans(int nn)
{
   for (int i = 1; i <= nn; i++)
	{
        memset(vis, 0, sizeof(vis));
        if (dfs(i)) ans++;
    }
}
inline bool che(int x, int y)
{
   return x >= 1 && x <= n && y >= 1 && y <= m;
}
int main()
{
    scanf("%d%d%d", &n, &m, &t);
    init();
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            if (!((i + j)&1)) ff[i][j] = ++cnt;
        }
    }
    int mx = cnt;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
           if ((i+j)&1) ff[i][j] = ++cnt;
        }
    }
    for (int i = 0; i < t; i++)
    {
        int x, y;
        scanf("%d%d", &x, &y);
        mp[x][y] = 1;
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            if (mp[i][j]) continue;
            if (!((i+j)&1))
            {
                if (che(i+1, j+2) && !mp[i+1][j+2]) add(ff[i][j], ff[i+1][j+2]);
                if (che(i+2, j+1) && !mp[i+2][j+1]) add(ff[i][j], ff[i+2][j+1]);
                if (che(i+1, j-2) && !mp[i+1][j-2]) add(ff[i][j], ff[i+1][j-2]);
                if (che(i+2, j-1) && !mp[i+2][j-1]) add(ff[i][j], ff[i+2][j-1]);
            }
            else
            {
                if (che(i+1, j+2) && !mp[i+1][j+2]) add(ff[i+1][j+2], ff[i][j]);
                if (che(i+2, j+1) && !mp[i+2][j+1]) add(ff[i+2][j+1], ff[i][j]);
                if (che(i+1, j-2) && !mp[i+1][j-2]) add(ff[i+1][j-2], ff[i][j]);
                if (che(i+2, j-1) && !mp[i+2][j-1]) add(ff[i+2][j-1], ff[i][j]);
            }
        }
    }
    getans(mx);
    printf("%d\n", n*m-t-ans);
	return 0;
}
有向无环图的最小路径点覆盖

给定一张有向无环图，要求用尽量少的不相交的简单路径，覆盖所有点。
满足这种模型的，我们如下处理：
我们把原图 G G G中的所有点拆成两个点 x , x + n x, x+n x,x+n，（以1~n为一部， n +1 ~2n为另一部）建立一个二分图 G 2 G_2 G2​。
这时我们有：

定理

有向无环图 G G G的最小路径点覆盖等于 G 2 G_2 G2​的最大匹配。

例4：牛客 Vani和cl2捉迷藏
我们求出最小路径点覆盖，每个路径上只能选择一个点。
下面是ac代码（来自蓝皮书）：

 #include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <map>
#include <queue>
#define ll long long
using namespace std;
bool cl[222][222];
int match[222],n,m;
bool vis[222], succ[222];
int hide[222];
int ans;
bool dfs(int x)
{
    for (int i = 1; i <= n; i++)
    {
        if (cl[x][i] && !vis[i])
        {
            vis[i] = 1;
            if (!match[i] || dfs(match[i]))
            {
                match[i] = x;
                return 1;
            }
        }
    }
    return 0;
}
void getans(int n)
{
    ans = n;
    for (int i = 1; i <= n; i++)
    {
        memset(vis, 0, sizeof(vis));
        ans -= dfs(i);
    }
}
int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i++)
    {
        int x,y;
        scanf("%d%d", &x, &y);
        cl[x][y] = 1;
    }
    for (int i = 1; i <= n; i++) cl[i][i] = 1;
    for (int k = 1; k <= n; k++)
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                cl[i][j] |= cl[i][k] && cl[k][j];
    for (int i = 1; i <= n; i++)
        cl[i][i] = 0;
    getans(n);
    printf("%d\n", ans);
    return 0;
}
二分图的最小边覆盖

对于一个二分图，我们选择一些边，是这些边覆盖所有的点，那么，我们最少要选择：

点总数-最大匹配数

Kalzn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
模板 - 二分图（包含全套常用定理性质）
繁凡さん的博客
07-31 813
整理的算法模板合集： ACM模板 目录染色法增广路的性质一些二分图的概念和定理二分图最大匹配匈牙利算法二分图匹配模型的两个要素二分图最小点覆盖的一个要素DAG的最小路径点覆盖DAG的最小可重复路径点覆盖最小可重复路径点覆盖模板 二分图： 如果一张无向图 (V,E)(V,E)(V,E)存在点集A,BA,BA,B，满足 ∣A∣,∣B∣≥1|A|,|B|≥1∣A∣,∣B∣≥1，A∩B=∅A∩B=∅A∩B=∅，A∪B=VA∪B=VA∪B=V，且对于 x,y∈Ax,y∈Ax,y∈A 或x,y∈Bx,y∈Bx,y∈B
二分图定理
wild-wind的专栏
09-04 1489
二分图一些定理性质
二分图相关定理及其证明（最小点覆盖+最小路径覆盖+最大独立集+最小覆盖集）
热门推荐
lethalboy
10-10 1万+
①最小路径覆盖： 给定有向图G=(V,E)。设P 是G 的一个简单路（顶点不相交）的集合。如果V 中每个顶点恰好在P 的一条路上，则称P是G 的一个路径覆盖。P 中路径可以从V 的任何一个顶点开始，长度也是任意的，特别地，可以为0。G 的最小路径覆盖是G 的所含路径条数最少的路径覆盖。   路径覆盖和二分图匹配的关系： 最小路径覆盖=|G|-最大匹配数 上述公式中最大匹配数是这样来的：
二分图一些定理 以后整理
Salvare219
05-23 599
点覆盖集：无向图G的一个点集，使得该图中所有边都至少有一个端点在该凑集内。 最小点权覆盖集：在带点权无向图G中，点权之和最小的覆盖集。 点自力集：无向图G的一个点集，使得任两个在该凑集中的点在原图中都不相邻。 最大点权自力集：在带权无向图G中，点权之和最大的自力集。  // 定理：(二分图)  // 1. 最小点权覆盖集=最小割=最大流  // 2. 最大点权自力集=总权-最小点权覆盖
二分图覆盖与独立集ppt
11-17
网络流ppt,最小点覆盖，König定理：二分图中的最大匹配数=这个图中的最小点覆盖数，König定理证明，最小点覆盖构造
图论- 二分图.rar
09-16
此外，二分图还与匈牙利算法密切相关，这是一种用于解决赋权二分图的最大匹配问题的高效算法。 在实际应用中，二分图模型可以用来描述许多现实世界的问题。比如，社交网络中的人际关系可以建模为二分图，其中一个人...
二分图匹配--刘汝佳
08-31
Hall 定理是二分图匹配中一个非常重要的定理，它描述了二分图中的匹配是否存在的充要条件。该定理表明，在一个二分图中，如果对于每个子集A，|Γ(A)|≥|A|，那么存在一个完全匹配。 二分图匹配算法有很多种，例如...
二分图最大匹配及最大权匹配（km算法）
06-14
本文将详细介绍二分图最大匹配及最大权匹配（km算法），涵盖了增广路定理、Hall定理、匈牙利树算法、Edmonds-Karp算法、Hopcroft算法等相关知识点。 一、二分图最大匹配 在图论中，二分图最大匹配是指在给定的二分...
网络流二分图课件
01-04
7. **扩展话题**：可能还会涉及最大流最小割定理、 Ford-Fulkerson方法的增广路径选择策略优化、以及二分图匹配的其他算法，如Blossom算法等。 通过这个网络流二分图的课件，学习者将能够掌握网络流的基本理论，...
二分图定理及证明
weixin_34138255的博客
01-22 254
最小顶点覆盖 定义：能覆盖所有的边的最少顶点数(或是最小点权和) 计算方法：最小顶点覆盖 = 最大匹配数 证明： 不妨把这个问题抽象为这个： 平面内有G个点\((x,y)\)，每次可以选择一个x或y，然后删除该直线上的所有点，问最少几次可以删去所有点？ 显然是以点的x坐标为集合{X}，点的y坐标为集合{Y}。那么如下连边： [1> 从S向{X}连一条流量为1的边。 [2> 从{Y}向T...
二分原理
baihacker的专栏
10-16 2588
作者:baihacker 来源:http://hi.baidu.com/feixue http://hi.csdn.net/baihacker 二分原理: 设f是定义在[a, b]上的bool函数,且满足性质若f(i) = true则f(i+1) = true. 那么算法: int l = a, r = b; while (l {  int mid = (l + r)/2;
二分图的相关定理
qq_43697256的博客
02-07 100
为了防止自己搞混概念，特地去搜了相关定理和证明 参考博客: https://www.jianshu.com/p/9aa33b956563 https://blog.csdn.net/qq_34564984/article/details/52778763
二分图定理及常见模型
ZHangFFYY的博客
08-29 1923
判二分图无向图G为二分图的充分必要条件是，G至少有两个顶点，且其所有回路的长度均为偶数。 二分图最大匹配定义：匹配是图中一些边的集合，且集合中任意两条边都没有公共点，所有的匹配中，边数最多的就是最大匹配。如果所有点都是匹配点，则称这个匹配为完美匹配。 算法：用匈牙利算法可以在O(V*E)的复杂度内求出二分图的最大匹配。 二分图最小顶点覆盖定义：点覆盖是图中一些点的集合，且对于图中所有的边，至少有一个
二分图匹配的一些定理
qq_51244139的博客
09-28 131
定理1：最小点覆盖=最大匹配数 matrix67神牛的证明（需要翻墙）：https://www.matrix67.com/blog/archives/116 例题：Asteroids 定理2：最小边覆盖=顶点数-最小点覆盖（最大匹配数） 定理3：最大独立集=ΣV-最大匹配数 ...
二分图的常用定义&性质&定理&二分图判定模板
qq_41510496的博客
07-01 533
补充定义和定理：最大匹配数：最大匹配的匹配边的数目最小点覆盖数：选取最少的点，使任意一条边至少有一个端点被选择最大独立数：选取最多的点，使任意所选两点均不相连最小路径覆盖数：对于一个 DAG（有向无环图），选取最少条路径，使得每个顶点属于且仅属于一条路径。路径长可以为 0（即单个点）。定理1：最大匹配数 = 最小点覆盖数（这是 Konig 定理）定理2：最大匹配数 = 最大独立数定理3：最小路径覆...
MIT 18.433 组合优化讲义.pdf
最新发布
02-03
König定理（1931年）进一步指出，在二分图中，最大匹配的大小实际上等于最小顶点覆盖的大小，显示了强对偶性。 接下来，讲义会描述算法来解决这些问题，特别是匈牙利算法，它是一种高效的方法，用于找到二分图的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值