【洛谷】P2764 最小路径覆盖问题（网络流dinic,建图）

题目描述

«问题描述：

给定有向图G=(V,E)。设P 是G 的一个简单路（顶点不相交）的集合。如果V 中每个顶点恰好在P 的一条路上，则称P是G 的一个路径覆盖。P 中路径可以从V 的任何一个顶点开始，长度也是任意的，特别地，可以为0。G 的最小路径覆盖是G 的所含路径条数最少的路径覆盖。设计一个有效算法求一个有向无环图G 的最小路径覆盖。提示：设V={1，2，…. ，n}，构造网络G1=(V1,E1)如下：

每条边的容量均为1。求网络G1的（ 0 x , 0 y ）最大流。

«编程任务：

对于给定的给定有向无环图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

这题可以用匹配来做，但是这段时间学习网络流，就用网络流。
建图：
对于这个问题的建图，首先要明确两个点连接成一条边，所以，要把图分为两部分。
左半部分是出发点，右半部分是终点。
还要自己建立源点和汇点。

例如：
源点：0， 汇点：n*2+1
左半部分：1–>n
右半部分：n+1–>n*2
对于每一条边的容量都应当是1
然后跑网络流dinic

#include<bits/stdc++.h>
#define MAX 60000
#define INF 0x3f3f3f3f
using namespace std;
int level[MAX];
int iter[MAX];
struct edge
{
    int to, cap, rev;
};
int next[MAX];
int vis[MAX];
vector<edge>G[MAX];
void add_edge(int from, int to, int cap)
{
    struct edge e;
    e.to = to;
    e.cap = cap;
    e.rev = G[to].size();
    G[from].push_back(e);
    e.to = from;
    e.cap = 0;
    e.rev = G[from].size()-1;
    G[to].push_back(e);
}
void bfs(int s)
{
    memset(level, -1, sizeof(level));
    level[s] = 0;
    queue<int>que;
    que.push(s);
    while(!que.empty())
    {
        int v = que.front();
        que.pop();
        for(int i=0; i<G[v].size(); i++)
        {
            edge &e = G[v][i];
            if(e.cap>0&&level[e.to]<0)
            {
                level[e.to] = level[v]+1;
                que.push(e.to);
            }
        }
    }
}
int dfs(int v, int t, int flow)
{
    if(v==t)
        return flow;
    for(int &i=iter[v]; i<G[v].size(); i++)
    {
        edge & e = G[v][i];
        if(e.cap>0&&level[e.to]>level[v])
        {
            int d = dfs(e.to, t, min(flow, e.cap));
            if(d>0)
            {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s, int t)
{
    int flow = 0;
    for(;;)
    {
        bfs(s);
        if(level[t]<0)
            return flow;
        memset(iter, 0, sizeof(iter));
        int f;
        while((f=dfs(s, t, INF))>0)
        {
            flow += f;
        }
    }
}
int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    for(int i=0; i<n+n+2; i++)
    {
        G[i].clear();
    }
    for(int i=0; i<m; i++)
    {
        int a, b;
        scanf("%d %d", &a, &b);
        add_edge(a, b+n, 1);
    }
    for(int i=0; i<n; i++)
    {
        add_edge(0, i+1, 1);
        add_edge(i+n+1, n+n+1, 1);
    }
    memset(next, 0, sizeof(next));
    memset(vis, 0, sizeof(vis));
    int d = max_flow(0, n+n+1);
    for(int i=n+1; i<=2*n; i++)//寻找边的前后关系
    {
        for(int j=0; j<G[i].size(); j++)
        {
            edge &e = G[i][j];
            if(e.cap>0)//反向边的容量为1，说明这条正向边是用了的
            {
                next[e.to] = i-n;
            }
        }
    }
    for(int i=1; i<=n; i++)//输出，Special Judge
    {
        if(vis[i]==0)
        {
            printf("%d", i);
            vis[i] = 1;
            int a = i;
            while(next[a])
            {
                printf(" %d", next[a]);
                vis[next[a]] = 1;
                a = next[a];
            }
            printf("\n");
        }
    }
    printf("%d\n", n-d);
    return 0;
}