Poj(1325)，最小点覆盖

题目链接：http://poj.org/problem?id=1325

Machine Schedule

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 14216		Accepted: 6075

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

Source

Beijing 2002

 

题意：有两个机器A和B，A机器有n个模式，B机器有m个模式,两个机器最初在0模式然后有k个作业，每个作业有三个参数i，a，b，i代表作业编号，a和b代表第i作业要么在A机器的a模式下完成，或者在B机器的b模式下完成，问两个机器总共最少变换多少次可以完成所有作业

 

分析：

最小点覆盖，刚开始是出于0状态下，因此要删掉0与其他点的边，两个集合都要，或者是，都从1开始扫。

然后是：

最小点覆盖 = 最大匹配；

证明：我没退出来，看了网上的证明，很有道理。

首先，最小点集覆盖一定>=最大匹配，因为假设最大匹配为n，那么我们就得到了n条互不相邻的边，光覆盖这些边就要用到n个点。现在我们来思考为什么 最小点击覆盖一定<=最大匹配。任何一种n个点的最小点击覆盖，一定可以转化成一个n的最大匹配。因为最小点集覆盖中的每个点都能找到至少一条只有 一个端点在点集中的边（如果找不到则说明该点所有的边的另外一个端点都被覆盖，所以该点则没必要被覆盖，和它在最小点集覆盖中相矛盾），只要每个端点都选 择一个这样的边，就必然能转化为一个匹配数与点集覆盖的点数相等的匹配方案。所以最大匹配至少为最小点集覆盖数，即最小点击覆盖一定<=最大匹配。 综上，二者相等。

#include <stdio.h>
#include <string.h>

int n,m,k;
bool maps[105][105];
int match[1050];
bool use[1050];

bool DFS(int u)
{
    for(int i=1;i<m;i++)
    {
        if(!use[i]&&maps[u][i])
        {
            use[i] = true;
            if(match[i]==-1||DFS(match[i]))
            {
                match[i] = u;
                return true;
            }
        }
    }
    return false;
}


int main()
{
    while(scanf("%d",&n))
    {
        if(n==0) break;
        scanf("%d%d",&m,&k);
        memset(maps,false,sizeof(maps));
        memset(match,-1,sizeof(match));

        for(int i=0;i<k;i++)
        {
            int t,a,b;
            scanf("%d%d%d",&t,&a,&b);
            maps[a][b] = true;
        }
        /*for(int i=0;i<m;i++)
        {
            if(maps[0][i])
                maps[0][i] = false;
        }
        for(int i=0;i<n;i++)
        {
            if(maps[i][0])
                maps[i][0] = false;
        }*/
        int num = 0;
        for(int i=1;i<n;i++)
        {
            memset(use,false,sizeof(use));
            if(DFS(i))
                num++;
        }
        printf("%d
",num);
    }
    return 0;
}