二分匹配

最新推荐文章于 2022-01-30 18:01:29 发布
最新推荐文章于 2022-01-30 18:01:29 发布
阅读量197 收藏
点赞数
分类专栏： 算法 文章标签： 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhe_zhenbuhui_a/article/details/106756496
版权

棋盘游戏 HDU - 1281 题目链接

行与列的二分匹配，暴力删除每一点求最新的二分匹配，比原先的小那就是重要点

#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 5;
struct node{
    int x,y;
}s[N * N];
int Map[N][N],vis[N],link[N];
int cnt[N];
bool dfs(int x,int m)
{
    for (int i = 1; i <= m; i++){
        if (!Map[x][i]) continue;
        if (vis[i]) continue;
        vis[i] = 1;
        if (!link[i] || dfs(link[i],m)){
            link[i] = x;
            return true;
        }
    }
    return false;
}
int main()
{
    int n,m,k,Case = 1;
    while(scanf("%d %d %d",&n,&m,&k) == 3){
        memset(Map,0,sizeof(Map));
        memset(cnt,0,sizeof(cnt));
        for (int i = 0; i < k; i++){
            scanf("%d %d",&s[i].x,&s[i].y);
            Map[s[i].x][s[i].y] = 1;
            cnt[s[i].x]++;
        }
        memset(link,0,sizeof(link));
        int mx = 0;
        for (int i = 1; i <= n; i++){
            memset(vis,0,sizeof(vis));
            if (cnt[i]){
                mx += dfs(i,m);
            }
        }
        int ans = 0;
        for (int i = 0; i < k; i++){
            Map[s[i].x][s[i].y] = 0;
            cnt[s[i].x]--;

            memset(link,0,sizeof(link));
            int tem = 0;
            for (int i = 1; i <= n; i++){
                memset(vis,0,sizeof(vis));
                if (cnt[i]){
                    tem += dfs(i,m);
                }
            }
            Map[s[i].x][s[i].y] = 1;
            cnt[s[i].x]++;

            if (tem < mx) ans++;
        }
        printf("Board %d have %d important blanks for %d chessmen.\n",Case++,ans,mx);
    }
    return 0;
}

Swap HDU - 2819 题目链接

题意

交换矩阵中的行或列，使矩阵的对角线都为1

思路

行列的二分图匹配
最后把每一列都换到对应位置即可

#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 5;
int a[N][N];
int link[N],vis[N];
vector<pair<int,int> >p;
bool dfs(int x,int n)
{
    for (int i = 1; i <= n; i++){
        if (!a[x][i]) continue;
        if (vis[i]) continue;
        vis[i] = 1;
        if (!link[i] || dfs(link[i],n)){
            link[i] = x;
            return true;
        }
    }
    return false;
}
int main()
{
    int n;
    while(scanf("%d",&n) == 1){
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= n; j++){
                scanf("%d",&a[i][j]);
            }
        }
        memset(link,0,sizeof(link));
        int cnt = 0;
        for (int i = 1; i <= n; i++){
            memset(vis,0,sizeof(vis));
            cnt += dfs(i,n);
        }
        if (cnt < n) cout << -1 << endl;
        else {
            p.clear();
            for (int i = 1; i <= n; i++){
                int x = 1;
                while(link[x] != i) x++;
                if (x == i) continue;
                swap(link[x],link[i]);
                p.push_back({i,x});
            }
            cout << p.size() << endl;
            for (auto &k : p){
                cout << "C " << k.first << " " << k.second << endl;
            }
        }
    }
    return 0;
}

无题II HDU 2236 题目链接

题意

这是一个简单的游戏，在一个n*n的矩阵中，找n个数使得这n个数都在不同的行和列里并且要求这n个数中的最大值和最小值的差值最小。

思路

二分匹配差值

