[Luogu P2764] 最小路径覆盖问题

洛谷传送门

题目描述

给定有向图$G=(V,E)$。设$P$ 是$G$ 的一个简单路（顶点不相交）的集合。如果$V$ 中每个顶点恰好在$P$ 的一条路上，则称$P$是$G$ 的一个路径覆盖。$P$ 中路径可以从$V$ 的任何一个顶点开始，长度也是任意的，特别地，可以为$0$。$G$ 的最小路径覆盖是$G$ 的所含路径条数最少的路径覆盖。设计一个有效算法求一个有向无环图$G$ 的最小路径覆盖。

输入输出格式

输入格式：

第$1$ 行有$2$个正整数$n$和$m$。$n$是给定有向无环图$G$ 的顶点数，$m$是$G$ 的边数。接下来的$m$行，每行有 $2$ 个正整数i和$j$，表示一条有向边$(i,j)$。

输出格式：

从第$1$ 行开始，每行输出一条路径。文件的最后一行是最少路径数。

输入输出样例

输入样例#1：

11 12
1 2
1 3
1 4
2 5
3 6
4 7
5 8
6 9
7 10
8 11
9 11
10 11

输出样例#1：

1 4 7 10 11
2 5 8
3 6 9
3

说明

$1\leq n\leq 150,1\leq m\leq 6000$

解题分析

我们把两个点合在一起的时候， 总的路径条数便减1。因此我们实际上是在求相邻点与点之间的最优匹配， 直接换为二分图模型。对于所有的$E(A,B)$， 我们连$x_A\to y_B$这样一条容量为1的边。 最终最小路径数便为点数减去最优匹配数。

至于输出方案， 直接使用并查集维护所在链端即可。

代码如下：

#include <cstdio>
#include <cmath>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <cstdlib>
#include <queue>
#define R register
#define IN inline
#define gc getchar()
#define W while
#define S 0
#define T 500
#define MX 505
#define INF 100000000
template <class TT>
IN void in(TT &x)
{
    x = 0; R char c = gc;
    W (!isdigit(c)) c = gc;
    W (isdigit(c))
    x = (x << 1) + (x << 3) + c - 48, c = gc;
}
int dot, line, cnt = -1;
int head[MX], layer[MX], bel[MX];
struct Edge {int from, to, fl, nex;} edge[MX * 100];
std::queue <int> q;
IN void add(R int from, R int to, R int fl)
{
    edge[++cnt] = {from, to, fl, head[from]}, head[from] = cnt;
    edge[++cnt] = {to, from, 0, head[to]}, head[to] = cnt;
}
int find(R int now) {return bel[now] == now ? now : bel[now] = find(bel[now]);}
IN bool BFS()
{
    std::memset(layer, 0, sizeof(layer));
    layer[S] = 1; q.push(S);
    R int now;
    W (!q.empty())
    {
        now = q.front(); q.pop();
        for (R int i = head[now]; ~i; i = edge[i].nex)
        {
            if(edge[i].fl && !layer[edge[i].to])
            layer[edge[i].to] = layer[now] + 1, q.push(edge[i].to);
        }
    }
    return layer[T];
}
int DFS(R int now, R int val)
{
    if(now == T) return val;
    int lef = val, buf;
    for (R int i = head[now]; ~i; i = edge[i].nex)
    {
        if(edge[i].fl && layer[edge[i].to] == layer[now] + 1)
        {
            buf = DFS(edge[i].to, std::min(lef, edge[i].fl));
            if(!buf) continue;
            lef -= buf; edge[i].fl -= buf, edge[i ^ 1].fl += buf;
            if(lef <= 0) return val;
        }
    }
    return val - lef;
}
int Dinic()
{
    int ret = 0;
    W (BFS()) ret += DFS(S, INF);
    return ret;
}
void print(R int now)
{
    printf("%d ", now);
    for (R int i = head[now]; ~i; i = edge[i].nex)
    if(!edge[i].fl && edge[i].to > dot) print(edge[i].to - dot);
}
int main(void)
{
    int a, b;
    std::memset(head, -1, sizeof(head));
    in(dot), in(line);
    for (R int i = 1; i <= dot; ++i) add(S, i, 1), add(i + dot, T, 1), bel[i] = i;
    for (R int i = 1; i <= line; ++i)
    in(a), in(b), add(a, b + dot, 1);
    int ans = dot - Dinic();
    for (R int i = 0; i <= cnt; ++i)
    {
        if(edge[i].from > 0 && edge[i].from <= dot && edge[i].to > dot && edge[i].to <= 2 * dot)
        {
            if(!edge[i].fl)
            bel[find(bel[edge[i].to - dot])] = find(bel[edge[i].from]);
        }
    }
    for (R int i = 1; i <= dot; ++i) if(bel[i] == i) print(i), putchar(10);
    printf("%d", ans);
}