图论 —— 二分图 —— KM 算法

最新推荐文章于 2024-01-15 21:06:32 发布
最新推荐文章于 2024-01-15 21:06:32 发布
阅读量2.7k 收藏 6
点赞数 4
分类专栏： # 图论——二分图

【原理】

KM 算法是用于求带权二分图的最优匹配的算法，其时间复杂度为 O(N^3)。

1.首先选择顶点数较少的为 X 部（左点集），初始时对 X 部的每一个顶点设置顶标，顶标的值为该点关联的最大边的权值，Y 部（右点集）的顶点顶标为 0。

2.对于 X 部中的每个顶点，在相等子图中利用匈牙利算法找一条增广路径，如果没有找到，则修改顶标，扩大相等子图，继续找增广路径。

3.当 X 部的每个点都找到增广路径时，此时意味着每个点都在匹配中，即找到了该二分图的完全匹配。该完全匹配即为二分图的最优匹配。

【有关概念】

1）相等子图：由于每个顶点有一个顶标，如果选择边权等于两端点的顶标之和的边，它们组成的图称为相等子图。

2）顶标：每个点的顶标为该点关联的最大边的权值。

【顶标的修改】

如果从 X 部中的某个点 Xi 出发在相等子图中没有找到增广路径，则需要修改顶标。

如果没有找到增广路径，则一定找到了许多条从 Xi 出发并结束于 X 部的匹配边与未匹配边交替出现的路径，即交错路。

将交错路中 X 部的顶点顶标减去一个值 d，交错路中属于 Y 部的顶点顶标加上一个值 d，那么会发现：

  • 两端都在交错路中的边（i,j），其顶标和没有变化，即：其原属于相等子图，现仍属于相等子图。
  • 两端都不在交错路中的边（i,j），其顶标也没有变化，即：其原来属于（或不属于）相等子图，现仍属于（或不属于）相等子图。
  • X 端不在交错路中，Y 端在交错路中的边（i,j），其顶标和会增大，即：其原来不属于相等子图，现仍不属于相等子图。
  • X 端在交错路中，Y 端不在交错路中的边（i,j），其顶标和会减小，即：其原来不属于相等子图，现可能进入相等子图，从而使相等子图得到扩大。

修改顶标的目的就是要扩大相等子图，为保证至少有一条边进入相等子图，可以在交错路的边中寻找顶标和与边权之差最小的边，也即前述的 d 值。

将交错路中属于 X 部的顶点减去 d，交错路中属于 Y 部的顶点加上 d，则可以保证至少有一条边扩充进入相等子图。

【相等子图的性质】

1）任意时刻，相等子图的 最大权匹配 ≤ 相等子图的顶标和

2）任意时刻，相等子图的 顶标和=所有顶点的顶标和

3）扩充相等子图后，相等子图的顶标和会减小

4）相等子图的 最大匹配=原图的完全匹配 时，匹配边的权值和=所有顶点的顶标和，此匹配即为最优匹配

【实现】

1.最优匹配