#include <bits/stdc++.h>
using namespace std;
const int N = 111;
const int INF = 0x3f3f3f3f;
int g[N][N];
int n;
int link[N],vis[N];
int mid,k;
bool dfs(int x)
{
    for (int i = 1; i <= n; i++){
        if (vis[i]) continue;
        if (g[x][i] < k || g[x][i] > k + mid) continue;
        vis[i] = 1;
        if (!link[i] || dfs(link[i])){
            link[i] = x;
            return true;
        }
    }
    return false;
}
bool solve()
{
    memset(link,0,sizeof(link));
    for (int i = 1; i <= n; i++){
        memset(vis,0,sizeof(vis));
        if (!dfs(i)) return false;
    }
    return true;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        int mx = -INF,mi = INF;
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= n; j++){
                scanf("%d",&g[i][j]);
                mx = max(mx,g[i][j]);
                mi = min(mi,g[i][j]);
            }
        }
        int l = 0,r = mx - mi;
        int ans = r;
        while(l <= r){
            mid = (l + r) >> 1;
            bool flag = true;
            for (k = mi; k + mid <= mx; k++){
                if (solve()){
                    ans = mid;
                    r = mid - 1;
                    flag = false;
                    break;
                }
            }
            if (flag) l = mid + 1;
        }
        cout << ans << endl;
    }
    return 0;
}

Rain on your Parade HDU - 2389 题目链接

思路

匈牙利算法优化
Hopcroft-Karp算法模板题

#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 5;
const int INF = 0x3f3f3f3f;
struct node{
    int x,y,v;
}s[N];
struct node2{
    int x,y;
}p[N];
int linku[N],linkv[N],vis[N];
int du[N],dv[N];
int dis;
vector<int> ve[N];
bool bfs(int n)
{
    memset(du,0,sizeof(du));
    memset(dv,0,sizeof(dv));
    queue<int> q;
    dis = INF;
    for (int i = 1; i <= n; i++){
        if (!linku[i]){
            q.push(i);
            du[i] = 0;
        }
    }
    while(!q.empty()){
        int u = q.front();
        q.pop();
        if (du[u] > dis) break;
        for (auto v : ve[u]){
            if (!dv[v]){
                dv[v] = du[u] + 1;
                if (!linkv[v]){
                    dis = dv[v];
                }
                else {
                    du[linkv[v]] = dv[v] + 1;
                    q.push(linkv[v]);
                }
            }
        }
    }
    return dis != INF;
}
bool dfs(int u)
{
    for (auto v : ve[u]){
        if (!vis[v] && dv[v] == du[u] + 1){
            vis[v] = 1;
            if (linkv[v] && dis == dv[v]) continue;
            if (!linkv[v] || dfs(linkv[v])){
                linku[u] = v;
                linkv[v] = u;
                return true;
            }
        }
    }
    return false;
}
int solve(int n)
{
    int ans = 0;
    memset(linku,0,sizeof(linku));
    memset(linkv,0,sizeof(linkv));
    while(bfs(n)){
        memset(vis,0,sizeof(vis));
        for (int i = 1; i <= n; i++){
            if (!linku[i] && dfs(i)) ans++;
        }
    }
    return ans;
}
int calc(int a,int b,int c,int d)
{
    return (a - b) * (a - b) + (c - d) * (c - d);
}
int main()
{
    int t,Case = 1;
    scanf("%d",&t);
    while(t--){
        int rain;
        scanf("%d",&rain);
        int n,m;
        scanf("%d",&n);
        for (int i = 1; i <= n; i++){
            scanf("%d %d %d",&s[i].x,&s[i].y,&s[i].v);
            s[i].v *= rain;
            s[i].v *= s[i].v;
        }
        scanf("%d",&m);
        for (int i = 1; i <= m; i++){
            scanf("%d %d",&p[i].x,&p[i].y);
        }
        for (int i = 0; i < N; i++){
            ve[i].clear();
        }
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= m; j++){
                int tem = calc(s[i].x,p[j].x,s[i].y,p[j].y);
                if (tem <= s[i].v) ve[i].push_back(j);
            }
        }
        printf("Scenario #%d:\n%d\n\n",Case++,solve(n));
    }
    return 0;
}

Strategic Game HDU - 1054 题目链接

题意

有一个树，在一个节点上放士兵可以观察与其相连的所有点，问最少需要几个士兵就可以观察到全部节点

思路

（最小顶点覆盖数）

