匈牙利算法（图论中寻找最大匹配的算法）-群体智能-多机协同开发有备无患

匈牙利算法是一种在多项式时间内求解任务分配问题的组合优化算法，并推动了后来的原始对偶方法。1955年，库恩(W.W.Kuhn)利用匈牙利数学家康尼格(D.Kőnig)的一个定理构造了这个解法，故称为匈牙利法。 [2] 

 邻接矩阵-C

#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

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（使用动态链表）

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++

#include<iostream>
#include<cstring>
 
using namespace std;
 
//定义链表
struct link{
    int data;//存放数据
    link*next;//指向下一个节点
    link(int=0);
};
 
link::link(int n){
    data=n;
    next=NULL;
}
 
int n1,n2,m,ans=0;
int result[101];//记录n1中的点匹配的点的编号
bool state[101];//记录n1中的每个点是否被搜索过
link*head[101];//记录n2中的点的邻接节点
link*last[101];//邻接表的终止位置记录
 
//判断能否找到从节点n开始的增广路
bool find(const int n){
    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
                return true;//返回匹配成功的标志
            }
        }
        t=t->next;//继续查找下一个n的邻接节点
    }
    return false;
}
int main(){
    int t1=0,t2=0;
    cin>>n1>>n2>>m;
    for(int i=0;i<m;i++){
        cin>>t1>>t2;
        if(last[t1]==NULL)
            last[t1]=head[t1]=new link(t2);
        else
            last[t1]=last[t1]->next=new link(t2）；
    }
    for(int i=1;i<=n1;i++){
        memset(state,0,sizeof(state));
        if(find(i))ans++;
    }
    cout<<ans<<endl;
    return 0;
}

邻接矩阵-C++

#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()
{
    int n1,n2;
    while(cin>>n1 >>n2 >>m)
    {
        n=n1;
        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;
}

概念

参考文献：

匈牙利算法-看这篇绝对就够了！_土豆钊的博客-CSDN博客_匈牙利算法

(二)匈牙利算法简介_恒友成的博客-CSDN博客_匈牙利算法

趣写算法系列之--匈牙利算法_Dark_Scope的博客-CSDN博客