二分图——（最大匹配，最小顶点覆盖两者相应例题--POJ1469 POJ1325 基础例题）

参考博客：

（二分图的相关概念+匈牙利算法  简单清楚的介绍）

https://blog.csdn.net/qq_41829060/article/details/92180709

推荐博客

《Hall定理（二分图匹配问题，Hungary算法基础）》：

https://blog.csdn.net/Feynman1999/article/details/76037603

 

1、二分图：

设G=(V,E)是一个图，图的顶点集合可以分为两个集合V1，V2，E中的每个边都有一个点要么属于

点集V1，另一个属于点集V2。

 

2、二分图的最大匹配：

（1）匹配：一条边就是一个匹配，就是两个点通过一条边来匹配，并且匹配的边的集合中任意两条边都不相连。

（2）最大匹配：一个图能够包含的包含边最多的边的集合。

（3）二分图的最大匹配：二分图中能够包含的最大匹配。

 

3、二分图的最小顶点覆盖：

（1）定义：二分图的最小顶点覆盖就是（一个点就能覆盖它所在的边），所以二分图的最小顶点覆盖就是

选择最少数量的顶点覆盖所有的边。

（2）二分图的最小顶点覆盖  = 二分图的最大匹配。

 

4、二分图的最大独立集

（1）定义：从二分图中选出一些点，使这些点两两互不相邻。

（2）最大独立集 = 二分图的顶点数量 - 二分图的最小顶点覆盖。
 

 

POJ1469    COURSES

Description

Consider a group of N students and P courses. Each student visits zero, one or more than one courses. Your task is to determine whether it is possible to form a committee of exactly P students that satisfies simultaneously the conditions:

• 
  
• every student in the committee represents a different course (a student can represent a course if he/she visits that course)
• each course has a representative in the committee

Input

Your program should read sets of data from the std input. The first line of the input contains the number of the data sets. Each data set is presented in the following format:

P N
Count1 Student1 1 Student1 2 ... Student1 Count1
Count2 Student2 1 Student2 2 ... Student2 Count2
...
CountP StudentP 1 StudentP 2 ... StudentP CountP

The first line in each data set contains two positive integers separated by one blank: P (1 <= P <= 100) - the number of courses and N (1 <= N <= 300) - the number of students. The next P lines describe in sequence of the courses �from course 1 to course P, each line describing a course. The description of course i is a line that starts with an integer Count i (0 <= Count i <= N) representing the number of students visiting course i. Next, after a blank, you抣l find the Count i students, visiting the course, each two consecutive separated by one blank. Students are numbered with the positive integers from 1 to N.
There are no blank lines between consecutive sets of data. Input data are correct.

Output

The result of the program is on the standard output. For each input data set the program prints on a single line "YES" if it is possible to form a committee and "NO" otherwise. There should not be any leading blanks at the start of the line.

Sample Input

2
3 3
3 1 2 3
2 1 2
1 1
3 3
2 1 3
2 1 3
1 1

Sample Output

YES
NO

#include<iostream>
#include<vector>
#include<cstdio>
#include<cstring>  //以课程为左集合  学生为右集合   求左集合到右集合的最大匹配
#define maxp 105    //课程数（1<=P<=100）
#define maxn 305    //学生数(1<=N<=300)
using namespace std;
int match[maxn];//记录学生i匹配的课程,若还未匹配，则match[i]=-1
vector<int>g[maxp];//vector实现邻接表存图   存储课程对应的学生
bool used[maxn];//记录学生是否已经匹配
int n,p;
bool dfs(int x)   //寻找增广路径
{
	for(int i=0;i<g[x].size();i++)
	{
		int v=g[x][i];
		if(used[v]==false)
		{
			used[v]=true;

			if(match[v]==-1||dfs(match[v]))//如果match[i]==-1,表明右集合中的v未覆盖，即有学生未匹配，否则向下继续搜索，（匈牙利算法里的递归流程，关键思想归为“腾”）
			{
				match[v]=x;
				return true;
			}
		}
	}
	return false;
}
int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		scanf("%d%d",&p,&n);
		for(int i=0;i<=p;i++)  g[i].clear();
		for(int i=0;i<p;i++)
		{
			int s;
			scanf("%d",&s);
			while(s--)
			{
				int v;
				scanf("%d",&v);
				g[i].push_back(v);

			}
		}
		int cnt=0;  //记录左集合（课程）的匹配数
		memset(match,-1,sizeof(match));
		for(int i=0;i<p;i++)
		{
                   //每次dfs一门课程时都将used重新设为false     开始想得不太清楚
			memset(used,false,sizeof(used));
			if(dfs(i)) cnt++;

		}
		if(cnt==p)
		printf("YES\n");
	   else
		printf("NO\n");

	}

	return 0;

}

 POJ1325    Machine Schedule  

 

