二分圖簡單模擬題 POJ 1274、1325、1469、2446

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;
}