二分图匹配(匈牙利算法，hungray)

最新推荐文章于 2024-08-10 15:25:17 发布
最新推荐文章于 2024-08-10 15:25:17 发布
阅读量284 收藏 1
点赞数 1
分类专栏： # Algorithm 文章标签： 算法 图论 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40342400/article/details/127638713
版权

二分图

二分图难点在于如何建图

二分图最大匹配 : K   (匈牙利算法)
二分图最小顶点覆盖 : 等价于K   (最少的顶点覆盖所有边)
二分图的最大独立集 : 等价于顶点数N - K  (去除尽可能少的点，使所有边消失，所剩下最多的独立点)
DAG图最小路径覆盖 : 等价于顶点数N - K  (有向无环图用最少的路径覆盖所有点，每条路径所走的点各不相同)

 

1、过山车

HDU2063 过山车

二分图最大匹配(匈牙利算法)

6 3 3
1 1
1 2
1 3
2 1
2 3
3 1
0

6条边(关系) 左图3个点 右图3个点

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

#define N 500
#define M 1000

int vis[N + 5], flag[N + 5], head[M + 5], edge[M + 5], nxt[M + 5], tot;

#define MS(a, b) memset(a, b, sizeof(a))
void Init() {
    MS(vis, -1);
    MS(head, 0);
    MS(edge, 0);
    MS(nxt, 0);
    tot = 0;
}
#undef MS

void add(int k) {
    int s, e;
    for (int i = 0; i < k; ++i) {
        scanf("%d%d", &s, &e);
        ++tot;
        edge[tot] = e;
        nxt[tot] = head[s];
        head[s] = tot;
    }
    return ;
}

bool Hungary(int s) {
    for (int i = head[s]; i; i = nxt[i]) {
        if (flag[edge[i]])  continue;
        flag[edge[i]] = 1;
        if (vis[edge[i]] == -1 || Hungary(vis[edge[i]])) {
            vis[edge[i]] = s;
            return true;
        }
    }
    return false;
}

int main() {
    int k, n, m;
    while (scanf("%d", &k) && k) {
        Init();
        scanf("%d%d", &n, &m);
        add(k);
        int ans = 0;
        for (int i = 1; i <= n; ++i) {
            memset(flag, 0, sizeof(flag));
            if (Hungary(i))  ++ans;
        }
        printf("%d\n", ans);
    }
    return 0;
}

 

2、Machine Schedule

HDU1150 Machine Schedule

二分图最小顶点覆盖
注意：两台机器的初始状态都为0，需预处理0状态

题目意思：
有A，B两种机器，A机器上有n种模具，B机器上有m种模具，有k个任务，每个任务可以在既可以在A机器上的x模具上生产，也可以在B机器上的y模具上生产。A，B机器都可以切换模具，开始的A，B都为0模具，问最少切换多少次模具。可以完成所有的任务。

题目思路：
如果我们把A机器的n个模具作为二分图的左部，B机器的m个模具作为二分图的右部，然后把每个任务当成一条连接左部x和右部y的边，问题就转化为选择最少的点，覆盖所有的边，边覆盖的定义为该边至少有一个端点在所选点集中。（用最少的模具完成所有任务）。
有这么一个结论：二分图最大匹配 = 二分图最小点覆盖

5 5 10
0 1 1
1 1 2
2 1 3
3 1 4
4 2 1
5 2 2
6 2 3
7 2 4
8 3 3
9 4 3
0

3

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

#define N 100
#define M 1000

int vis[N + 5], flag[N + 5], head[M + 5], edge[M + 5], nxt[M + 5], tot;

#define MS(a, b) memset(a, b, sizeof(a))
void Init() {
    MS(vis, -1);
    MS(flag, 0);
    MS(head, 0);
    MS(edge, 0);
    MS(nxt, 0);
    tot = 0;
    return ;
}

void add(int k) {
    int id, s, e;
    for (int i = 1; i <= k; ++i) {
        scanf("%d%d%d", &id, &s, &e);
        if (s == 0 || e == 0)  continue;
        ++tot;
        edge[tot] = e;
        nxt[tot] = head[s];
        head[s] = tot;
    }
    return ;
}

