匈牙利算法，百度

来源：互联网发布：范冰冰演技知乎编辑：程序博客网时间：2024/06/07 07:54

匈牙利算法

中文名: 匈牙利算法
外文名: Hungary

提出者: Edmonds
提出时间: 1965
算法的核心: 寻找增广路径

简介

编辑

设

是一个无向图。如顶点集V可分割为两个互不相交的子集

，选择这样的子集中边数最大的子集称为图的最大匹配问题（maximal matching problem)。

如果一个匹配中，

且匹配数

，则称此匹配为完全匹配，也称作完备匹配。特别的当

称为完美匹配。

概念

编辑

在介绍匈牙利算法之前还是先提一下几个概念，下面M是G的一个匹配。

若

，

，其中边

已经在匹配M上。

M-交错路：p是G的一条通路，如果p中的边为属于M中的边与不属于M但属于G中的边交替出现，则称p是一条M-交错路。如：路径

，

。

M-饱和点：对于

，如果v与M中的某条边关联，则称v是M-饱和点，否则称v是非M-饱和点。如

都属于M-饱和点，而其它点都属于非M-饱和点。

M-可增广路：p是一条M-交错路，如果p的起点和终点都是非M-饱和点，则称p为M-可增广路。如

（不要和流网络中的增广路径弄混了）。

求最大匹配的一种显而易见的算法是：先找出全部匹配，然后保留匹配数最多的。但是这个算法的时间复杂度为边数的指数级函数。因此，需要寻求一种更加高效的算法。下面介绍用增广路求最大匹配的方法（称作匈牙利算法，匈牙利数学家Edmonds于1965年提出）。

增广路的定义（也称增广轨或交错轨）：

若P是图G中一条连通两个未匹配顶点的路径，并且属于M的边和不属于M的边（即已匹配和待匹配的边)在P上交替出现，则称P为相对于M的一条增广路径。

由增广路的定义可以推出下述三个结论：

（1）P的路径个数必定为奇数，第一条边和最后一条边都不属于M。

（2）将M和P进行取反操作可以得到一个更大的匹配

。

（3）M为G的最大匹配当且仅当不存在M的增广路径。

算法轮廓：

（1）置M为空

（2）找出一条增广路径P，通过异或操作获得更大的匹配

代替M

（3）重复（2）操作直到找不出增广路径为止

复杂度

编辑

时间复杂度邻接矩阵：最坏为

邻接表：

空间复杂度邻接矩阵：

邻接表：

样例程序

编辑

格式说明

输入格式：

第1行3个整数，

的节点数目

,G的边数m

第2-m+1行，每行两个整数

，代表

中编号为

的点和

中编号为

的点之间有边相连

输出格式：

1个整数ans，代表最大匹配数

邻接矩阵-C

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include<stdio.h>
#include<string.h>
int n1, n2, m, ans;
int result[101];//记录V2中的点匹配的点的编号
bool state[101];//记录V2中的每个点是否被搜索过
bool data[101][101];//邻接矩阵true代表有边相连
void init()
{
    int t1, t2;
    memset(data, 0, sizeof(data));
    memset(result, 0, sizeof(result));
    ans = 0;
    scanf("%d%d%d", &n1, &n2, &m);
 
    for(int i = 1; i <= m; i++)
    {
        scanf("%d%d", &t1, &t2);
        data[t1][t2] = true;
    }
 
    return;
}
bool find(inta)
{
    for(int i = 1; i <= n2; i++)
    {
        if(data[a][i] == 1 && !state[i]) //如果节点i与a相邻并且未被查找过
        {
            state[i] = true; //标记i为已查找过
 
            if(result[i] == 0 //如果i未在前一个匹配M中
                || find(result[i])) //i在匹配M中，但是从与i相邻的节点出发可以有增广路
            {
                result[i] = a; //记录查找成功记录
                 
                return true;//返回查找成功
            }
        }
    }
 
    return false;
}
int main()
{
    init();
 
    for(int i = 1; i <= n1; i++)
    {
        memset(state, 0, sizeof(state)); //清空上次搜索时的标记
        if(find(i))
        {
            ans++;    //从节点i尝试扩展
        }
    }
 
    printf("%d\n", ans);
    return 0;
}

