LuoguP2764 最小路径覆盖问题(最大流)

题目描述

«问题描述：

给定有向图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 行开始，每行输出一条路径。文件的最后一行是最少路径数。

解题思路：

转换一下思路，需要覆盖，那么最多就需要点数条路径。

然后发现，有些路径可以合并，而且每合并一个点集，就少一条路径。

那么什么样的点可以合并呢，就是一条边相连的。

那么将一个点分裂成两个一个用于接受合并，一个用来提供合并。

相连的点，从起点的提供指向终点的接受，流量为$inf$

每个点都可以是起点终点所以向源汇点连$1$的边。

最大流最后拿n减掉就好了。

代码：

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 const int oo=0x3f3f3f3f;
 namespace stb{
     template<class tnt>
     class queue{
         public:
             queue(){h=,t=;}
             int nxt(int x){if(x+==)return ;return x+;}
             void push(tnt x){t=nxt(t);l[t]=x;return ;}
             bool empty(void){return nxt(t)==h;}
             tnt front(void){return l[h];}
             void clear(void){h=,t=;}
             void pop(void){h=nxt(h);}
         private:
             tnt l[];
             int h,t;
     };
 };
 struct pnt{
     int hd;
     int now;
     int lyr;
     int nxt;
     bool nos;
 }p[];
 struct ent{
     int twd;
     int lst;
     int vls;
 }e[];
 int cnt;
 int n,m;
 int s,t;
 stb::queue<int>Q;
 void ade(int f,int t,int v)
 {
     cnt++;
     e[cnt].twd=t;
     e[cnt].vls=v;
     e[cnt].lst=p[f].hd;
     p[f].hd=cnt;
     return ;
 }
 bool Bfs(void)
 {
     Q.clear();
     for(int i=;i<=n*+;i++)
         p[i].lyr=;
     p[s].lyr=;
     Q.push(s);
     while(!Q.empty())
     {
         int x=Q.front();
         Q.pop();
         for(int i=p[x].hd;i;i=e[i].lst)
         {
             int to=e[i].twd;
             if(p[to].lyr==&&e[i].vls>)
             {
                 p[to].lyr=p[x].lyr+;
                 if(to==t)
                     return true;
                 Q.push(to);
             }
         }
     }
     return false;
 }
 int Dfs(int x,int fll)
 {
     if(x==t)
         return fll;
     for(int &i=p[x].now;i;i=e[i].lst)
     {
         int to=e[i].twd;
         if(p[to].lyr==p[x].lyr+&&e[i].vls>)
         {
             int ans=Dfs(to,std::min(fll,e[i].vls));
             if(ans>)
             {
                 e[i].vls-=ans;
                 e[((i-)^)+].vls+=ans;
                 p[x].nxt=to;
                 if(x!=s)
                     p[to-n].nos=true;
                 return ans;
             }
         }
     }
     return ;
 }
 void Dinic(void)
 {
     int ans=;
     while(Bfs())
     {
         for(int i=;i<=*n+;i++)
             p[i].now=p[i].hd;
         int dlt;
         while(dlt=Dfs(s,oo))
             ans+=dlt;
     }
     for(int i=;i<=n;i++)
     {
         if(!p[i].nos)
         {
             for(int j=i;j!=t-n&&j>;j=p[j].nxt-n)
                 printf("%d ",j);
             puts("");
         }
     }
     printf("%d\n",n-ans);
     return ;
 }
 int main()
 {
     scanf("%d%d",&n,&m);
     s=n*+,t=n*+;
     for(int i=;i<=n;i++)
     {
         ade(s,i,);
         ade(i,s,);
         ade(i+n,t,);
         ade(t,n+i,);
     }
     for(int i=;i<=m;i++)
     {
         int a,b;
         scanf("%d%d",&a,&b);
         ade(a,b+n,oo);
         ade(b+n,a,);
     }
     Dinic();
     return ;
 }