二分图最大权匹配

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

奔小康赚大钱 HDU - 2255 题目链接

题意

村里共有n间房间,刚好有n家老百姓,考虑到每家都要有房住（如果有老百姓没房子住的话，容易引起不安定因素），每家必须分配到一间房子且只能得到一间房子。
现在这个问题就是村领导怎样分配房子才能使收入最大.
在这里插入图片描述

DFS O(n^4）写法
#include <bits/stdc++.h>
using namespace std;
const int N = 407;
const int INF = 0x3f3f3f3f;
int g[N][N];
int visx[N],visy[N];
int match[N],slack[N];
int lx[N],ly[N];
int n;
bool Find(int x)
{
    visx[x] = 1;
    for (int y = 1; y <= n; y++){
        if (visy[y]) continue;
        int delta = lx[x] + ly[y] - g[x][y];
        if  (delta) slack[y] = min(slack[y],delta);
        else {
            visy[y] = 1;
            if (match[y] == -1 || Find(match[y])){
                match[y] = x;
                return true;
            }
        }
    }
    return false;
}
void dfs(int s)
{
    memset(slack,0x3f,sizeof(slack));
    while(true){
        memset(visx,0,sizeof(visx));
        memset(visy,0,sizeof(visy));
        if (Find(s)) break;
        else {
            int delta = INF;
            for (int y = 1; y <= n; y++){
                if (!visy[y]){
                    delta = min(delta,slack[y]);
                }
            }
            for (int i = 1; i <= n; i++){
                if (visx[i]) {
                    lx[i] -= delta;
                }
                if (visy[i]){
                    ly[i] += delta;
                }
                else {
                    slack[i] -= delta;
                }
            }
        }
    }
}
void solve()
{
    for (int i = 1; i <= n; i++){
        lx[i] = -INF;
        ly[i] = 0;
        for (int j = 1; j <= n; j++){
            lx[i] = max(g[i][j],lx[i]);
        }
    }
    memset(match,-1,sizeof(match));
    for (int i = 1; i <= n; i++){
        dfs(i);
    }
}
int main()
{
    while(scanf("%d",&n) == 1){
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= n; j++){
                scanf("%d",&g[i][j]);
            }
        }
        solve();
        int ans = 0;
        for (int i = 1; i <= n; i++){
            if (match[i] != -1){
                ans += g[match[i]][i];
            }
        }
        cout << ans << endl;
    }
    return 0;
}
BFS O(n^3) 写法
思路

设置左边为lx,右边为ly，lx置为所连接边权的最大值，ly置为0
扫描右边的点（在这里计作v），找到与之匹配的 lx[i] + ly[v] == g[i][v] ，设置fl[i] = v,fr[v] = i;
没有找到就改变顶标，继续寻找，如果还没有找到，而且符合 lx[i] + ly[v] == g[i][v] 的边已经配对成功，则将已配对的点v进行重新匹配，改变对应的fl[i],fr[v]
依次进行以上步骤，直到没有可加入的边