bool hungary(int s) {
    for (int i = head[s]; i; i = nxt[i]) {
        if (flag[edge[i]])  continue;
        flag[edge[i]] = 1;
        if (vis[edge[i]] == -1 || hungary(vis[edge[i]])) {
            vis[edge[i]] = s;
            return true;
        }
    }
    return false;
}

int main() {
    int n, m, k;
    while (scanf("%d", &n) && n) {
        Init();
        scanf("%d%d", &m, &k);
        add(k);
        int ans = 0;
        for (int i = 1; i <= n; ++i) {
            MS(flag, 0);
            if (hungary(i))  ++ans;
        }
        printf("%d\n", ans);
    }
    return 0;
}

 

3、Girls and Boys

HDU1068 Girls and Boys

二分图最大独立集 = 节点数 - 最小节点覆盖
注意此题数据在一个集合中

7
0: (3) 4 5 6
1: (2) 4 6
2: (0)
3: (0)
4: (2) 0 1
5: (1) 0
6: (2) 0 1
3
0: (2) 1 2
1: (1) 0
2: (1) 0

5
2

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

#define N 100000

int vis[N + 5], flag[N + 5], head[N + 5], edge[N + 5], nxt[N + 5], tot;

#define MS(a, b) memset(a, b, sizeof(a))
void Init() {
    MS(vis, -1);
    MS(flag, 0);
    MS(head, 0);
    MS(edge, 0);
    MS(nxt, 0);
    tot = 0;
    return ;
}

void add(int t) {
    int s, n, e;
    for (int i = 0; i < t; ++i) {
        scanf("%d: (%d)", &s, &n);
        while (n--) {
            scanf("%d", &e);
            ++tot;
            edge[tot] = e;
            nxt[tot] = head[s];
            head[s] = tot;
        }
    }
    return ;
}

bool hungary(int s) {
    for (int i = head[s]; i; i = nxt[i]) {
        if (flag[edge[i]])  continue;
        flag[edge[i]] = 1;
        if (vis[edge[i]] == -1 || hungary(vis[edge[i]])) {
            vis[edge[i]] = s;
            return true;
        }
    }
    return false;
}

int main() {
    int t;
    while (~scanf("%d", &t)) {
        Init();
        add(t);
        int Max = 0;
        for (int i = 0; i < t; ++i) {
            MS(flag, 0);
            if (hungary(i))  ++Max;
        }
        printf("%d\n", t - Max / 2);
    }
    return 0;
}

 

4、Air Raid

HDU1151 Air Raid

DAG图最小路径覆盖

什么是DAG图的最小路径覆盖
用尽量少的不相交简单路径覆盖有向无环图(DAG)的所有顶点，这就是——DAG图的最小路径覆盖问题。
一句话记忆:
最小路径覆盖就是用最少的路覆盖所有的点。


