HDU - 1150 最小顶点覆盖

题意：

工厂有两个机器A和B，两个机器分别有n，m种工作模式，现在有k种工作，每种工作可以在A的x[i]模式下完成，也可以在B的y[i]模式下完成，在可以调整任务执行顺序的情况下，如何分配任务可以使得调整机器模式的次数最少。

思路：

最小顶点覆盖。左边n种模式，右边m种模式，直接按照任务给x，y建边，这样构成的显然是二分图，为了要求出完成k个任务的最小调整次数，就是求出最小的顶点集合，可以覆盖所有边，也就是最小顶点覆盖，而对于二分图，最小顶点覆盖 = 最大匹配。

另外要注意一点，两台机器初始的状态都是0，可以把能用0处理的任务提前先处理了，所以连的边的顶点不应该包含0

代码：

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 105;
const int MAXM = 105;

struct node {
    int x, y, z;
    bool operator < (const node &b) const {
        if (x == b.x) {
            if (y == b.y) return z < b.z;
            return y < b.y;
        }
        return x < b.x;
    }
}a[MAXN];

struct BgMaxMatch {

    int nl, nr;
    int l[MAXN], r[MAXM];
    bool vis[MAXN];
    vector <int> G[MAXN];  //这里注意要看是按左右哪边建图，也有可能是MAXM

    void init(int nl, int nr) {
        this -> nl = nl;
        this -> nr = nr;
        for (int i = 1; i <= nl; i++) G[i].clear();
        memset(vis, false, sizeof(vis));
    }

    void AddEdge(int u, int v) {
        G[u].push_back(v);
    }

    bool dfs(int u){
        int cnt = G[u].size();
        for (int i = 0; i < cnt; i++) {
            int v = G[u][i];
            if (!vis[v]) {
                vis[v] = true;
                if(l[v] == -1 || dfs(l[v]))	{
                    l[v] = u; r[u] = i;
                    return true;
                }
            }
        }
        return false;
    }

    int MaxMatch() {
        memset(l, -1, sizeof(l));
        memset(r, -1, sizeof(r));
        int ans = 0;
        for (int i = nl; i >= 1; i--) {
            memset(vis, false, sizeof(vis));
            ans += dfs(i);
        }
        return ans;
    }
} solver;

int main() {
    int  n, m, k;
    while (scanf("%d", &n), n) {
        scanf("%d%d", &m, &k);
        solver.init(n, m);
        for (int i = 1; i <= k; i++) {
            int t, x, y;
            scanf("%d%d%d", &t, &x, &y);
            if (x > 0 && y > 0) solver.AddEdge(x, y);
        }
        printf("%d\n", solver.MaxMatch());
    }
    return 0;
}