POJ 1274
#include<stdio.h>
#include<memory.h>
#define MAX 202
bool flag,visit[MAX]; //記錄V2中的某個點是否被搜索過
int match[MAX]; //記錄與V2中的點匹配的點的編號
int cow, stall; //二分圖中左邊、右邊集合中頂點的數目
int head[MAX];
struct edge
{
int to,next;
}e[3000];
int index;
void addedge(int u,int v)
{ //向圖中加邊的算法,注意加上的是有向邊
//u爲v的後續節點既是v---->u
e[index].to=v;
e[index].next=head[u];
head[u]=index;
index++;
}
// 匈牙利(鄰接表)算法
bool dfs(int u)
{
int i,v;
for(i = head[u]; i != 0; i = e[i].next)
{
v = e[i].to;
if(!visit[v]) //如果節點v與u相鄰並且未被查找過
{
visit[v] = true; //標記v爲已查找過
if(match[v] == -1 || dfs(match[v])) //如果i未在前一個匹配M中,或者i在匹配M中,但是從與i相鄰的節點出發可以有增廣路徑
{
match[v] = u; //記錄查找成功記錄,更新匹配M(即“取反”)
return true; //返回查找成功
}
}
}
return false;
}
int MaxMatch()
{
int i,sum=0;
memset(match,-1,sizeof(match));
for(i = 1 ; i <= cow ; ++i)
{
memset(visit,false,sizeof(visit)); //清空上次搜索時的標記
if( dfs(i) ) //從節點i嘗試擴展
{
sum++;
}
}
return sum;
}
int main(void)
{
int i,j,k,ans,m;
while (scanf("%d %d",&cow, &stall)!=EOF)
{
memset(head,0,sizeof(head)); //切記要初始化
index = 1;
for (i = 1; i <= cow; ++i)
{
scanf("%d",&k);
for (j = 0; j < k; ++j)
{
scanf("%d",&m);
addedge(i , m);
}
}
ans = MaxMatch();
printf("%d\n",ans);
}
return 0;
}
POJ 1325
#include<stdio.h>
#include<memory.h>
#define MAX 105
bool visit[MAX]; //記錄V2中的某個點是否被搜索過
int match[MAX]; //記錄與V2中的點匹配的點的編號
int n,m; //二分圖中左邊、右邊集合中頂點的數目
int head[MAX];
struct edge
{
int to,next;
}e[1005];
int index;
void addedge(int u,int v)
{ //向圖中加邊的算法,注意加上的是有向邊
//u爲v的後續節點既是v---->u
e[index].to=v;
e[index].next=head[u];
head[u]=index;
index++;
}
// 匈牙利(鄰接表)算法
bool dfs(int u)
{
int i,v;
for(i = head[u]; i != 0; i = e[i].next)
{
v = e[i].to;
if(!visit[v]) //如果節點v與u相鄰並且未被查找過
{
visit[v] = true; //標記v爲已查找過
if(match[v] == -1 || dfs(match[v])) //如果i未在前一個匹配M中,或者i在匹配M中,但是從與i相鄰的節點出發可以有增廣路徑
{
match[v] = u; //記錄查找成功記錄,更新匹配M(即“取反”)
return true; //返回查找成功
}
}
}
return false;
}
int MaxMatch()
{
int i,sum=0;
memset(match,-1,sizeof(match));
for(i = 1 ; i < n ; ++i)
{
memset(visit,false,sizeof(visit)); //清空上次搜索時的標記
if( dfs(i) ) //從節點i嘗試擴展
{
sum++;
}
}
return sum;
}
int main(void)
{
int i,j,k,ans,y,x;
while (scanf("%d",&n),n)
{
scanf("%d %d",&m,&k);
index = 1;
memset(head,0,sizeof(head)); //切記要初始化
for (i = 1; i <= k; ++i)
{
scanf("%d %d %d",&j,&x,&y);
if(x && y)
addedge(x,y);
}
ans = MaxMatch();
printf("%d\n",ans);
}
return 0;
}
POJ 1469
//poj_1469
/*==================================================*\
| 二分圖匹配(匈牙利算法DFS 實現)
| INIT: g[][]鄰接矩陣;
| 優點:實現簡潔容易理解,適用於稠密圖,DFS找增廣路快。
| 找一條增廣路的複雜度爲O(E),最多找V條增廣路,故時間複雜度爲O(VE)
==================================================*/
#include<stdio.h>
#include<memory.h>
bool g[110][310]; //鄰接矩陣,true代表有邊相連
bool flag,visit[310]; //記錄V2中的某個點是否被搜索過
int match[310]; //記錄與V2中的點匹配的點的編號
int p,n; //二分圖中左邊、右邊集合中頂點的數目
// 匈牙利算法
bool dfs(int u)
{
for (int i = 1; i <= n; ++i)
{
if (g[u][i] && !visit[i]) //如果節點i與u相鄰並且未被查找過
{
visit[i] = true; //標記i爲已查找過
if (match[i] == -1 || dfs(match[i])) //如果i未在前一個匹配M中,或者i在匹配M中,但是從與i相鄰的節點出發可以有增廣路徑
{
match[i] = u; //記錄查找成功記錄,更新匹配M(即“取反”)
return true; //返回查找成功
}
}
}
return false;
}
int main(void)
{
int i,j,k,t,v,ans;
scanf("%d",&t);
while (t--)
{
scanf("%d %d", &p, &n);
for (i = 1; i <= p; i++)
{
for (j = 1; j <= n; j++)
g[i][j] = false;
}
for (i = 1; i <= n; i++)
match[i] = -1;
flag = true;
for (i = 1; i <= p; i++)
{
scanf("%d",&k);
if (k == 0)
flag = false;
while (k--)
{
scanf("%d",&v);
g[i][v] = true;
}
}
if (flag)
{
ans = 0;
for (i = 1; i <= p; i++)
{
memset(visit,false,sizeof(visit)); //清空上次搜索時的標記
if(dfs(i)) //break;//從節點i嘗試擴展
ans++;
}
//if (i>p)
if(ans==p)
puts("YES");
else
puts("NO");
}
else
puts("NO");
}
return 0;
}
POJ 2446
//poj_2446
/*==================================================*\
| 二分圖匹配(匈牙利算法DFS 實現)
| 鄰接表方法來實現;
| 優點:實現簡潔容易理解,適用於稠密圖,DFS找增廣路快。
| 找一條增廣路的複雜度爲O(E),最多找V條增廣路,故時間複雜度爲O(VE)
==================================================*/
#include<stdio.h>
#include<memory.h>
#define MAX 1089 //33*33
bool flag,visit[MAX]; //記錄V2中的某個點是否被搜索過
int match[MAX]; //記錄與V2中的點匹配的點的編號
int cnt; //二分圖中左邊、右邊集合中頂點的數目
bool hole[MAX][MAX];
int id[MAX][MAX];
int head[MAX];
struct edge
{
int to,next;
}e[100005];
int index;
void addedge(int u,int v)
{ //向圖中加邊的算法,注意加上的是有向邊
//u爲v的後續節點既是v---->u
e[index].to=v;
e[index].next=head[u];
head[u]=index;
index++;
}
// 匈牙利(鄰接表)算法
bool dfs(int u)
{
int i,v;
for(i = head[u]; i != 0; i = e[i].next)
{
v = e[i].to;
if(!visit[v]) //如果節點v與u相鄰並且未被查找過
{
visit[v] = true; //標記v爲已查找過
if(match[v] == -1 || dfs(match[v])) //如果i未在前一個匹配M中,或者i在匹配M中,但是從與i相鄰的節點出發可以有增廣路徑
{
match[v] = u; //記錄查找成功記錄,更新匹配M(即“取反”)
return true; //返回查找成功
}
}
}
return false;
}
int MaxMatch()
{
int i,sum=0;
memset(match,-1,sizeof(match));
for(i = 1 ; i <= cnt ; ++i)
{
memset(visit,false,sizeof(visit)); //清空上次搜索時的標記
if( dfs(i) ) //從節點i嘗試擴展
{
sum++;
}
}
return sum;
}
int main(void)
{
int i,j,k,m,n,ans,y,x;
while (scanf("%d %d %d",&m,&n,&k)!=EOF)
{
memset(hole,false,sizeof(hole));
for (i = 1; i <= k; ++i)
{
scanf("%d %d",&y,&x);
hole[x][y] = true;
}
if((m*n-k)&1) //奇偶剪枝
{
puts("NO");
continue;
}
cnt = 0;
index = 1;
for (i = 1; i <= m; ++i)
{
for (j = 1; j <= n; ++j)
{
if(hole[i][j] == false) //對沒有塗黑的點進行標號
{
id[i][j] = ++cnt;
}
}
}
memset(head,0,sizeof(head)); //切記要初始化
for (i = 1; i <= m; ++i)
{
for (j = 1; j <= n; ++j)
{
if(hole[i][j] == false)
{
if(i-1>0 && hole[i-1][j] == false) //建圖。。要注意邊界問題
addedge(id[i][j],id[i-1][j]);
if(i+1<=m && hole[i+1][j] == false)
addedge(id[i][j],id[i+1][j]);
if(j-1>0 && hole[i][j-1] == false)
addedge(id[i][j],id[i][j-1]);
if(j+1<=n && hole[i][j+1] == false)
addedge(id[i][j],id[i][j+1]);
}
}
}
ans = MaxMatch();
if (ans == cnt)
puts("YES");
else
puts("NO");
}
return 0;
}