376. 机器任务

有两台机器 A，B 以及 K 个任务。

机器 A 有 N 种不同的模式（模式 0∼N−1），机器 B 有 M 种不同的模式（模式 0∼M−1）。

两台机器最开始都处于模式 0。

每个任务既可以在 A 上执行，也可以在 B 上执行。

对于每个任务 i，给定两个整数 a[i] 和 b[i]，表示如果该任务在 A 上执行，需要设置模式为 a[i]，如果在 B 上执行，需要模式为 b[i]。

任务可以以任意顺序被执行，但每台机器转换一次模式就要重启一次。

求怎样分配任务并合理安排顺序，能使机器重启次数最少。

输入格式

输入包含多组测试数据。

每组数据第一行包含三个整数 N,M,K。

接下来 K 行，每行三个整数 i,a[i] 和 b[i]，i 为任务编号，从 0 开始。

当输入一行为 0 时，表示输入终止。

输出格式

每组数据输出一个整数，表示所需的机器最少重启次数，每个结果占一行。

数据范围

N,M<100,K<1000
0≤a[i]<N
0≤b[i]<M

输入样例：

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

输出样例：

3

思路：

/*
3 最小点覆盖、最大独立集、最小路径点覆盖(最小路径重复点覆盖)
  最大匹配数 = 最小点覆盖 = 总点数 - 最大独立集 = 总点数 - 最小路径覆盖

匹配/匹配边: 与其他边没有公共节点的一条边, 我们称这条边为一个匹配/匹配边.
匹配点: 匹配边上的点
非匹配点: 不在匹配边上的点
非匹配边: 图中两点之间的边不是匹配边的边
最大匹配(匹配边数量的最大值): 最多连多少条边, 使得所有的边无公共点
⭐增广路(径): 一边的非匹配点到另一边的非匹配点的一条非匹配边和匹配边交替经过的路径. 
  通俗:由一个未匹配的顶点开始，经过若干个匹配顶点，最后到达对面集合的一个未匹配顶点的路径，即这条路径将两个不同集合的两个未匹配顶点通过一系列匹配顶点相连。
初始:匹配边为一根线(-),非匹配边为两根线(--)
1 o  -  o 2
     \/
     /\
3 o     o 4  

此时3->2->1->4就是一条 非匹配边上的点3->非匹配边上的点4的增广路径
通过该增广路径可以让3-2匹配,1-4匹配从而实现最大匹配

(只要有一条增广路径就能多一组匹配, 最大匹配 <=> 不存在增广路径)

最小点覆盖问题
定义: 给我们一个图, 从中选出最少的点, 使得图中的每一条边至少有一个顶点被选
三个匹配边 = 1(\),2(\),3(-) 
  o    o
     \1
  o    .  选出最少的点(标记为".") 使得每一条边的两个点中起码有一个被选
     /
    /
  o    o
     \2
  o    .
  . ——3o
    \
     \
      o
在二分图中
    最小点覆盖==最大匹配数
    证A = B
    则需证最小点覆盖A ≥ 最大匹配数B - 最大匹配m-最少要选m个点来覆盖m个边(匹配里两两没有交点)
          最大匹配数B = 最小点覆盖A等号可以成立 -  构造一种方案 --由于最小点覆盖是所有方案的最小值
构造:
1 求最大匹配(匈牙利)
2 从左边每个非匹配点{a,b}出发 向右边做一遍增广(两条横虚线- -)
  o    o
     \
 ao - -.  
     /
    /
  o    o
     \
 bo - -.
  . —— o
    \
     \
      o
3 标记所有经过的点 标记为。 而未被经过的点依然是o
  。   o
     \      -> e1
 a。- -。3 
     /
    /
  。   o
     \      -> e2
 b。- -。2
 1. —— o    -> e3
    \
     \
       oc
 左部所有未被标记的点{1}和右边所有被标记的点{2,3}
1 左边所有非匹配点一定都被标记了(它们是出发点) / 左边未被标记的点一定是匹配点(1)
2 右边所有非匹配点一定没被标记(否则就找到了增广路) / 右边所有被标记的点一定是匹配点(2,3)
    回顾增广路定义:从左边非匹配点->右边非匹配点的路径
                    而被标记代表从左边非匹配点出发走到了右边的非匹配点
3 对于匹配边 左右两个点要么同时被标记 要么同时不被标记(因为在寻找增广路的过程中，左部匹配点只能通过右部到达。)
⭐对每个匹配边必然只选一个点 - 选右边被标记的点{2,3}/选左边没被标记的点{1}
    此时:我们选的点(.)的数量==匹配数(e1、e2、e3)


0 首先定义当前满足假设:左边右边都在匹配边肯定是被最大匹配树中得匹配边覆盖的
不在匹配中的点所在的边是否被最大匹配数中的匹配边覆盖？
1 左边非匹配点i → 右边匹配点j (如边a-3,边b-2)
    因为i是出发点，所以j一定被标记。而我们选了右部所有被标记的点(⭐处)，因此这样的边也被覆盖。
2 左边匹配点i    → 右边非匹配点j(如边1-c 右边非匹配点==未被标记的点)
    i一定没有被标记，否则再走到j就找到了增广路。而我们选了左部所有未被标记的点(⭐处)，因此这样的边也被覆盖。
    画出i被标记的例子就可说明为什么
 0。-- 。 ->被标记的点都是能从左边非匹配点0出发经过i后才标记i的
     /       如果能从i->j,则说明找到一条0-j的增广路,则可以多出一条匹配边 
    /        与最大匹配矛盾
 i。—— o 
    \
     \
       o j
3 左边右边都不匹配(此时可以在最大匹配加一条新的边) -- 这和当前这个匹配是最大匹配矛盾

因此 我们构造出的情况恰好选3个点且将最大3条匹配边覆盖住
*/

代码：

/*
本题
a[i]=0 || b[i]=0时可以跳过
一个任务i可以被A、B机器的两种状态a[i]、b[i]完成，将一个任务看成一条边，两种状态看成两个端点，
要完成一个任务就要从这两个点中选一个点(任务可以在A上执行也可以在B上执行)，
对于所有任务就要从N+M-2个点中(不包含初始0状态)选出最少的点，覆盖所有的边(任务)，
问题就变成求最小点覆盖问题(二分图中最小点覆盖等价于最大匹配数--匈牙利算法)。
*/


#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m, k;
int match[N];
bool g[N][N], st[N];

bool find(int x)
{
    for (int i = 1; i < m; i++)
    {
        if (!st[i] && g[x][i])
        {
            st[i] = 1;
            if (match[i] == -1 || find(match[i]))
            {
                match[i] = x;
                return true;
            }
        }
    }

    return false;
}

int main()
{
    while (cin >> n, n)
    {
        cin >> m >> k;
        memset(g, 0, sizeof g);
        memset(match, -1, sizeof match);
        while (k--)
        {
            int t, a, b;
            cin >> t >> a >> b;
            if (!a || !b)
                continue;
            g[a][b] = true;
        }

        int res = 0;
        for (int i = 1; i < n; i++)
        {
            memset(st, 0, sizeof st);
            // 当前的i必定是没有对象的
            if (find(i))
                res++;
        }
        cout << res << endl;
    }

    return 0;
}