#include <cstring>
#include <iostream>
#include <string>
#include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
const int N = 1555;
const int INF = 0x3f3f3f3f;
int vis[N];
int link[N];
vector<int> ve[N];
bool dfs(int u)
{
    for (int i = 0; i < (int)ve[u].size(); i++){
        int v = ve[u][i];
        if (vis[v]) continue;
        vis[v] = 1;
        if (link[v] == - 1 || dfs(link[v])){
            link[u] = v;
            link[v] = u;
            return true;
        }
    }
    return false;
}
int main()
{
    int n;
    while(scanf("%d",&n) == 1){
        for (int i = 0; i <= n; i++){
            ve[i].clear();
        }
        for (int i = 0; i < n; i++){
            int u,m;
            scanf("%d:(%d)", &u, &m);
            for (int j = 0; j < m; j++){
                int v;
                scanf("%d",&v);
                ve[u].push_back(v);
                ve[v].push_back(u);
            }
        }
        int ans = 0;
        memset(link,-1,sizeof(link)); /// 节点0开始
        for (int i = 0; i < n; i++){
            memset(vis,0,sizeof(vis));
            if (link[i] == -1 && dfs(i)) ans++;
        }
        printf("%d\n",ans);
    }
    return 0;
}

Air Raid HDU - 1151 题目链接

题意

在一个城镇，有m个路口，和n条路，这些路都是单向的，而且路不会形成环，现在要弄一些伞兵去巡查这个城镇，伞兵只能沿着路的方向走，问最少需要多少伞兵才能把所有的路口搜一遍。
（点不能重复经过）

思路

有向图的最大匹配

#include <cstring>
#include <iostream>
#include <string>
#include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
const int N = 155;
const int INF = 0x3f3f3f3f;
int vis[N];
int link[N];
vector<int> ve[N];
bool dfs(int u)
{
    for (int i = 0; i < (int)ve[u].size(); i++){
        int v = ve[u][i];
        if (vis[v]) continue;
        vis[v] = 1;
        if (!link[v] || dfs(link[v])){
            link[v] = u;
            return true;
        }
    }
    return false;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        int n,m;
        scanf("%d %d",&n,&m);
        for (int i = 1; i <= n; i++){
            ve[i].clear();
        }
        for (int i = 0; i < m; i++){
            int u,v;
            scanf("%d %d",&u,&v);
            ve[u].push_back(v);
        }
        int ans = 0;
        memset(link,0,sizeof(link));
        for (int i = 1; i <= n; i++){
            memset(vis,0,sizeof(vis));
            if (dfs(i)) ans++;
        }
        printf("%d\n",n - ans);
    }
    return 0;
}

Treasure Exploration POJ - 2594 题目链接

题意

hdu1151 的改版，点可以重复经过

思路

使用floyd重新构图
最小路径覆盖 = 总点数 - 最大匹配数

#include <cstring>
#include <iostream>
#include <string>
#include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
const int N = 555;
const int INF = 0x3f3f3f3f;
int vis[N];
int link[N];
int mp[N][N];
bool dfs(int u,int n)
{
    for (int v = 1; v <= n; v++){
        if (!mp[u][v] || v == u) continue;
        if (vis[v]) continue;
        vis[v] = 1;
        if (!link[v] || dfs(link[v],n)){
            link[v] = u;
            return true;
        }
    }
    return false;
}
void floyd(int n)
{
    for (int k = 1; k <= n; k++){
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= n; j++){
                if (mp[i][k] && mp[k][j]){
                    mp[i][j] = 1;
                }
            }
        }
    }
}
int main()
{
    int n,m;
    while(scanf("%d %d",&n,&m) == 2 && (n || m)){
        memset(mp,0,sizeof(mp));
        for (int i = 0; i < m; i++){
            int u,v;
            scanf("%d %d",&u,&v);
            mp[u][v] = 1;
        }
        floyd(n);
        int ans = 0;
        memset(link,0,sizeof(link));
        for (int i = 1; i <= n; i++){
            memset(vis,0,sizeof(vis));
            if (dfs(i,n)) ans++;
        }
        printf("%d\n",n - ans);
    }
    return 0;
}

Cat VS Dog HDU - 3829题目链接

题意

动物园有N只猫，M只狗，P个小孩。每个小孩都有自己喜欢的动物和讨厌的动物，如果他喜欢狗，那么就讨厌猫， 如果他讨厌狗，那么他就喜欢猫。某个小孩能开心，当且仅当他喜欢的动物留在动物园和讨厌的动物不在动物园里面。 现让管理员通过带走某些动物，问最多能使多少个孩子开心。

思路

最大独立集 = 总点数 - 最大匹配数

