HDU 1150 Machine Schedule（最小点覆盖）

Description





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 mode0 , mode1 , ... , moden-1 , likewise machine B has m kinds
of working modes, mode0 , mode1 , ... , modem-1 . At the beginning they are both work at mode0 .
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 mode3 or
in machine B at mode4 , job 1 can either be processed in machine A at mode2 or in machine B atmode4 ,
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 machineA at modex ,
or in machine B at modey .
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

题意：有很多种零件，每种零件可用A或者B机器的某一种状态完成，A B机器有n和m种状态，初始状态为0，每变一次状态花费为1，求完成所有零件的最小花费为多少。

这题用二分匹配可解。想一想，每一种零件要么用A要么用B，如果将A和B的状态看做是点。相当于是对于当前零件，A的一个状态和B的一个状态之间有一条边，需要求解的就是能够将所有的边覆盖所需要的最少的点的数量，即为最小点覆盖。而最小点覆盖，其实就是匈牙利算法的最大二分匹配。

有一个地方要注意的是，初始状态为0，也就是说如果0可以覆盖边的话，其实是没有花费的。所以在代码中，虽然A和B的状态是从0~（n-1）,0~（m-1），但我的处理其实是从1~（n-1）和1~（m-1）。

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int n,m,k,be[105];
bool flag[105][105],vis[105];
bool erfen(int id)
{
for(int i=1;i<m;i++)
{
if(flag[id][i]&&!vis[i])
{
vis[i]=true;
if(be[i]==-1||erfen(be[i]))
{
be[i]=id;
return true;
}
}
}
return false;
}
int main()
{
while(~scanf("%d",&n),n)
{
scanf("%d%d",&m,&k);
memset(flag,false,sizeof(flag));
memset(be,-1,sizeof(be));
for(int i=0;i<k;i++)
{
int l,x,y;
scanf("%d%d%d",&l,&x,&y);
flag[x][y]=true;
}
int ans=0;
for(int i=1;i<n;i++)
{
memset(vis,false,sizeof(vis));
if(erfen(i))
ans++;
}
printf("%d\n",ans);
}
return 0;
}