#include <bits/stdc++.h>
using namespace std;
const int N = 407;
const int INF = 0x3f3f3f3f;
int g[N][N];
int lx[N],ly[N],slack[N];
int fl[N],fr[N];    /// 存放对应的连接点
int visx[N],visy[N];
int pre[N],q[N];
int n,l,r;
bool check(int x)
{
    visx[x] = 1;
    if (fl[x] != -1){
        q[r++] = fl[x];
        visy[fl[x]] = 1;
        return  true;
    }
    while (x != -1){
        fl[x] = pre[x];
        swap(x,fr[pre[x]]);
    }
    return false;
}
void bfs(int s)
{
    memset(slack,0x3f,sizeof(slack));
    memset(visx,0,sizeof(visx));
    memset(visy,0,sizeof(visy));
    l = 0;
    r = 1;
    q[0] = s;
    visy[s] = 1;;
    while (true){
        int delta;
        while (l < r){
            int v = q[l++];
            for (int i = 1; i <= n; ++i){
                if (!visx[i] && slack[i] >= (delta = lx[i] + ly[v] - g[i][v])){
                    pre[i] = v;
                    if (delta){
                        slack[i] = delta;
                    }
                    else if (!check(i))
                        return;
                }
            }
        }
        delta = INF;
        for (int i = 1; i <= n; ++i){
            if (!visx[i] && delta > slack[i]){
                delta = slack[i];
            }
        }
        for (int i = 1; i <= n; i++){
            if (visx[i])
                lx[i] += delta;
            else
                slack[i] -= delta;
            if (visy[i])
                ly[i] -= delta;
        }
        for (int i = 1; i <= n; ++i){
            if (!visx[i] && !slack[i] && !check(i))
                return;
        }
    }
}
void solve()
{
    memset(fl,-1,sizeof(fl));
    memset(fr,-1,sizeof(fr));
    for (int i = 1; i <= n; ++i){
        lx[i] = -INF;
        ly[i] = 0;
        for (int j = 1; j <= n; j++){
            lx[i] = max(g[i][j],lx[i]);
        }
    }
    for (int i = 1; i <= n; i++){
        bfs(i);
    }
}
int main()
{
    while(scanf("%d",&n) == 1){
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= n; j++){
                scanf("%d",&g[i][j]);
            }
        }
        solve();
        int ans = 0;
        for (int i = 0; i <= n; i++){
            ans += g[i][fl[i]];
        }
        cout << ans << endl;
    }
    return 0;
}

Tour HDU - 3488 题目链接

题意

有N个城市,M条街道,每条街道是单向的,现在要你设计多条路线覆盖所有的点,每条路线都是一个环,并且每个点仅能被一条路线覆盖且只经过一次(终始点除外)

思路

入度和出度就能代表二分图的两边
题目求最小权，全部权值取反求最大权即可
（这道题有重边）

#include <bits/stdc++.h>
using namespace std;
const int N = 407;
const int INF = 0x3f3f3f3f;
int g[N][N];
int visx[N],visy[N];
int match[N],slack[N];
int lx[N],ly[N];
int n;
bool Find(int x)
{
    visx[x] = 1;
    for (int y = 1; y <= n; y++){
        if (visy[y]) continue;
        int delta = lx[x] + ly[y] - g[x][y];
        if  (delta) slack[y] = min(slack[y],delta);
        else {
            visy[y] = 1;
            if (match[y] == -1 || Find(match[y])){
                match[y] = x;
                return true;
            }
        }
    }
    return false;
}
void dfs(int x)
{
    memset(slack,0x3f,sizeof(slack));
    while(true){
        memset(visx,0,sizeof(visx));
        memset(visy,0,sizeof(visy));
        if (Find(x)) break;
        else {
            int delta = INF;
            for (int i = 1; i <= n; i++){
                if (!visy[i]){
                    delta = min(delta,slack[i]);
                }
            }
            for (int i = 1; i <= n; i++){
                if (visx[i]){
                    lx[i] -= delta;
                }
                if (visy[i]){
                    ly[i] += delta;
                }
                else {
                    slack[i] -= delta;
                }
            }
        }
    }
}
void solve()
{
    for (int i = 1; i <= n; i++){
        lx[i] = -INF;
        ly[i] = 0;
        for (int j = 1; j <= n; j++){
            lx[i] = max(g[i][j],lx[i]);
        }
    }
    memset(match,-1,sizeof(match));
    for (int i = 1; i <= n; i++){
        dfs(i);
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        int m;
        scanf("%d %d",&n,&m);
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= n; j++){
                g[i][j] = -INF;
            }
        }
        for (int i = 0; i < m; i++){
            int u,v,w;
            scanf("%d %d %d",&u,&v,&w);
            g[u][v] = max(g[u][v],-w);
        }
        solve();
        int ans = 0;
        for (int i = 1; i <= n; i++){
            ans += g[match[i]][i];
        }
        cout << -ans << endl;
    }
    return 0;
}

HDU 2426 题目链接

题意

n个学生，m个房间，给定一些学生想住房的喜欢度，找一个最优方案使得每个学生分配一个房间，并且使得喜欢度最大，注意这题有个坑，就是学生不会住喜欢度为负的房间

疑问

没有 if (w >= 0) 这个判断就会WA