#include <cstring>
#include <iostream>
#include <string>
#include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
const int N = 555;
const int INF = 0x3f3f3f3f;
struct node{
    char s1[5],s2[5];
}s[N];
int vis[N];
int link[N];
vector<int> ve[N];
bool dfs(int u)
{
    for (int i = 0; i < (int)ve[u].size(); i++){
        int v = ve[u][i];
        if (vis[v]) continue;
        vis[v] = 1;
        if (!link[v] || dfs(link[v])){
            link[v] = u;
            link[u] = v;
            return true;
        }
    }
    return false;
}
int main()
{
    int n,m,k;
    while(scanf("%d %d %d",&n,&m,&k) == 3){
        for (int i = 0; i < k; i++){
            scanf("%s %s",s[i].s1,s[i].s2);
        }
        for (int i = 1; i <= k; i++){
            ve[i].clear();
        }
        for (int i = 0; i < k; i++){
            for (int j = i + 1; j < k; j++){
                if (strcmp(s[i].s2,s[j].s1) == 0 || strcmp(s[i].s1,s[j].s2) == 0){
                    ve[i + 1].push_back(j + 1);
                    ve[j + 1].push_back(i + 1);
                }
            }
        }
        int ans = 0;
        memset(link,0,sizeof(link));
        for (int i = 1; i <= k; i++){
            memset(vis,0,sizeof(vis));
            if (!link[i] && dfs(i)) ans++;
        }
        printf("%d\n",k - ans);
    }
    return 0;
}

HDU 3081 题目链接

题意

n个男生,n个女生,接下来有 m个关系,u v表示第 u 个女生和第 v个男生可以配对,然后接下来有 f 个关系,u v表示第 u个女生和第v个女生是好友,如果 u 和 v可以配对,u 和 w是好友,那么w 和 v也是可以配对的.问知道这些人的关系,最多可以完全配对多少次(完全配对是指n个男生和n个女生都可以配对)?

思路

floyd建图，然后求完美匹配，匹配完成后就删边，直到不能匹配为止
（这道题是在网络流专题里的，使用二分和并查集最大流也可以解）