#include<cstdio>
#include<cstring>
#include<cmath>
#define INF 0x3f3f3f3f
#define N 1001
int n,m;//x、y中结点个数，下标从1开始
int G[N][N];//边权值矩阵
int Lx[N],Ly[N];//x、y中每个点的期望值
bool visX[N],visY[N];//标记左右点集是否已被访问过
int linkX[N],linkY[N];//linkX[i]表示与X部中点i匹配的点,linkY[i]表示与Y部中点i匹配的点,-1时表示无匹配
bool dfs(int x){
    visX[x]=true;
    for(int y=1;y<=m;y++){
        if(!visY[y]){
            int temp=Lx[x]+Ly[y]-G[x][y];
            if(temp==0){//不在交替路中
                visY[y]=true;//放入交替路
                if(linkY[y]==-1 || dfs(linkY[y])){//如果是未匹配点,说明交替路是增广路
                    linkX[x]=y;//交换路径
                    linkY[y]=x;
                    return true;//返回成功
                }
            }
        }
    }
    return false;//不存在增广路
}
void update(){
    int minn=INF;
    for(int i=1;i<=n;i++){//找出边权与顶标和的最小的差值
        if(visX[i]){
            for(int j=1;j<=m;j++){
                if(!visY[j]){
                    minn=min(minn,Lx[i]+Ly[j]-G[i][j]);
                }
            }
        }
    }

    for(int j=1;j<=n;j++)//将交错路中X部的点的顶标减去minn
        if(visX[j])
            Lx[j]-=minn;
    for(int j=1;j<=m;j++)//将交错路中Y部的点的顶标加上minn
        if(visY[j])
            Ly[j]+=minn;
}
int KM(){//更新理想值,纳入更多的边
    memset(linkX,-1,sizeof(linkX));
    memset(linkY,-1,sizeof(linkY));
    memset(Lx,0,sizeof(Lx));
    memset(Ly,0,sizeof(Ly));
    
    for(int i=1;i<=n;i++)//更新理想值
        for(int j=1;j<=m;j++)
            Lx[i]=max(Lx[i],G[i][j]);

    for(int i=1;i<=n;i++){
        while(true){
            memset(visX,false,sizeof(visX));
            memset(visY,false,sizeof(visY));

            if(dfs(i))
                break;
            else
                update();
        }
    }

    int ans=0;
    for(int i=1;i<=n;i++)
        if(linkY[i]!=-1)//若存在边
            ans+=G[linkY[i]][i];//统计边权和

    return ans;
}

int main(){
    while(scanf("%d%d",&n,&m)!=EOF&&(n+m)){
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                scanf("%d",&G[i][j]);

        printf("%d\n",KM());
    }
    return 0;
}

2.边权和最小的完全匹配

使用 KM 算法只能求二分图的最优匹配，即边权和最大的完全匹配， 这里有一个技巧，就是将所有的边权取负，再进行 KM 算法，得到的解取负就是边权和最小的完全匹配

假设存在一个最优解 res，是所有解中花费最小的，那么 -res 自然是所有花费中最大的解，当将所有边权取负后，用 KM 算法得到的最优匹配必然是那个花费最大的解，取负后就是所需的最小边权值的解

#include<cstdio>
#include<cstring>
#include<cmath>
#define INF 0x3f3f3f3f
#define N 1001
int n,m;//x、y中结点个数，下标从1开始
int G[N][N];//边权值矩阵
int Lx[N],Ly[N];//x、y中每个点的期望值
bool visX[N],visY[N];//标记左右点集是否已被访问过
int linkX[N],linkY[N];//linkX[i]表示与X部中点i匹配的点,linkY[i]表示与Y部中点i匹配的点,-1时表示无匹配
bool dfs(int x){
    visX[x]=true;
    for(int y=1;y<=m;y++){
        if(!visY[y]){
            int temp=Lx[x]+Ly[y]-G[x][y];
            if(temp==0){//不在交替路中
                visY[y]=true;//放入交替路
                if(linkY[y]==-1 || dfs(linkY[y])){//如果是未匹配点,说明交替路是增广路
                    linkX[x]=y;//交换路径
                    linkY[y]=x;
                    return true;//返回成功
                }
            }
        }
    }
    return false;//不存在增广路
}
void update(){
    int minn=INF;
    for(int i=1;i<=n;i++){//找出边权与顶标和的最小的差值
        if(visX[i]){
            for(int j=1;j<=m;j++){
                if(!visY[j]){
                    minn=min(minn,Lx[i]+Ly[j]-G[i][j]);
                }
            }
        }
    }

    for(int j=1;j<=n;j++)//将交错路中X部的点的顶标减去minn
        if(visX[j])
            Lx[j]-=minn;
    for(int j=1;j<=m;j++)//将交错路中Y部的点的顶标加上minn
        if(visY[j])
            Ly[j]+=minn;
}
int KM(){//更新理想值,纳入更多的边
    memset(linkX,-1,sizeof(linkX));
    memset(linkY,-1,sizeof(linkY));
    memset(Lx,0,sizeof(Lx));
    memset(Ly,0,sizeof(Ly));
    
    for(int i=1;i<=n;i++)//更新理想值
        for(int j=1;j<=m;j++)
            Lx[i]=max(Lx[i],G[i][j]);

    for(int i=1;i<=n;i++){
        while(true){
            memset(visX,false,sizeof(visX));
            memset(visY,false,sizeof(visY));

            if(dfs(i))
                break;
            else
                update();
        }
    }

    int ans=0;
    for(int i=1;i<=n;i++)
        if(linkY[i]!=-1)
            ans+=G[linkY[i]][i];

    return ans;
}