#include <bits/stdc++.h>
using namespace std;
const int N = 555;
const int INF = 0x3f3f3f3f;
int g[N][N];
int visx[N],visy[N],slack[N];
int lx[N],ly[N];
int link[N];
int n;
bool dfs(int x)
{
    visx[x] = 1;
    for (int i = 1; i <= n; i++){
        if (visy[i]) continue;
        int delta = lx[x] + ly[i] - g[x][i];
        if (delta) slack[i] = min(slack[i],delta);
        else {
            visy[i] = 1;
            if (link[i] == -1 || dfs(link[i])){
                link[i] = x;
                return true;
            }
        }
    }
    return false;
}
void km(int x)
{
    memset(slack,0x3f,sizeof(slack));
    while(true){
        memset(visx,0,sizeof(visx));
        memset(visy,0,sizeof(visy));
        if (dfs(x)) break;
        else {
            int delta = INF;
            for (int i = 1; i <= n; i++){
                if (visy[i]) continue;
                delta = min(delta,slack[i]);
            }
            for (int i = 1; i <= n; i++){
                if (visx[i]){
                    lx[i] -= delta;
                }
                if (visy[i]){
                    ly[i] += delta;
                }
                else slack[i] -= delta;
            }
        }
    }
}
int solve(int nx)
{
    for (int i = 1; i <= n; i++){
        lx[i] = -INF;
        ly[i] = 0;
        for (int j = 1; j <= n; j++){
            lx[i] = max(lx[i],g[i][j]);
        }
    }
    memset(link,-1,sizeof(link));
    for (int i = 1; i <= n; i++){
        km(i);
    }
    int ans = 0;
    for (int i = 1; i <= n; i++){
        if (link[i] <= nx){
            ans += g[link[i]][i];
        }
    }
    return ans;
}
int main()
{
    int nx,ny,m;
    int Case = 1;
    while(scanf("%d %d %d",&nx,&ny,&m) == 3){
        n = max(nx,ny);
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= n; j++){
                g[i][j] = -INF;
            }
        }
        for (int i = 0; i < m; i++){
            int u,v,w;
            scanf("%d %d %d",&u,&v,&w);
            u++;
            v++;
            if (w >= 0) g[u][v] = max(g[u][v],w);
        }
        if (nx > ny || !m){
            printf("Case %d: -1\n",Case++);
            continue;
        }
        printf("Case %d: %d\n",Case++,solve(nx));
    }
    return 0;
}

Assignment HDU 2853 题目链接

题意:

给定一个二分图，N个点对应M个点，两两之间存在一组关系，每组关系一个权值。题目中了给定了一个匹配方案，现在要求满足这组关系中的最大的匹配权值在原方案上增长了多少？并且还要求出在原匹配方案上改变(最少)多少条边才能够得到这个最大匹配？

思路(别人的想法，非常巧妙)

将原计划边和非计划边区分开来
原计划边： 乘上K倍加一
其他边：乘上K倍
满足条件（K>= N + 1）
这样就能保证极端情况下结果仍然正确：
假设
最优方案 : sum1
次优方案：sum2
sum1 - sum2 == 1
最优方案中一条计划边都没有
次优方案选择全部的 计划边
此时最优方案为：sum1 * K
次优方案：sum2 * K + N
要保证sum1 * K > sum2 * K + N
解得：K > N

结果：

ans % K 即 选择计划边的数目
ans / K - pre / K 即 增加的权值