As we all know, machine scheduling is a very classical problem in computer science and has been studied for a very long history. Scheduling problems differ widely in the nature of the constraints that must be satisfied and the type of schedule desired. Here we consider a 2-machine scheduling problem.

There are two machines A and B. Machine A has n kinds of working modes, which is called mode_0, mode_1, ..., mode_n-1, likewise machine B has m kinds of working modes, mode_0, mode_1, ... , mode_m-1. At the beginning they are both work at mode_0.

For k jobs given, each of them can be processed in either one of the two machines in particular mode. For example, job 0 can either be processed in machine A at mode_3 or in machine B at mode_4, job 1 can either be processed in machine A at mode_2 or in machine B at mode_4, and so on. Thus, for job i, the constraint can be represent as a triple (i, x, y), which means it can be processed either in machine A at mode_x, or in machine B at mode_y.

Obviously, to accomplish all the jobs, we need to change the machine's working mode from time to time, but unfortunately, the machine's working mode can only be changed by restarting it manually. By changing the sequence of the jobs and assigning each job to a suitable machine, please write a program to minimize the times of restarting machines.

Input

The input file for this program consists of several configurations. The first line of one configuration contains three positive integers: n, m (n, m < 100) and k (k < 1000). The following k lines give the constrains of the k jobs, each line is a triple: i, x, y.

The input will be terminated by a line containing a single zero.

Output

The output should be one integer per line, which means the minimal times of restarting machine.

Sample Input

5 5 10
0 1 1
1 1 2
2 1 3
3 1 4
4 2 1
5 2 2
6 2 3
7 2 4
8 3 3
9 4 3
0

Sample Output

3

二分图的最小顶点覆盖=二分图的最大匹配 （与上题完全同理，匈牙利算法----递归寻找增广路径）

（想了。。。。很久还不是很清楚等式取等号的原理以及抽象点和边的理解） 

本题把两台机器的每个模式看成一个点，则在每个作用在两台机器的不同模式之间连一条边。则看成最小顶点覆盖，在二分图中，又有二分图的最小顶点覆盖=二分图的最大匹配 成立。

#include<iostream>
#include<vector>
#include<cstdio>
#include<cstring>
const int maxn=110;         
int uN,vN;
using namespace std;
int g[maxn][maxn];           //此题数据较小，可用邻接矩阵表示
int match[maxn];
bool used[maxn];
bool dfs(int u)
{
	for(int v=0;v<vN;v++)
	if(g[u][v]&&!used[v])
	{
		used[v]=true;
		if(match[v]==-1||dfs(match[v]))
		{
			match[v]=u;
			return true;
		}
	}
	return false;
}
int hungary()                          //可去了解hall定理，Huangary算法基础
{
	int res=0;
	memset(match,-1,sizeof(match));
	for(int u=0;u<uN;u++)
	{
		memset(used,0,sizeof(used));
		if(dfs(u))res++;
		
	}
	return res;
	
}
int main()
{
	int i, k,u,v;
	while(scanf("%d",&uN),uN)
	{
		scanf("%d%d",&vN,&k);
		memset(g,0,sizeof(g));
		while(k--)
		{
			scanf("%d%d%d",&i,&u,&v);
			if(u>0&&v>0)g[u][v]=1;
		}
		printf("%d\n",hungary());
	}
	return 0;
}