int main(){
    while(scanf("%d%d",&n,&m)!=EOF&&(n+m)){
        
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                scanf("%d",&G[i][j]);

        G[i][j]=-G[i][j];


        printf("%d\n",-KM());
    }
    return 0;
}

3.最小有向环覆盖权值和

若原图能由多个不相交的有向环覆盖，那么二分图一定存在完全匹配，比如：原图中有向环为 1-2-3-1，则二分图的完全匹配就是 1-2'，2-3'，3-1'

由于有向环覆盖对应一个二分图的完全匹配，该完全匹配的权值对应有向环覆盖的权值，因此原图权值最大的有向环匹配就是二分图最优匹配的值

要求最小权值和，因此将边的权值全部取负，再进行计算，最后结果再取负即可

#include<cstdio>
#include<cstring>
#include<cmath>
#define INF 0x3f3f3f3f
#define N 1001
int n,m;
int G[N][N];
int Lx[N],Ly[N];
bool visX[N],visY[N];
int linkX[N],linkY[N];
bool dfs(int x){
    visX[x]=true;
    for(int y=1;y<=m;y++){
        if(!visY[y]){
            int temp=Lx[x]+Ly[y]-G[x][y];
            if(temp==0){
                visY[y]=true;
                if(linkY[y]==-1 || dfs(linkY[y])){
                    linkX[x]=y;
                    linkY[y]=x;
                    return true;
                }
            }
        }
    }
    return false;
}
void update(){
    int minn=INF;
    for(int i=1;i<=n;i++)
        if(visX[i])
            for(int j=1;j<=m;j++)
                if(!visY[j])
                    minn=min(minn,Lx[i]+Ly[j]-G[i][j]);
 
    for(int i=1;i<=n;i++)
        if(visX[i])
            Lx[i]-=minn;
 
    for(int i=1;i<=m;i++)
        if(visY[i])
            Ly[i]+=minn;
}
int KM(){
    memset(linkX,-1,sizeof(linkX));
    memset(linkY,-1,sizeof(linkY));
 
    for(int i=1;i<=n;i++){
        Lx[i]=Ly[i]=0;
        for(int j=1;j<=m;j++)
            Lx[i]=max(Lx[i],G[i][j]);
    }
 
    for(int i=1;i<=n;i++){
        while(true){
            memset(visX,false,sizeof(visX));
            memset(visY,false,sizeof(visY));
 
            if(dfs(i))
                break;
            else
                update();
        }
    }
 
    int ans=0;
    for(int i=1;i<=m;i++){
        if(G[linkY[i]][i]==-INF){
            return 1;
        }
        ans+=G[linkY[i]][i];
    }
 
    return ans;
}
int main(){
    while(scanf("%d%d",&n,&m)!=EOF&&(n+m)){
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                G[i][j]=-INF;
 
        while(m--){
            int x,y,w;
            scanf("%d%d%d",&x,&y,&w);
            G[x][y]=max(G[x][y],-w);//处理重边
            G[y][x]=G[x][y];//无向图
        }

        int res=-KM();
        if(res==-1)
            printf("NO\n";
        else
            printf("%d\n",res);
    }
    return 0;
}

4.优先用原匹配边构建的最优匹配

最优匹配可以直接使用 KM 模版，但是要在原匹配边的基础上使得改变的边最少，可以进行如下的处理：

左边点集有 n 个点，且 n<=m，则最优匹配必有 n 条边，让原图中的每条边的权值都乘以 (n+1)，即扩大 n+1 倍，且若某边本来就是原匹配用的其中一条边，那么该边权值在扩大 n+1 倍后，再加1。

因此任意一条边的权值只能是 n+1 的倍数 或 (n+1 的倍数)+1，要在这种权值的边中选出 n 条来，最终得到的最优权值和 ans  除以 n+1，即为最优匹配解，因此就算是所有边均使用原先的匹配，也即在所有权值的基础上加了 n 个 1，此时除以 n+1，减去原匹配的值就是最优匹配比原匹配增长的值

如果在新二分图中求出的权值和为 n+1 的倍数，则说明最优匹配中一条老边都没有复用。

综上：所有边权值*(n+1)，老边再 +1，最终 ans%(n+1) 就是复用旧边的条数，ans/(n+1)-oldVal 就是最优匹配比原匹配增长的值。

#include<cstdio>
#include<cstring>
#include<cmath>
#define INF 0x3f3f3f3f
#define N 1001
int n,m;
int G[N][N];
int Lx[N],Ly[N];
bool visX[N],visY[N];
int linkX[N],linkY[N];
bool dfs(int x){
    visX[x]=true;
    for(int y=1;y<=m;y++){
        if(!visY[y]){
            int temp=Lx[x]+Ly[y]-G[x][y];
            if(temp==0){
                visY[y]=true;
                if(linkY[y]==-1 || dfs(linkY[y])){
                    linkX[x]=y;
                    linkY[y]=x;
                    return true;
                }
            }
        }
    }
    return false;
}
void update(){
    int minn=INF;
    for(int i=1;i<=n;i++)
        if(visX[i])
            for(int j=1;j<=m;j++)
                if(!visY[j])
                    minn=min(minn,Lx[i]+Ly[j]-G[i][j]);

    for(int i=1;i<=n;i++)
        if(visX[i])
            Lx[i]-=minn;

    for(int i=1;i<=m;i++)
        if(visY[i])
            Ly[i]+=minn;
}
int KM(){
    memset(linkX,-1,sizeof(linkX));
    memset(linkY,-1,sizeof(linkY));

    for(int i=1;i<=n;i++){
        Lx[i]=Ly[i]=0;
        for(int j=1;j<=m;j++)
            Lx[i]=max(Lx[i],G[i][j]);
    }

    for(int i=1;i<=n;i++){
        while(true){
            memset(visX,false,sizeof(visX));
            memset(visY,false,sizeof(visY));

            if(dfs(i))
                break;
            else
                update();
        }
    }

    int ans=0;
    for(int i=1;i<=m;i++)
        if(linkY[i]!=-1)
            ans+=G[linkY[i]][i];

    return ans;
}
int main(){
    while(scanf("%d%d",&n,&m)!=EOF&&(n+m)){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                scanf("%d",&G[i][j]);
                G[i][j]=G[i][j]*(n+1);//每条边乘以(n+1)
            }
        }

        int oldVal=0;//记录原匹配权值和
        for(int i=1;i<=n;i++){
            int j;
            scanf("%d",&j);
            oldVal+=(G[i][j]/(n+1));//累计原匹配权值
            G[i][j]++;//老边+1
        }

        int ans=KM();
        int v1=ans/(n+1);//最优匹配的权值和
        int v2=v1-oldVal;//最优匹配比原匹配相比多的权值数
        int v3=ans%(n+1);//最优匹配使用的老边数
        int v4=n-v3;//最优匹配使用的新边数

        printf("%d\n",v1);
        printf("%d\n",v2);
        printf("%d\n",v3);
        printf("%d\n",v4);
    }
    return 0;
}

 