#include <bits/stdc++.h>
using namespace std;
const int N = 55;
const int INF = 0x3f3f3f3f;
int g[N][N];
int visx[N],visy[N];
int match[N],slack[N];
int lx[N],ly[N];
int n,nx,ny;
bool Find(int x)
{
    visx[x] = 1;
    for (int y = 1; y <= ny; y++){
        if (visy[y]) continue;
        int delta = lx[x] + ly[y] - g[x][y];
        if  (delta) slack[y] = min(slack[y],delta);
        else {
            visy[y] = 1;
            if (match[y] == -1 || Find(match[y])){
                match[y] = x;
                return true;
            }
        }
    }
    return false;
}
void dfs(int s)
{
    memset(slack,0x3f,sizeof(slack));
    while(true){
        memset(visx,0,sizeof(visx));
        memset(visy,0,sizeof(visy));
        if (Find(s)) break;
        else {
            int delta = INF;
            for (int y = 1; y <= ny; y++){
                if (!visy[y]){
                    delta = min(delta,slack[y]);
                }
            }
            for (int i = 1; i <= nx; i++){
                if (visx[i]) lx[i] -= delta;
            }
            for (int i = 1; i <= ny; i++){
                if (visy[i]){
                    ly[i] += delta;
                }
                else {
                    slack[i] -= delta;
                }
            }
        }
    }
}
void solve()
{
    memset(lx,0,sizeof(lx));
    memset(ly,0,sizeof(ly));
    memset(match,-1,sizeof(match));
    for (int i = 1; i <= nx; i++){
        for (int j = 1; j <= ny; j++){
            lx[i] = max(g[i][j],lx[i]);
        }
    }
    for (int i = 1; i <= nx; i++){
        dfs(i);
    }
}
int main()
{
    while(scanf("%d %d",&nx,&ny) == 2){
        for (int i = 1; i <= nx; i++){
            for (int j = 1; j <= ny; j++){
                scanf("%d",&g[i][j]);
                g[i][j] *= 111;
            }
        }
        int pre = 0;
        for (int i = 1; i <= nx; i++){
            int x;
            scanf("%d",&x);
            pre += g[i][x];
            g[i][x]++;
        }
        solve();
        int ans = 0;
        for (int i = 1; i <= ny; i++){
            if (match[i] != -1){
                ans += g[match[i]][i];
            }
        }
        cout << nx - ans % 111 << " " << ans / 111 - pre / 111 << endl;
    }
    return 0;
}

Similarity HDU 3718 题目链接

题意

有两串字符串,他们都是分类的结果.第一行是正确结果,第二行是需要你判断的.
现在给你很多字符串,要你输出最大相似率.

思路

每一对字母映射就在相应的边权加一，如何求最大权匹配即可
（我用O(n4)超时，可能是我的O(n4)有点垃圾）

#include <bits/stdc++.h>
using namespace std;
const int N = 55;
const int INF = 0x3f3f3f3f;
int g[N][N];
int lx[N],ly[N],slack[N];
int fl[N],fr[N];    /// 存放对应的连接点
int visx[N],visy[N];
int pre[N],q[N];
int n,l,r;
map<char,int> mp1,mp2;
char str1[11111];
bool check(int x)
{
    visx[x] = 1;
    if (fl[x] != -1){
        q[r++] = fl[x];
        visy[fl[x]] = 1;
        return  true;
    }
    while (x != -1){
        fl[x] = pre[x];
        swap(x,fr[pre[x]]);
    }
    return false;
}
void bfs(int s)
{
    memset(slack,0x3f,sizeof(slack));
    memset(visx,0,sizeof(visx));
    memset(visy,0,sizeof(visy));
    l = 0;
    r = 1;
    q[0] = s;
    visy[s] = 1;;
    while (true){
        int delta;
        while (l < r){
            int v = q[l++];
            for (int i = 1; i <= n; ++i){
                if (!visx[i] && slack[i] >= (delta = lx[i] + ly[v] - g[i][v])){
                    pre[i] = v;
                    if (delta){
                        slack[i] = delta;
                    }
                    else if (!check(i))
                        return;
                }
            }
        }
        delta = INF;
        for (int i = 1; i <= n; ++i){
            if (!visx[i] && delta > slack[i]){
                delta = slack[i];
            }
        }
        for (int i = 1; i <= n; i++){
            if (visx[i])
                lx[i] += delta;
            else
                slack[i] -= delta;
            if (visy[i])
                ly[i] -= delta;
        }
        for (int i = 1; i <= n; ++i){
            if (!visx[i] && !slack[i] && !check(i))
                return;
        }
    }
}
void solve()
{
    memset(fl,-1,sizeof(fl));
    memset(fr,-1,sizeof(fr));
    for (int i = 1; i <= n; ++i){
        lx[i] = -INF;
        ly[i] = 0;
        for (int j = 1; j <= n; j++){
            lx[i] = max(g[i][j],lx[i]);
        }
    }
    for (int i = 1; i <= n; i++){
        bfs(i);
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        int n1,m,k;
        scanf("%d %d %d",&n1,&k,&m);
        mp1.clear();
        int nx = 0;
        for (int i = 0; i < n1; i++){
            char ch;
            scanf(" %c",&ch);
            str1[i] = ch;
            if (!mp1[ch])   mp1[ch] = ++nx;
        }
        for (int i = 0; i < m; i++){
            int ny = 0;
            mp2.clear();
            memset(g,0,sizeof(g));
            for (int i = 0; i < n1; i++){
                char ch;
                scanf(" %c",&ch);
                if (!mp2[ch]) mp2[ch] = ++ny;
                int x = mp1[str1[i]];
                g[x][mp2[ch]]++;
            }
            n = max(nx,ny);
            solve();
            int ans = 0;
            for (int i = 1; i <= nx; i++){
                if (fl[i] != -1){
                    ans += g[i][fl[i]];
                }
            }
            printf("%.4f\n",(double)ans / n1);
        }
    }
    return 0;
}