#include <cstring>
#include <iostream>
#include <string>
#include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
const int N = 222;
const int INF = 0x3f3f3f3f;
int vis[N];
int pre[N];
int link[N];
int g[N][N];
int n,m,f;
bool dfs(int u)
{
    for (int v = 1; v <= n; v++){
        if (!g[u][v]) continue;
        if (vis[v]) continue;
        vis[v] = 1;
        if (!link[v] || dfs(link[v])){
            link[v] = u;
            return true;
        }
    }
    return false;
}
int Find(int x)
{
    return pre[x] == x ? x : pre[x] = Find(pre[x]);
}
void Union(int a,int b)
{
    int x = Find(a),y = Find(b);
    if (x != y){
        pre[x] = y;
    }
}
int solve()
{
    memset(link,0,sizeof(link));
    for (int i = 1; i <= n; i++){
        memset(vis,0,sizeof(vis));
        if (!dfs(i)) return false;
    }
    return true;
}
void build()
{
    for (int i = 1; i <= n; i++){
        for (int j = 1; j <= n; j++){
            if (Find(i) == Find(j)){
                for (int k = 1; k <= n; k++){
                    if (g[i][k]) g[j][k] = 1;
                }
            }
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d %d %d",&n,&m,&f);
        memset(g,0,sizeof(g));
        for (int i = 0; i < m; i++){
            int u,v;
            scanf("%d %d",&u,&v);
            g[u][v] = 1;
        }
        for (int i = 1; i <= n; i++){
            pre[i] = i;
        }
        for (int i = 0; i < f; i++){
            int u,v;
            scanf("%d %d",&u,&v);
            Union(u,v);
        }
        build();
        int ans = 0;
        while(true){
            if (!solve()) break;
            ans++;
            for (int i = 1; i <= n; i++){
                g[link[i]][i] = 0;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}
zhe_zhenbuhui_a
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二分匹配题集
09-03
二分匹配题集，适用于算法爱好者，内含有多种题型
二分匹配大总结——Bipartite Graph Matchings[LnJJF]
LnJJF的博客
10-22 1579
文章目录二分匹配——Bipartite Graph Matchings[LnJJF]认识：什么是二分图？理解：现实模型如何与二分图相互转化？如何判断能否转化？能够转化的话，如何转化？应用：已知一个二分图，求最大匹配数的方法是什么？匈牙利算法示例解析匈牙利算法求二分图最大匹配的通用思路匈牙利算法核心部分代码展示(C++)——通用代码模板活用：那些题目不是求最大匹配数，但是可以转化为求最大匹配数来做？1. 最小顶点覆盖数=最大匹配数什么是最小顶点覆盖？为什么最小顶点覆盖数=最大匹配数？有什么现实模型，是问最小顶
二分匹配一些总结
酷闷
11-11 277
[img]/upload/attachment/48866/f8addf81-cc43-30e5-b619-f2c1f67a6371.jpg[/img][img]/upload/attachment/48868/441fb3b1-201a-3113-a405-42b2bcd82afb.jpg[/img] 图1是我给出的二分图中的一个匹配：［1，5］和［2，6］。图2就是在这个匹配的基础上找到的一...
二分图匹配详解
日拱一卒,功不唐捐
10-25 5145
1.二分图的原始模型及相关概念 二分图又称作二部图，是图论中的一种特殊模型。 设G=(V,E)G=(V,E)是一个无向图。如顶点集VV 可分割为两个互不相交的子集，并且图中每 条边依附的两个顶点都分属两个不同的子集。则称图GG 为二分图。我们将上边顶点集合称 为XX 集合，下边顶点结合称为YY 集合，如下图，就是一个二分图。 给定一个二分图G(无向图)，在G的一个子图M中，M的边集中的任意...
二分图匹配-匈牙利算法
The Shawshank Redemption
08-24 2315
二分图概述 所谓二分图，就是我们可以将图中所有的点分为A、B两个集合，从而使得集合内部任意两个点都不直接相连。 二分图适用于解决一种类似于婚姻匹配的问题，即如果A-B匹配，那么A就不能在和C匹配，即便他们之间有好感。 最大匹配 二分图的最大匹配即需要给出一种分配策略，使得产生尽可能多的对（就是撮合最多多少对情侣）。 匈牙利算法是一个用于解决该类问题的标准算法之一，核心想法是让路：假设你（就是红娘）当前想撮合Bi与Gk，但是Gk已经有了对象Bj，此时红娘就和Bj交涉能否让Bj尝试换一个对象.
二分匹配算法
m0_57587757的博客
10-18 401
二分图及其应用（Bipartite Graph） 什么是二分图？ 如果一个图的顶点可以分成两个集合X和Y，图的所有边一定是有一个顶点属于集合X，另一个顶点属于集合Y，则称该图为”二分图”或“二部图”。 典型问题，婚配问题。 二分图如图所示： 二分图的最大匹配 在二分图的应用中，最常见的就是求——最大匹配，很多其他的问题都可以转化为匹配问题来解决。 那么我们如何求二分图的最大匹配呢？ 下面介绍一个算法：匈牙利算法 匈牙利算法示意图 1： 匈牙利算法示意图 2： 匈牙利..
二分匹配总结
11-15
对二分匹配的思想总结的简洁而透彻，在acm竞赛中二分有很多变种，但都是基于曾广路进行的
HDU二分匹配及其应用
07-10
HDU二分匹配及其应用，此PPT是刘春英老师版权所有， 特此贡献给广大编程爱好者，特别是对于ACMer
过山车之二分匹配
01-19
过山车之二分匹配，这道题是求最大匹配数，求、最多可以有几对
二分匹配讲义
07-28
二分匹配各种算法,非常详尽
二分图匹配
08-08
设G是一个图。如果存在VG的一个划分X，Y，使得G的任何一条边的一个端点在X中，另一个端点在Y中，则称G为二分图，记作G＝(X，Y，E)。如果G中X的每个顶点都与Y的每个顶点相邻，则称G为完全二分图。
二分图完全匹配算法之匈牙利算法
小菜鸡的博客
01-30 6012
最近在参加了一个小项目，里面用到二分图匹配算法，因为之前并没有接触过相关算法，于是找到一些博客进行了一番学习，但学习之后，发现部分博客或多或少存在一些另我疑惑的地方，于是，我打算写此博客以巩固对算法的理解。 一、二分图基本概念 二分图（Bipartite graph）又称作二部图，是图论中的一种特殊模型。 设G=(V,E)是一个无向图，如果顶点V可分割为两个互不相交的子集(A,B)，并且图中的每条边（i，j）所关联的两个顶点i和j分别属于这两个不同的顶点集(i in A,j in B)，则称图G为一个二分图
【算法详解】 二分图及其匹配
鹭天
11-06 1412
一、二分图基础 什么是二分图? 如果一个无向图可以分为两个不同的集合A,BA,BA,B， 使得集合A,BA,BA,B内部的点中没有边相连，只存在AAA集合中的点连向BBB集合中的点或者相反。 这样的图成为无向图 无向图上的基本术语/概念 一、二分图的匹配：选取二分图中的边集SSS，当且仅当集合中的任意两条边都没有共同公共端点时，S为二分图的一个匹配 二、匹配边/未匹配边：在集合S...
二分图大讲堂——彻底搞定最大匹配数（最小覆盖数）、最大独立数、最小路径覆盖、带权最优匹配...
qiudesuo的专栏
10-04 1442
二分图大讲堂——彻底搞定最大匹配数（最小覆盖数）、最大独立数、最小路径覆盖、带权最优匹配 文本内容框架： §1图论点、边集和二分图的相关概念和性质 §2二分图最大匹配求解 匈牙利算法、Hopcroft-Karp算法 §3二分图最小覆盖集和最大独立集的构造 §4二分图最小路径覆盖求解 §5二分图带权最优匹配求解 Kuhn-Munkers算法 §6小结 每章节都...
二分图最大匹配
chen_1993_6_9的专栏
05-26 392
二分图：二分图是这样一个图，它的顶点可以分类两个集合X和Y，所有的边关联的两个顶点恰好一个属于集合X，另一个属于集合Y。 二分图匹配：给定一个二分图G，在G的一个子图M中，M的边集中的任意两条边都不依附于同一个顶点，则称M是一个匹配。 最大匹配：图中包含边数最多的匹配称为图的最大匹配。 完美匹配：如果所有点都在匹配边上，则称这个最大匹配是完美匹配。 二分图匹配基本概念： 未盖
匹配算法——相亲男女匹配
无限大地NLP_空木的专栏
09-28 3458
时间：20210928 背景：有个相亲活动，需要暗地里给男女进行匹配，毕竟明面上直接说不喜欢哪个异性总是尴尬的。匹配的话，方法众多，并不能让每个人都满意，根据各自的意向，总能计算整体意向都不错的。 太长了不看，直接操作： 线下让N对男女： 写个小纸条，各自给N个异性排序，更喜欢的排在前面 得到： 女生的选择：womanChoices 女1：男2，男5，男1，.... 女2：... ... 女N：... 男生的选择：manChoices 同理 操作：
二分匹配算法理解
K.X的博客
08-12 1270
                                         二分匹配算法理解 二分匹配算法是解决两个集合自身间的元素无关系，但两集合间的元素有关系，可将有关系的元素进行匹配，二分匹配可以得到最大匹配数；二分匹配是在一个集合中进行查找，查找不冲突就进行匹配，若出现冲突进行查找增广路，若找到增广路，更新原来的配对关系，具体实现是利用深搜思想查找尝试每一个点，首先从任意一个未被匹...
二分匹配的一些基本概念
m0_51736862的博客
08-24 167
1.二分图：二分图又称作二部图，是图论中的一种 特殊模型 。设G= (V,E)是一个无向 图，如果顶点V可分割为两个互不相交的子集 (A,B)，并且图中的每条边（i，j）所关联 的两个顶点i和j分别属于这两个不同的顶点集 (i in A,j in B)，则称图G为一个二分图 2.匹配：在图论中，一个「匹配」是一个边的集合，其中任意两条边都没有公共顶点。 3.最大匹配：一个图所有匹配中，所含匹配边数最多的匹配，称为这个图的最大匹配。 4.完美匹配：如果一个图的某个匹配中，所有的顶点都是匹配点，那么它就是一个
我对KM算法的理解
茅屋
12-26 2299
一般对KM算法的描述，基本上可以概括成以下几个步骤： （1） 初始化可行标杆 （2） 用匈牙利算法寻找完备匹配 （3） 若未找到完备匹配则修改可行标杆 （4） 重复（2）（3）直到找到相等子图的完备匹配 关于该算法的流程及实施，网上有很多介绍，基本上都是围绕可行标杆如何修改而进行的讨论，至于原理并没有给出深入的探讨。 KM算法是用于寻找带权二分图最佳匹配的算法。 二分图是...
如何用FFA算法解决二分匹配问题
最新发布
05-31
3. 如果当前节点j已经匹配，那么设它的匹配节点为k，如果i和k不在同一个交替路上，则可以通过交替路增广来更新匹配，即将i和j匹配，并将k和它的匹配节点重新匹配。如果i和k在同一个交替路上，则继续寻找下一个未匹配...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值