有一个城镇,它的所有街道都是单行的，并且每条街道都是和两个路口相连。同时已知街道不会形成回路。
你的任务是编写程序求最小数量的伞兵，这些伞兵可以访问(visit）所有的路口。对于伞兵的起始降落点不做限制。

2
4
3
3 4
1 3
2 3
3
3
1 3
1 2
2 3

2
1

在这里插入图片描述

在这里插入图片描述

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

#define N 120

int vis[N + 5], flag[N + 5], head[N + 5], edge[N + 5], nxt[N + 5], tot;

#define MS(a, b) memset(a, b, sizeof(a))
void Init() {
    MS(vis, -1);
    MS(flag, 0);
    MS(head, 0);
    MS(edge, 0);
    MS(nxt, 0);
    tot = 0;
    return ;
}

void add(int m) {
    int s, e;
    for (int i = 0; i < m; ++i) {
        scanf("%d%d", &s, &e);
        ++tot;
        edge[tot] = e;
        nxt[tot] = head[s];
        head[s] = tot;
    }
    return ;
}

bool hungary(int s) {
    for (int i = head[s]; i; i = nxt[i]) {
        if (flag[edge[i]])  continue;
        flag[edge[i]] = 1;
        if (vis[edge[i]] == -1 || hungary(vis[edge[i]])) {
            vis[edge[i]] = s;
            return true;
        }
    }
    return false;
}

int main() {
    int t, n, m;
    scanf("%d", &t);
    while (t--) {
        Init();
        scanf("%d%d", &n, &m);
        add(m);
        int Max = 0;
        for (int i = 1; i <= n; ++i) {
            MS(flag, 0);
            if (hungary(i))  ++Max;
        }
        printf("%d\n", n - Max);
    }
    return 0;
}

 

5、棋盘游戏

HDU1281 棋盘游戏

二分图最大匹配
用行号和列号创建二分图，每一行只能匹配一列，同理每列只能匹配一行
重要点：去除该点后，最大匹配数会变小
如何找到重要点：求得最大匹配数之后，暴力搜索每一个点，去除该点看是否会改变最大匹配数
注意：题目图中的点，在二分图中用边来反映。重复使用匈牙利算法时，注意清空对象数组

在这里插入图片描述

在这里插入图片描述

3 3 4
1 2
1 3
2 1
2 2
3 3 4
1 2
1 3
2 1
3 2

Board 1 have 0 important blanks for 2 chessmen.
Board 2 have 3 important blanks for 3 chessmen.

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

#define N 100
#define M 10000

int head[N + 5], edge[M + 5], nxt[M + 5], flag[N + 5], pre[N + 5], tot;

#define MS(a, b) memset(a, b, sizeof(a))

void init() {
    MS(head, 0);
    MS(edge, 0);
    MS(nxt, 0);
    MS(pre, -1);
    tot = 0;
    return ;
}

void add(int n) {
    init();
    int s, e;
    for (int i = 1; i <= n; ++i) {
        scanf("%d%d", &s, &e);
        ++tot;
        edge[tot] = e;
        nxt[tot] = head[s];
        head[s] = tot;
    }
    return ;
}

bool __hungary(int s, int x, int y) {
    for (int i = head[s]; i; i = nxt[i]) {
        if (flag[edge[i]] || (s == x && edge[i] == y))  continue;
        flag[edge[i]] = 1;
        if (pre[edge[i]] == -1 || __hungary(pre[edge[i]], x, y)) {
            pre[edge[i]] = s;
            return true;
        }
    }
    return false;
}

bool hungary(int s, int x, int y) {
    MS(flag, 0);
    return __hungary(s, x, y);
}

int main() {
    int n, m, k, t = 0;
    while (~scanf("%d%d%d", &n, &m, &k)) {
        ++t;
        add(k);
        int ans = 0, cnt = 0;
        for (int i = 1; i <= n; ++i) {
            if (hungary(i, 0, 0))  ++ans;
        }

        for (int i = 1; i <= n; ++i) {
            for (int j = head[i]; j; j = nxt[j]) {
                MS(pre, -1);
                int step = 0;
                for (int z = 1; z <= n; ++z) {
                    if (hungary(z, i, edge[j]))  ++step;
                }
                if (step != ans)  ++cnt;
            }
        }
        printf("Board %d have %d important blanks for %d chessmen.\n", t, cnt, ans);
    }
    return 0;
}

 

6、Fire Net

HDU1045 Fire Net

在这里插入图片描述

题目大意：
有一个Map[N][N],空白方格上放置墙壁(黑方格),炮台(黑色圆),要求在已知墙壁的情况下放置最多的炮台(最大匹配),限制条件：同一行同一列只能放置一个炮台(墙壁可以起到隔断作用)。
如何建图：横竖分区。先看每一列，同一列相连的空地同时看成一个点，显然这样的区域不能够同时放两个点。这些点作为二分图的X部。同理在对所有的行用相同的方法缩点，作为Y部。连边的条件是两个区域有相交部分。最后求最大匹配就是答案。

原图
.X..   
....		
XX..
....
按行编号：
1022
3333
0044
5555
按列编号：
1056
1356
0056
2456

可按行图和列图的对应位置点进行建图

#include <iostream>
#include <cstdio>
#include <cstring>
#include <unordered_map>

using namespace std;

#define N 30

char nums[N][N];
int line[N][N], col[N][N], pre[N], flag[N], head[N], edge[N], nxt[N], tot;

#define MS(a, b) memset(a, b, sizeof(a))
void init() {
    MS(nums, 0);
    MS(line, 0);
    MS(col, 0);
    MS(head, 0);
    MS(edge, 0);
    MS(nxt, 0);
    MS(pre, -1);
    tot = 0;
    return ;
}

void add(int n) {
    init();
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            cin >> nums[i][j];
        }
    }
    int cnt_line = 0, cnt_col = 0;
    for (int i = 1; i <= n; ++i) {
        ++cnt_line;
        ++cnt_col;
        for (int j = 1; j <= n; ++j) {
            if (nums[i][j] == 'X')  ++cnt_line;
            else  line[i][j] = cnt_line;
            if (nums[j][i] == 'X')  ++cnt_col;
            else  col[j][i] = cnt_col;
        }
    }
    unordered_map<int, unordered_map<int, bool> > mp;
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            if (nums[i][j] == 'X')  continue;
            int s = line[i][j], e = col[i][j];
            if (mp[s].count(e))  continue;
            mp[s][e] = true;
            ++tot;
            edge[tot] = e;
            nxt[tot] = head[s];
            head[s] = tot;
        }
    }
    return ;
}