HDU 3523 题目链接

题意

有m个数列Q1、Q2、Qm，每个数列有n个数（1-n排列），让你找到一个数列T使得题意中的公式取得的值最小
在这里插入图片描述

思路

遍历每一列中的1-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 match[N];
int visx[N],visy[N];
int lx[N],ly[N];
int slack[N];
int a[N][N];
bool Find(int x)
{
    visx[x] = 1;
    for (int i = 1; i <= n; i++){
        if (visy[i]) continue;
        int delta = lx[x] + ly[i] - g[x][i];
        if (delta) slack[i] = min(slack[i],delta);
        else {
            visy[i] = 1;
            if (match[i] == -1 || Find(match[i])){
                match[i] = x;
                return true;
            }
        }
    }
    return false;
}
void dfs(int x)
{
    memset(slack,0x3f,sizeof(slack));
    while(true){
        memset(visx,0,sizeof(visx));
        memset(visy,0,sizeof(visy));
        if (Find(x)) break;
        else {
            int delta = INF;
            for (int i = 1; i <= n; i++){
                if (!visy[i]) delta = min(delta,slack[i]);
            }
            for (int i = 1; i <= n; i++){
                if (visx[i]){
                    lx[i] -= delta;
                }
                if (visy[i]){
                    ly[i] += delta;
                }
                else slack[i] -= delta;
            }
        }
    }
}
void solve()
{
    memset(ly,0,sizeof(ly));
    for (int i = 1; i <= n; i++){
        lx[i] = -INF;
        for (int j = 1; j <= n; j++){
            lx[i] = max(lx[i],g[i][j]);
        }
    }
    memset(match,-1,sizeof(match));
    for (int i = 1; i <= n; i++){
        dfs(i);
    }
}
int main()
{
    int t,Case = 1;
    scanf("%d",&t);
    while(t--){
        int m;
        scanf("%d %d",&n,&m);
        for (int i = 1; i <= m; i++){
            for (int j = 1; j <= n; j++){
                scanf("%d",&a[i][j]);
            }
        }
        memset(g,0,sizeof(g));
        for (int k = 1; k <= n; k++){
            for (int i = 1; i <= m; i++){
                for (int j = 1; j <= n; j++){
                    g[j][k] -= abs(k - a[i][j]);
                }
            }
        }
        solve();
        int ans = 0;
        for (int i = 1; i <= n; i++){
            if (match[i] != -1){
                ans += g[match[i]][i];
            }
        }
        printf("Case #%d: %d\n",Case++,-ans);
    }
    return 0;
}
zhe_zhenbuhui_a
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二分图带权最大匹配-KM算法详解
EQUINOX1的博客
01-15 2049
找不到对象就降低期望（
我对KM算法的理解
茅屋
12-26 2327
一般对KM算法的描述，基本上可以概括成以下几个步骤： （1） 初始化可行标杆 （2） 用匈牙利算法寻找完备匹配 （3） 若未找到完备匹配则修改可行标杆 （4） 重复（2）（3）直到找到相等子图的完备匹配 关于该算法的流程及实施，网上有很多介绍，基本上都是围绕可行标杆如何修改而进行的讨论，至于原理并没有给出深入的探讨。 KM算法是用于寻找带权二分图最佳匹配的算法。 二分图是...
二分图匹配 简要总结
最新发布
Cu_OH_2的博客
04-25 322
二分图匹配 简要总结
二分图大合集——二分图最大匹配（最小覆盖数），完美匹配以及最优匹配（带权最大匹配）
热门推荐
ling_wang的博客
04-06 4万+
二分图： 定义：二分图又称作二部图，是图论的一种特殊模型。设G=(V, E)是一个无向图，如果顶点V可分割为两个互不相交的子集（A , B），且图中的每条边（i, j）所关联的两个定点分别属于这两个不同的顶点集（i in A, j in B），则称图G为一个二分图。 简单的说，一个图被分成了两部分，相同的部分没有边，那这个图就是二分图，二分图是特殊的图。（不含奇环） 由定义可知，二分图没有自...
最大带权二分图匹配
zzjlhlcd的博客
10-30 240
匈牙利算法改进，求最大带权二分图匹配
模板总结——二分图最大权匹配
EnjoyingAC的博客
04-17 1250
基本概念 完全二分图：两侧顶点集大小相等的二分图 完备匹配：所有顶点都是匹配点的匹配 最大权匹配：在带权的完全二分图中，匹配边的权值和最大的完美匹配。 相等子图：由原图的点集和边权等于顶点标号的和的边集组成的图。 KM算法原理 设左侧顶点的顶标集为{Ui},右侧顶点的顶标集为{Vj}。 定理：如果含有顶标的二分图的相等子图存在完备匹配，则该匹配就是原图的最大权匹配。 KM算法通...
二分图最大匹配及最大权匹配（km算法）
06-14
km算法是指二分图最大权匹配算法。其主要思想是使用匈牙利树算法或Hopcroft算法来解决二分图最大匹配问题，并将其应用于最大权匹配问题中。 本文详细介绍了二分图最大匹配及最大权匹配（km算法），涵盖了增广路定理...
ZJPP.zip_graph matching_二分图_二分图 matlab_最佳匹配_最大权匹配
07-14
应用MATLAB编程求解二分图的最大权匹配，即实现二分图的最佳匹配。
二部图最大权匹配KM算法
12-14
KM算法用于求二部图最大权匹配，该程序的输入是二分图两边节点的数和一个矩阵 矩阵的行和列应该相等，当二分图的两边节点数不一样时，以数值大的节点为准，不存在的边的权赋值为0。 比如：一边是2个点（v1，v2），...
二分图匹配及其应用(刘汝佳).ppt
09-17
二分图匹配及其应用 二分图匹配是图论中的一种重要概念，它是一种将图分为两个不相交的点集合的匹配方式。二分图匹配的应用非常广泛，例如在计算机网络中，它可以用来解决数据传输问题，在社交网络中，它可以用来...
二分图匹配--刘汝佳
08-31
此外，二分图匹配还有一些其他的变种，例如最小点集覆盖问题、最大权匹配问题等。这些问题都是基于二分图匹配的变种，它们的解决方法也都是基于二分图匹配的算法。 二分图匹配是一个非常重要的问题，它有很多实际...
二分图带权匹配（推箱子问题的思考）
大田二十
06-07 2526
转载请附上原文链接： http://blog.csdn.net/u013351484/article/details/51598270 二分图带权匹配（也叫二分图最优（最佳）匹配，Kuhn－Munkres 算法） 预备知识：二分图最大匹配，二分图完备（完美）匹配 二分图带权匹配，可以把它看作集合 X 的每个顶点到集合 Y 的每个顶点均有边的二分图（设权重均为正数，则原来分别...
算法题 匈牙利算法 求二分图最大匹配（Python）
blowfire123的博客
12-02 910
题目： 给定一个二分图，其中左半部包含n1n1个点（编号1~n1n1），右半部包含n2n2个点（编号1~n2n2），二分图共包含m条边。 数据保证任意一条边的两个端点都不可能在同一部分中。 请你求出二分图的最大匹配数。 二分图的匹配：给定一个二分图G，在G的一个子图M中，M的边集{E}中的任意两条边都不依附于同一个顶点，则称M是一个匹配。 二分图的最大匹配：所有匹配中包含边数最多的一组匹配被称为二分图的最大匹配，其边数即为最大匹配数。 输入格式 第一行包含三个整数n1n1、n2n2和...
加权二分图完美匹配算法（KM递归版本），python实现
kdh的专栏
06-09 2428
加权二分图完美匹配算法，numpy实现，KM递归版本。当然还有BFS版本和费用流 原理和其他实现参考 https://blog.csdn.net/sixdaycoder/article/details/47720471 https://blog.csdn.net/u014754127/article/details/78086014 import numpy as np class...
km算法求带权二分图的最大匹配
yzyyylx的博客
03-05 266
做法 可以与匈牙利算法类比. 首先每一个匹配点都有一个期望匹配值为与它相连的所有边的最大搭配值,所有被匹配点的期望匹配值均为0. 然后如果匹配点与被匹配点的期望值之和恰好为该匹配值,则可以匹配,用匈牙利算法来求,如果没有找到则让参与此次失败匹配的点中的匹配点加上k,被匹配点减去k,k为产生一个合法匹配还需要的最小值(在代码中用need表示),全部匹配完后输出答案即可 代码#inclu
hdu 2255 带权二分图最大匹配 KM算法
Irving0323的博客
02-08 225
题意：现有n个村庄和n座房子，每个村庄分配一座房子。每个村庄分配的房子不同，则支付不同的金额。给出一个n*n矩阵，(i,j)坐标所在的数字表示第i个村庄买第j座房子需支付的价格。求分配房子可获得的最大价格。 题解：KM算法 1.带权二分图最大匹配直接用KM算法模板。 https://blog.csdn.net/chenshibo17/article/details/79933191 #i...
二分图最大权匹配（KM算法）
youngkl博客
03-13 1930
KM算法是通过给每个顶点一个标号（叫做顶标）来把求最大权匹配的问题转化为求完备匹配的问题的。设顶点Xi的顶标为A[i]，顶点Yi的顶标为B [i]，顶点Xi与Yj之间的边权为w[i,j]。在算法执行过程中的任一时刻，对于任一条边(i,j)，A[i]+B[j]>=w[i,j]始终 成立。KM算法的正确性基于以下定理：  　　若由二分图中所有满足A[i]+B[j]=w[i,j]的边(i,j)构成的子
二分图带权匹配 KM算法与费用流模型建立(转载)
weixin_30706507的博客
06-03 341
以下内容转载自此位牛人的博客：http://www.byvoid.com/blog/match-km/ 有关KM算法的基本内容可参考百度百科或者tianyi的讲解. [二分图带权匹配与最佳匹配] 什么是二分图的带权匹配？二分图的带权匹配就是求出一个匹配集合，使得集合中边的权值之和最大或最小。而二分图的最佳匹配则一定为完备匹配，在此基础上，才要求匹配的边权值之和最大或最小。二分图的带权匹配与最...
二分图最大匹配问题
Dream_Glow的博客
09-11 2995
二分图最大匹配问题 最近在做的打车项目中，涉及到了用户叫单后，将所有出单司机和所有订单匹配的问题，借此来学习一下二分图的匹配算法。 一、无权二分图最大匹配 首先要区分一下各个概念： 匹配：图G的一个匹配是由一组没有公共端点的不是环的边构成的集合。 匹配有两个重点：1. 匹配是边的集合；2. 在该集合中，任意两条边不能有共同的顶点。 注意：二分图无奇圈。 完美匹配：考虑部集为X={x1 ,x2, …}和Y={y1, y2, …}的二分图，一个完美匹配就是定义从X-Y的一个双射，依次为x1, x2, …
详细解释二分图最大权匹配
05-26
二分图最大权匹配是指在一个二分图中，找到一种匹配方式，使得匹配的边的权重之和最大。 首先，二分图是指一个图中的所有节点可以被分为两个不相交的集合，并且图中的每条边都连接着一个集合中的节点和另一个集合中...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值