P2764 最小路径覆盖问题(网络流２４题之一)

题目描述

«问题描述：

给定有向图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：

输出样例#1：

1 4 7 10 11

2 5 8

3 6 9

3

说明

1<=n<=150,1<=m<=6000

由@zhouyonglong提供SPJ

Ｓｏｌｕｔｉｏｎ：

先简单的解释一下最小路径覆盖：大致就是在一个有向无环图中，用最少多少条简单路径能将所有的点覆盖（简单路径简单来说就是一条路径不能和其他路径有重复的点，当然也可以认为单个点是一条简单路径）。

仔细思考，容易发现有些类似于二分图匹配的问题，异曲同工。

算法：把原图的每个点V拆成Vx和Vy两个点，如果有一条有向边A->B，那么就加边Ax−>By。这样就得到了一个二分图。那么最小路径覆盖=原图的结点数-新图的最大匹配数。

证明：一开始每个点都是独立的为一条路径，总共有n条不相交路径。我们每次在二分图里找一条匹配边就相当于把两条路径合成了一条路径，也就相当于路径数减少了1。所以找到了几条匹配边，路径数就减少了多少。所以有最小路径覆盖=原图的结点数-新图的最大匹配数。

因为路径之间不能有公共点，所以加的边之间也不能有公共点，这就是匹配的定义。

方法一：二分图匹配。综合上述所说的，我们可以直接建图，然后跑匈牙利算法，输出的话只需将所匹配的点依次输出就ｏｋ了。

代码（ｃｏｐｙ一份）：

 #include <bits/stdc++.h>

 using namespace std;

 typedef long long LL;

 const int maxn = ;

 const int maxm = ;

 struct Edge

 {

     int v;

     Edge *next;

 }E[maxm], *H[maxn], *edges;

 int res[maxn];

 int vis[maxn];

 void addedges(int u, int v)

 {

     edges->v = v;

     edges->next = H[u];

     H[u] = edges++;

 }

 void init()

 {

     edges = E;

     memset(H, , sizeof H);

     memset(res, -, sizeof res);

 }

 bool find(int u)

 {

     for(Edge *e = H[u]; e; e = e->next) if(!vis[e->v]) {

         int v = e->v;

         vis[v] = ;

         if(res[v] == - || find(res[v])) {

             res[v] = u;

             return true;

         }

     }

     return false;

 }

 int n, m;

 vector<int> ans;

 int to[maxn];

 void work()

 {

     int u, v;

     for(int i = ; i <= m; i++) {

         scanf("%d%d", &u, &v);

         addedges(u, v);

     }

     int result = ;

     for(int i = ; i <= n; i++) {

         memset(vis, , sizeof vis);

         if(find(i)) result++;

     }

     memset(to, , sizeof to);

     for(int i = ; i <= n; i++) if(res[i] != -) to[res[i]] = i;

     for(int i = ; i <= n; i++) if(res[i] == -) {

         ans.clear();

         int u = i;

         ans.push_back(u);

         while(to[u]) {

             u = to[u];

             ans.push_back(u);

         }

         for(int j = ; j < ans.size(); j++) printf("%d%c", ans[j], j == ans.size() -  ? '\n' : ' ');

     }

     printf("%d\n", n - result);

 }

 int main()

 {

     scanf("%d%d", &n, &m);

     init();

     work();

     return ;

 }

方法二：网络最大流。这里的做法和二分图匹配用最大流的做法是一样的。附加炒鸡源Ｓ和炒鸡汇Ｔ，然后建图（边权为１），最后跑最大流，输出时方法很多，我选择的是从汇点按残余流量的有无来往前找一条路径并递归输出。

代码（手打Ｄｉｎｉｃ）：

 #include<bits/stdc++.h>

 #define il inline

 using namespace std;

 const int N=,inf=;

 int n,m,s,t=,h[N],dis[N],cnt=,fa[N];

 struct edge{

 int to,net,v;

 }e[];

 il void add(int u,int v,int w)

 {

     e[++cnt].to=v,e[cnt].net=h[u],e[cnt].v=w,h[u]=cnt;

     e[++cnt].to=u,e[cnt].net=h[v],e[cnt].v=,h[v]=cnt;

 }

 queue<int>q;

 il bool bfs()

 {

     memset(dis,-,sizeof(dis));

     q.push(s),dis[s]=;

     while(!q.empty())

     {

         int u=q.front();q.pop();

         for(int i=h[u];i;i=e[i].net)

         if(dis[e[i].to]==-&&e[i].v>)dis[e[i].to]=dis[u]+,q.push(e[i].to);

     }

     return dis[t]!=-;

 }

 il int dfs(int u,int op)

 {

     if(u==t)return op;

     int flow=,used=;

     for(int i=h[u];i;i=e[i].net)

     {

         int v=e[i].to;

         if(dis[v]==dis[u]+&&e[i].v)

         {

             used=dfs(v,min(op,e[i].v));

             if(!used)continue;

             flow+=used,op-=used;

             e[i].v-=used,e[i^].v+=used;

             fa[u]=v;

             if(!op)break;

         }

     }

     if(!flow)dis[u]=-;

     return flow;

 }

 il void print(int x)

 {

     if(x<=s)return;

     printf("%d ",x);

     for(int i=h[x];i;i=e[i].net)

         if(!e[i].v&&e[i].to<=n*)print(e[i].to-n);

 }

 int main()

 {

     scanf("%d%d",&n,&m);

     for(int i=;i<=n;i++)fa[i]=i;

     for(int i=;i<=n;i++)add(s,i,),add(i+n,t,);

     int u,v;

     for(int i=;i<=m;i++)

     {

         scanf("%d%d",&u,&v);

         add(u,v+n,);

     }

     int ans=n;

     while(bfs())ans-=dfs(s,inf);

     for(int i=h[t];i;i=e[i].net)

     {

         if(e[i].v)continue;

         print(e[i].to-n),printf("\n");

     }

     printf("%d",ans);

     return ;

 }