Alex_McAvoy
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
小白学习KM算法详细总结--附上模板题hdu2255
The_b-dn
09-10 2775
x小白理解KM算法学习总结，归纳各位大神的总结，结合自己辛苦画的图，详细的模板解说，希望自己以后回头看能一目了然，也对刚接触Km的人有帮助..
二分图学习记 之 KM算法 二分图最大权完美匹配。
weixin_30369087的博客
07-01 132
前置知识 ：匈牙利算法 首先有这样一张图，求这张图的最大权完美匹配。 当然如果你不想看这些渣图的话，您可以转到洛谷运动员最佳匹配问题 下面我来强行解释一下KM算法 左边一群妹子找汉子，但是每个妹子都对汉字的好感度不一样，我们首先看一看每个妹子的最大好感度[期望值]是多少，同时先暂时把汉字的最大好感度[期望值]设为0 现在妹子的梦想能不能实现呢，我们来看一看 NO.1给A找...
二分图的完全匹配---KM算法
热门推荐
知行合一
08-10 1万+
  写在之前：更多二分图知识，请关注---&gt;二分图知识导航篇   引述    KM算法全称Kuhn－Munkres，是一种求二分图完全、完美、最佳等匹配的方法，其实三个形容词都是指两个集内的所有顶点能够一一匹配，并且所获得的权值最大或最小。如果了解过，其实用最小费用最大流也可以，不过本文就讲解KM算法。在学习的时候，发现KM里面有几处思想挺难懂的，因为没见过吧，所以我将着重讲解下里面独特...
