HDU - 4160 最小路径覆盖

题意：

给n个玩具娃娃，分别给出每一个玩具娃娃的长宽高。如果满足一个娃娃的长宽高都大于另一个娃娃，那么大娃娃可以套在小娃娃的外面。问层层嵌套之后，最终最少还能剩下几个娃娃。

思路：

最小路径覆盖的模板题，如果左边放n个娃娃，右边放n个娃娃，满足嵌套关系的娃娃之间连边，那么显然这个图是二分图，顶点数 - 最大匹配 = 最小路径覆盖。

代码：

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

const int MAXN = 505;
const int MAXM = 505;

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;
    while (scanf("%d", &n), n) {
        for (int i = 1; i <= n; i++)
            scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].z);
        sort (a + 1, a + 1 + n);
        solver.init(n, n);
        for (int i = 1; i <= n; i++) {
            for (int j = i + 1; j <= n; j++) {
                if (a[i].x < a[j].x && a[i].y < a[j].y && a[i].z < a[j].z)
                    solver.AddEdge(i, j);
            }
        }
        printf("%d\n", n - solver.MaxMatch());
    }
    return 0;
}