邻接矩阵-pascal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
Programhungary;
Const
max=100;
Var
data:array[1..max,1..max]ofboolean;{邻接矩阵}
result:array[1..max]ofinteger;{记录当前连接方式}
state:array[1..max]ofboolean;{记录是否遍历过，防止死循环}
m,n1,n2,i,t1,t2,ans:integer;
Function dfs(p:integer):boolean;
var
i:integer;
begin
for i:=1 to n2 do
if data[p,i]and not(state[i]) then{有边存在且没有被搜索过}
begin
state[i]:=true;
if (result[i]=0)or dfs(result[i]) then{没有被连过或寻找到增广路}
begin
result[i]:=p;
exit(true);
end;
end;
exit(false);
end;
begin
readln(n1,n2,m);
fillchar(data,sizeof(data),0);
fori:=1 to mdo
begin
readln(t1,t2）；
data[t1,t2]:=true;
end;
fillchar(result,sizeof(result),0);
ans:=0;
fori:=1 to n1 do
begin
fillchar(state,sizeof(state),0);
if dfs(i) then inc(ans);
end;
writeln(ans);
end.

邻接表-pascal（使用动态链表）

（方法基于之前的邻接矩阵-pascal）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
programhungarian_algorithm;//匈牙利算法
type
node=^link;//链表定义
link=record
g:longint;//指向节点
next:node;
end;
var
n1,n2,m,a,v1,v2,ans:longint;
flag:array[1..1000000]ofboolean;//记录在main递归过程中是否已访问过，防止死循环
nd:array[1..1000000]ofnode;//邻接表
resultt:array[1..1000000]oflongint;//记录v2中节点的最终匹配于v1中的几号节点
functionmain(wei:longint):boolean;
varp:node;
begin
p:=nd[wei];
whilep<>nildo
begin
ifflag[p^.g]{没有被搜索过}
thenbegin
flag[p^.g]:=false;
if(resultt[p^.g]=0)or(main(resultt[p^.g])){没有被连过或原来指向的节点寻找到新的增广路}
thenbegin
resultt[p^.g]:=wei;
exit(true);
end;
end;
p:=p^.next;
end;
exit(false)
end;
procedureaddd(v1,v2:longint);//建立邻接表过程
varp:node;
begin
new(p);
p^.g:=v2;
p^.next:=nd[v1];
nd[v1]:=p;
end;
begin
readln(n1,n2,m);
fora:=1tomdo
begin
readln(v1,v2);
addd(v1,v2);
end;
ans:=0;
fillchar(resultt,sizeof(resultt),0);
fora:=1ton1do
begin
fillchar(flag,sizeof(flag),true);
ifmain(a)
theninc(ans);
end;
writeln(ans);
fora:=1ton2do
ifresultt[a]<>0
thenwriteln(resultt[a],'---',a);
end.

邻接表-C++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include<iostream>
#include<cstring>
usingnamespacestd;
//定义链表
structlink{
intdata;//存放数据
link*next;//指向下一个节点
link(int=0);
};
link::link(intn){
data=n;
next=NULL;
}
intn1,n2,m,ans=0;
intresult[101];//记录n1中的点匹配的点的编号
boolstate[101];//记录n1中的每个点是否被搜索过
link*head[101];//记录n2中的点的邻接节点
link*last[101];//邻接表的终止位置记录
//判断能否找到从节点n开始的增广路
boolfind(constintn){
link*t=head[n];
while(t!=NULL){//n仍有未查找的邻接节点时
if(!(state[t->data])){//如果邻接点t->data未被查找过
state[t->data]=true;//标记t->data为已经被找过
if((result[t->data]==0)||//如果t->data不属于前一个匹配M
(find(result[t->data]))){//如果t->data匹配到的节点可以寻找到增广路
result[t->data]=n;//那么可以更新匹配M'，其中n1中的点t->data匹配n
returntrue;//返回匹配成功的标志
}
}
t=t->next;//继续查找下一个n的邻接节点
}
returnfalse;
}
intmain(){
intt1=0,t2=0;
cin>>n1>>n2>>m;
for(inti=0;i<m;i++){
cin>>t1>>t2;
if(last[t1]==NULL)
last[t1]=head[t1]=newlink(t2);
else
last[t1]=last[t1]->next=newlink(t2）；
}
for(inti=1;i<=n1;i++){
memset(state,0,sizeof(state));
if(find(i))ans++;
}
cout<<ans<<endl;
return0;
}

邻接矩阵-C++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include<iostream>
#include<cstring>
using namespace std;
int map[105][105];
int visit[105],flag[105];
int n,m;
bool dfs(int a)
{
    for(int i=1; i<=n; i++)
    {
        if(map[a][i]&&!visit[i])
        {
            visit[i]=1;
            if(flag[i]==0||dfs(flag[i]))
            {
                flag[i]=a;
                return true;
            }
        }
    }
    return false;
}
int main()
{
    while(cin>>n1 >>n2 >>m)
    {
        memset(map,0,sizeof(map));
        for(int i=1; i<=m; i++)
        {
            int x,y;
            cin>>x>>y;
            map[x][y]=1;
        }
        memset(flag,0,sizeof(flag));
        int result=0;
        for(int i=1; i<=n1; i++)
        {
            memset(visit,0,sizeof(visit));
            if(dfs(i))result++;
        }
        cout<<result<<endl;
    }
    return 0;
}

阅读全文

0 0