P4298 [CTSC2008] Dilworth 定理

题意

传送门 P4298 [CTSC2008]祭祀

题解

$Dilworth$ 定理：对于任意有限偏序集，其最大反链中元素的数目必等于最小链划分中链的数目。

即 $DAG$ 中最长反链的大小，等于最小路径可重点覆盖的大小。反链定义为 $DAG$ 中的一个节点子集 $S$，任意不同的两点 $u,v\in S$ 相互不可达。

最小路径可重点覆盖，即给定一个 $DAG$，要求用尽可能少的可相交路径，覆盖 $DAG$ 的所有节点，此时一个节点可以覆盖多次。使用 $Floyd$ 算法对 $DAG$ 传递闭包，即得到偏序集中任意两点的关系，则问题转化为最小路径覆盖问题，此时每个节点恰好被覆盖一次。建立一个二分图，将原图每个点 $x$ 拆为左部点 $L(x)$ 与右部点 $R(x)$，对可达路径 $(x,y)$，在 $L(x),R(y)$ 间连一条边；此时，匹配边所代表的路径，左匹配部点可看作起点，左部非匹配点可看作终点。目标是最小化这样的终点数（或路径上的前驱节点数），则最小路径覆盖等于原图节点数 $n$ 减去二分图最大匹配数 $m$。

$K\ddot{o}nig$ 定理：二分图最小点覆盖包含的点数等于二分图最大匹配包含的边数。

需要构造一个最大反链。根据 $K\ddot{o}nig$ 定理的证明过程，构造一个最小点覆盖，其补集则为最大独立集。考虑最大反链的性质，得到一组构造，即满足左部点与右部点都在最大独立集中的节点。此时最大独立集大小为 $2\times n-m$，左部点或右部点包含于最小点覆盖的节点数最大为 $m$，则这组构造的大小的下界为 $[(2\times n-m)-m]/2=n-m$；又最大反链大小的上界为最小路径可重点覆盖的大小 $n-m$。上述构造简单证明了 $Dilworth$ 定理。

判断某个节点 $x$ 是否可包含于一个最大反链。假设 $x$ 为最大反链上的一点，根据最大反链的性质，删除 $x$ 和与 $x$ 存在连边的节点；若新图的最大反链大小等于原图最大反链大小减一，则满足条件。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 105, maxm = maxn * maxn;
int N, M, match[maxn];
int tot, head[maxn], to[maxm], nxt[maxm];
bool vs[maxn], vl[maxn], vr[maxn], dp[maxn][maxn], del[maxn];

inline void add(int x, int y) { to[++tot] = y, nxt[tot] = head[x], head[x] = tot; }

void floyd()
{
    for (int k = 1; k <= N; ++k)
        for (int i = 1; i <= N; ++i)
            for (int j = 1; j <= N; ++j)
                dp[i][j] |= dp[i][k] && dp[k][j];
}

bool dfs(int x)
{
    for (int i = head[x]; i; i = nxt[i])
    {
        int y = to[i], w = match[y];
        if (vs[y] || del[y])
            continue;
        vs[y] = 1;
        if (!w || (!del[w] && dfs(w)))
        {
            match[y] = x;
            return 1;
        }
    }
    return 0;
}

void dfs2(int x)
{
    vl[x] = 1;
    for (int i = head[x]; i; i = nxt[i])
    {
        int y = to[i], w = match[y];
        if (vr[y])
            continue;
        vr[y] = 1;
        dfs2(w);
    }
}

int main()
{
    scanf("%d%d", &N, &M);
    for (int i = 1, x, y; i <= M; ++i)
        scanf("%d%d", &x, &y), dp[x][y] = 1;
    floyd();
    for (int i = 1; i <= N; ++i)
        for (int j = 1; j <= N; ++j)
            if (dp[i][j])
                add(i, j);
    int res = N;
    for (int i = 1; i <= N; ++i)
        memset(vs, 0, sizeof(vs)), res -= dfs(i);
    printf("%d\n", res);
    memset(vs, 0, sizeof(vs));
    for (int i = 1; i <= N; ++i)
        vs[match[i]] = 1;
    for (int i = 1; i <= N; ++i)
        if (!vs[i])
            dfs2(i);
    for (int i = 1; i <= N; ++i)
        putchar((vl[i] && !vr[i]) ? '1' : '0');
    putchar('\n');
    for (int x = 1; x <= N; ++x)
    {
        memset(del, 0, sizeof(del));
        memset(match, 0, sizeof(match));
        int t = N;
        for (int i = 1; i <= N; ++i)
            if (i == x || dp[x][i] || dp[i][x])
                del[i] = 1, --t;
        for (int i = 1; i <= N; ++i)
            if (!del[i])
                memset(vs, 0, sizeof(vs)), t -= dfs(i);
        putchar(t == res - 1 ? '1' : '0');
    }
    putchar('\n');
    return 0;
}