KM算法 详解+模板
Lazier’s blog
03-01 1031
//原文地址：http://blog.sina.com.cn/s/blog_691ce2b701016reh.html 【KM算法及其具体过程】 （1）可行点标：每个点有一个标号，记lx[i]为X方点i的标号，ly[j]为Y方点j的标号。如果对于图中的任意边(i, j,W)都有lx[i]+ly[j]>=W，则这一组点标是可行的。特别地，对于lx[i]+ly[j]=W的边(i, j,W)，称
匈牙利算法,KM算法详解及java实现
chengqing5496的博客
02-17 1018
匈牙利算法 基本概念 二分图:二分图又称为二部图.简单来说，如果图中点可以被分为两组，并且使得所有边都跨越组的边界，则这就是一个二分图。准确地说：把一个图的顶点划分为两个不相交集 U 和V ，使得每一条边都分别连接U、V中的顶点。如果存在这样的划分，则此图为一个二分图。二分图的一...
二分图最大权完美匹配（KM算法）
Khasehemwy的博客
07-04 1308
太难了,蒟蒻只能背模板 二分图最大匹配是寻找最大匹配数，用匈牙利算法。当连接的边带有权值时，要寻找匹配后权值和最大的方案，且保证A集合中的点均有B中的点能匹配。此时问题就转化为二分图最大权完美匹配。 KM算法核心为:为每一点添加顶标,在顶标的限制下用匈牙利算法处理出最大匹配数,若最大匹配数=n,则达到最优解,输出。否则修改顶标,再用匈牙利算法处理,如此重复。 参考：二分图最大权完美匹配 题解 (转载模板) 【模板】二分图最大权完美匹配 //Data const int N=500; int n,m,e[N+
二分图带权最大匹配-KM算法详解
EQUINOX1的博客
01-15 2236
找不到对象就降低期望（
图论- 二分图- KM 算法.rar
09-16
总结来说，图论中的二分图和KM算法是解决匹配问题的重要工具。KM算法通过迭代寻找增广路径来达到最大匹配，其高效性和广泛适用性使其在计算机科学的多个领域中都有着重要的应用。了解和掌握这些理论知识对于进行网络...
图论- 二分图- 匈牙利算法.rar
09-16
匈牙利算法，又称为Kuhn-Munkres算法或KM算法，是解决二分图最大匹配问题的一种高效算法。它由E.D. Kuhn和J.B. Munkres在1955年提出，能够找到二分图中最大的匹配，即最大化两个集合之间连接的边的数量。 最大匹配...
图论- 二分图.rar
09-16
二分图是图论中的一个重要概念，它是图论研究的基础之一，广泛应用于计算机科学、运筹学、社会科学等多个领域。本资料"图论- 二分图.rar"包含的PDF文档详细介绍了二分图的基本理论及其应用。 首先，我们要了解什么...
Python 图论算法实现工具——NetworkX1
08-03
【Python 图论算法实现工具——NetworkX1】这篇文章主要介绍了Python中用于图论算法实现的工具NetworkX。NetworkX是一个强大的Python软件包，专门用于处理复杂网络的结构、动力学和功能。它支持多种图类型，如无向图...
【总结】KM算法
cqbzlydd的博客
05-02 1286
upd on 2023/10/26 ：修改了代码和一些不知所云的内容。
二分图最佳完美匹配——KM算法
Martisum的博客
08-16 4221
前情概要 学km算法之前，笔者还是希望大家已经掌握了匈牙利算法——也就是对于求解二分图最大匹配的算法。学习本算法的前提除了已经掌握C++语言之外，还需要掌握邻接表存图法，不会的朋友这里有传送门 [微笑] 邻接表存图法 km算法是匈牙利算法的改进，他不仅仅继承了匈牙利算法的最大匹配，还可以让匹配后所有匹配边权重加起来最大或者最小——计算机算法总是寻找这些“最”。如果大家对什么是二分图或者什么是二分图...
【二分图最大权匹配---KM算法】
leolin_的专栏
08-23 752
转自百度百科 KM算法用来解决最大权匹配问题： 在一个二分图内，左顶点为X，右顶点为Y，现对于每组左右连接XiYj有权wij，求一种匹配使得所有wij的和最大。 基本原理 　　该算法是通过给每个顶点一个标号（叫做顶标）来把求最大权匹配的问题转
P6577 【模板】二分图最大权完美匹配
_Griefs
08-24 388
P6577 【模板】二分图最大权完美匹配 ①、进阶指南上说他的KM算法的时间复杂度是O（N3）的，其实分析一下，就可以发现，它的时间复杂度其实是O（N4）的，这题过不去。 只能过去四个点。 #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> #include<cmath> #include<queue> #include<set&gt
图论算法----二分图匹配----KM算法详解
cqbzcsq的博客
05-03 1967
一、相关概念 1.完美匹配 如果一个二分图，X部的每一个顶点都与Y部的一个顶点匹配，并且Y部的每一个顶点也与X部的一个顶点匹配，则该匹配为完美匹配。 2.完备匹配 如果一个二分图，X部的每一个顶点都与Y部的一个顶点匹配，或者Y部的每一个顶点也与X部的一个顶点匹配，则该匹配为完备匹配。完美匹配属于完备匹配。 3.最大权匹配 带权二分图的权值最大的匹配为最大权匹配。
【算法竞赛学习笔记】超有用的二分图详解！！！
SC_Linno的博客
10-26 688
title : 二分图 date : 2021-8-19 tags : ACM,图论 author : Linno 基础概念 二分图：又称为二部图，如果一个图G=(V,E)的顶点可以分为两个部分，对所有边，其两端点都处于不同的部分，那么这个图就是二分图。 若对于图G=(V,E)，存在V的一个划分(A,B),使∀(u,v)∈E,都有u∈A,v∈B或者u∈B，v∈A，则称图G为二分图 若对于图G=(V,E)，存在V的一个划分(A,B),使\forall(u,v)\in E,\\ 都有u\in A,v\in .
udp分片报文pcap文件
最新发布
07-18
udp分片报文pcap文件：64kudp大包分成每片658字节总计100片
【图】二分图最大匹配算法的应用及Matlab实现
06-08
好的，你的问题是关于二分图最大匹配算法的应用及Matlab实现。二分图最大匹配算法是在一个二分图中找到最大匹配的算法。它可以应用于很多领域，如计算机科学、图论、运筹学等。在计算机视觉中，它可以用于图像配对，物体识别等。在生物信息学中，它可以应用于DNA测序的比对等。 Matlab实现二分图最大匹配算法有很多种方法，其中最常用的是匈牙利算法。匈牙利算法是一种经典的二分图最大匹配算法，它的时间复杂度为O(n^3)，其中n为节点数。在Matlab中，可以通过实现匈牙利算法来求解二分图最大匹配问题。具体实现方法可以参考相关的资料或者代码库。 希望这个回答能够帮到你。如果你有其他问题，可以继续提出。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值