[WC2016]挑战NPC【一般图最大匹配 带花树】

题目链接

---

  很容易想到的是每个球肯定是去和它能连接边的对应的篮子的三个状态进行连接边，但是怎样生成更多的半空框子呢？这里我们可以将每个框子拆开来的点的第2和第3个点连接，也就是我们也想让更多的半空的框子生成，所以的话，最后的半空框子的个数就是总的匹配数减去N个球都必须要匹配的个数。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 610, maxM = 2e5+ 7;
int N, M, E, head[maxN], cnt, L, id[105][3];
struct Eddge
{
    int nex, to;
    Eddge(int a=-1, int b=0):nex(a), to(b) {}
} edge[maxM];
inline void addEddge(int u, int v)
{
    edge[cnt] = Eddge(head[u], v);
    head[u] = cnt++;
}
inline void _add(int u, int v) { addEddge(u, v); addEddge(v, u); }
struct DHS
{
    int match[maxN], pre[maxN], vis[maxN], fa[maxN], tim[maxN], idx, ans, node;
    queue<int> Q;
    inline int fid(int x) { return x == fa[x] ? x : fa[x] = fid(fa[x]); }
    inline int lca(int x, int y)
    {
        for(++idx; ; swap(x, y))
        {
            if(x)
            {
                x = fid(x);
                if(tim[x] == idx) return x;
                else
                {
                    tim[x] = idx;
                    x = pre[match[x]];
                }
            }
        }
    }
    void blossom(int x, int y, int p)
    {
        while (fid(x) != p)
        {
            pre[x] = y; y = match[x];
            if (vis[y] == 2) { vis[y] = 1; Q.push(y); }
            if (fid(x) == x) fa[x] = p;
            if (fid(y) == y) fa[y] = p;
            x = pre[y];
        }
    }
    int Aug(int S)
    {
        for(int i=1; i<=node; i++)
        {
            vis[i] = pre[i] = 0;
            fa[i] = i;
        }
        while (!Q.empty()) Q.pop();
        Q.push(S);vis[S]=1;
        while (!Q.empty())
        {
            int u = Q.front(); Q.pop();
            for (int i=head[u], v; ~i; i=edge[i].nex)
            {
                v = edge[i].to;
                if (fid(u) == fid(v) || vis[v] == 2) continue;
                if (!vis[v])
                {
                    vis[v] = 2; pre[v] = u;
                    if (!match[v])
                    {
                        for (int x = v, lst; x; x = lst)
                        {
                            lst = match[pre[x]];
                            match[x] = pre[x];
                            match[pre[x]] = x;
                        }
                        return 1;
                    }
                    vis[match[v]] = 1;
                    Q.push(match[v]);
                }
                else
                {
                    int gg = lca(u, v);
                    blossom(u, v, gg);
                    blossom(v, u, gg);
                }
            }
        }
        return 0;
    }
    inline int solve()
    {
        for(int i=1; i<=node; i++)
        {
            if(!match[i]) ans += Aug(i);
        }
        return ans;
    }
} dhs;
inline void init()
{
    cnt = 0; dhs.ans = 0; dhs.idx = 0;
    for(int i=1; i<=dhs.node; i++) { head[i] = -1; dhs.match[i] = dhs.tim[i] = 0; }
}
int main()
{
    int T; scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d%d", &N, &M, &E);
        dhs.node = N;
        for(int i=1; i<=M; i++) for(int j=0; j<3; j++) id[i][j] = ++dhs.node;
        init();
        for(int i=1, u, v; i<=E; i++)
        {
            scanf("%d%d", &u, &v);
            for(int j=0; j<3; j++) _add(u, id[v][j]);
        }
        for(int i=1; i<=M; i++) _add(id[i][1], id[i][2]);
        int ans = dhs.solve();
        printf("%d\n", ans - N);
        for(int i=1; i<=N; i++) printf("%d%c", (int)ceil(1. * (dhs.match[i] - N) / 3), i == N ? '\n' : ' ');
    }
    return 0;
}