bool __hungary(int s) {
    for (int i = head[s]; i; i = nxt[i]) {
        if (flag[edge[i]])  continue;
        flag[edge[i]] = 1;
        if (pre[edge[i]] == -1 || __hungary(pre[edge[i]])) {
            pre[edge[i]] = s;
            return true;
        }
    }
    return false;
}

bool hungary(int s) {
    MS(flag, 0);
    return __hungary(s);
}

int main() {
    int n;
    while (scanf("%d", &n) && n) {
        add(n);
        int ans = 0;
        for (int i = 1; i <= N; ++i) {
            if (hungary(i))  ++ans;
        }
        printf("%d\n", ans);
    }
    return 0;
}
Lu Zelin
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二分图匹配之匈牙利算法和 二分图匹配的几种题型
zz_ylolita
08-07 493
首先介绍匈牙利算法。
Hungary 算法
魔神翼
09-16 1172
Hungary 算法（音译为“匈牙利算法”）是用来解决二分图匹配问题的利器。它的基本思想是通过DFS在二分图中找“交错轨”。但事实上，我认为掌握这个算法甚至根本不需要理解“交错轨”这个概念，它似乎和“决策树”“隐式图”类似，只是为了理解算法的本质而抽象出来的一种东西，在代码中不会出现，也不影响对代码的浅层理解和记忆。算法的核心是bool find(int v)函数，它的作用是：寻找顶点v可
Hungary算法
eilot_c的博客
09-16 160
模板：匈牙利算法
LOI__DiJiang的博客
10-29 589
“dc说NOIP不会考二分图匹配,如果考了就当500分做”——by 某学长 于是我就学习了二分图匹配。。。 匈牙利算法算是二分图匹配里最简单（不只是理解还有代码长度）的一种了吧。。。某神犇从来都是用Dinic我这种猹只能Orz。 关于匈牙利算法的解释： 每次寻找一个能匹配的点，如果这个点已经匹配，更新这个点的匹配，用递归实现就好。其实就是不断找增广路，直到没有路可以增广就停下
求解二分图的最大匹配的匈牙利算法---POJ 1325 Machine Schedule
Keaper的博客
07-27 1755
【基本概念】 二分图：简单来说，如果图中点可以被分为两组，并且使得所有边都跨越组的边界，则这就是一个二分图。准确地说：把一个图的顶点划分为两个不相交集 U 和V ，使得每一条边都分别连接U、V中的顶点。如果存在这样的划分，则此图为一个二分图。 二分图的一个等价定义是：不含有「含奇数条边的环」的图。 匹配：在图论中，一个「匹配」（matching）是一个边的集合，其中任意两条边都没有公共顶点。
hdoj 1153 解题报告
hellobabygogo3的专栏
07-06 596
题目意思：有一个城镇，它的所有街道都是单行的，并且每条街道都是和两个路口相连。同时已知街道不会形成回路。   你的任务是编写程序求最小数量的伞兵，这些伞兵可以访问（visit）所有的路口。对于伞兵的起始降落点不做限制。   解题思路：这个题转化成求DAG图的最小路径覆盖数=节点数-最大匹配数。其中求最大匹配是关键，用匈牙利算法。   代码： #include using name
BZOJ1433 [ZJOI2009]假期的宿舍 二分图匹配 匈牙利算法
weixin_30681121的博客
01-28 90
原文链接http://www.cnblogs.com/zhouzhendong/p/8372785.html 题目传送门 - BZOJ1433 题解 　　我们理一理题目。 　　在校的学生，有自己的床，还可以睡朋友的床。 　　离校的学生，不占床。 　　外来的学生，只能睡朋友的床。 　　然后就是一个裸的二分图匹配了。 代码 #include <cstring&g...
hdu-1045-Fire Net-二分图匹配-匈牙利算法-java
lijinyuliangyan的博客
09-14 294
Suppose that we have a square city with straight streets. A map of a city is a square board with n rows and n columns, each representing a street or a piece of wall.  A blockhouse is a small castle
day 9 回溯算法
m0_73924943的博客
08-08 252
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
day021二叉树最后章节
m0_62956971的博客
08-06 578
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
代码随想录算法训练营day36：动态规划04：1049.最后一块石头的重量II；494.目标和；474.一和零
weixin_65180740的博客
08-07 882
力扣题目链接(opens new window)有一堆石头，每块石头的重量都是正整数。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎；如果 x!= y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。输入：[2,7,4,1,8,1]输出：1。
基于LQR算法的机器人轨迹跟踪控制详解
慕羽★的博客
08-10 1356
本文详细介绍了基于线性二次型调节器（LQR）算法的机器人轨迹跟踪控制方法。首先，文章通过建立基于运动学模型的离散状态方程，来描述机器人的当前状态与目标状态之间的关系，并利用此模型进行状态误差的计算。接着，通过设定状态量和控制量的权重矩阵（Q和R），使用LQR算法求解控制输入u，旨在最小化状态偏差和控制成本，以实现精确的轨迹跟踪。此外，文章还分析了LQR算法在ros_motion_planning运动规划库中的实现，通过源代码详解了误差量化、状态方程动态矩阵的建立、反馈控制增益的计算以及最终控制向量的生成等关
用霍夫变换算法来识别图像中圆形的轮廓cv::HoughCircles
追赶时代的博客
08-06 420
霍夫变换 圆形轮廓检测 cv::HoughCircles
浙大版《C语言程序设计（第3版）》题目集
qq_67330059的博客
08-09 277
其中a和b是用户传入的参数，函数返回的是两者中较大的数。
(回溯) LeetCode 39. 组合总和
最新发布
zth12212003的博客
08-10 551
本题也十分建议练习，巩固回溯的基础同时可以应对相关的变题时间复杂度：O(S)，S 为所有可行解的长度之和；空间复杂度：O(target)。
代码随想录算法训练营day37｜动态规划part05
qq_39065682的博客
08-08 208
感觉今天学的技巧性都挺强的，完全背包的还得再看看；
算法测试.
cxj0695的博客
08-06 380
现在，尼克需要在公司中建立一个 "主管-同级 "关系的树状层次结构(也就是说，除了一名员工外，每名员工都有一名主管)。有N种豆子，这些豆子只能靠颜色来区分，每个豆子都有它的美味度；题目要求的是每种颜色豆子里面的美味度最小值的最大值；题目意思就是给你t个字符串，让你找出每个串与codeforces这个串有多少不同的字母；贪心，把m条关系按照代价排序，当x的大于y的，且y没有主管即可能让x当y的主管；运用map来存储最小的美味度，然后循环遍历找最大的美味度就好；的主管，但需支付额外费用。
CSP-J 复赛 模拟题7 and 解析
xingdjk888的博客
08-08 785
素数，又称质数，是指除 11 和其自身之外，没有其他约数的正整数。例如 2,3,5,132,3,5,13 都是素数，而 4,9,12,184,9,12,18 则不是。特别地，规定 11 不是素数（因此自然数的质因数分解就是唯一的）。如果一个数字的任意前缀所对应的数字都是一个素数，那么我们称这个数字是一个超级素数，例如：233233是一个超级素数，因为它的三个不同的前缀2,23,2332,23,233都是素数。而457457本身虽然是一个素数，但是它的前缀4,454,45却不是素数，所以457457不是一个超
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值