【PowerOJ1738&网络流24题】最小路径覆盖问题 （最大流）

题意：

 

 思路：

【问题分析】

有向无环图最小路径覆盖，可以转化成二分图最大匹配问题，从而用最大流解决。

【建模方法】

构造二分图，把原图每个顶点i拆分成二分图X，Y集合中的两个顶点Xi和Yi。对于原图中存在的每条边(i,j)，在二分图中连接边(Xi,Yj)。然后把二分图最大匹配模型转化为网络流模型，求网络最大流。

最小路径覆盖的条数，就是原图顶点数，减去二分图最大匹配数。沿着匹配边查找，就是一个路径上的点，输出所有路径即可。

【建模分析】

对于一个路径覆盖，有如下性质：

1、每个顶点属于且只属于一个路径。

2、路径上除终点外，从每个顶点出发只有一条边指向路径上的另一顶点。

所以我们可以把每个顶点理解成两个顶点，一个是出发，一个是目标，建立二分图模型。该二分图的任何一个匹配方案，都对应了一个路径覆盖方案。如果匹配数为0，那么显然路径数=顶点数。每增加一

条匹配边，那么路径覆盖数就减少一个，所以路径数=顶点数 - 匹配数。要想使路径数最少，则应最大化匹配数，所以要求二分图的最大匹配。

注意，此建模方法求最小路径覆盖仅适用于有向无环图，如果有环或是无向图，那么有可能求出的一些环覆盖，而不是路径覆盖。

DAG的最小路径覆盖=点数-二分图最大匹配

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> PII;
typedef pair<ll,ll> Pll;
typedef vector<int> VI;
typedef vector<PII> VII;
//typedef pair<ll,ll>P;
#define N  200010
#define M  200010
#define INF 1e9
#define fi first
#define se second
#define MP make_pair
#define pb push_back
#define pi acos(-1)
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,a,b) for(int i=(int)a;i<=(int)b;i++)
#define per(i,a,b) for(int i=(int)a;i>=(int)b;i--)
#define lowbit(x) x&(-x)
#define Rand (rand()*(1<<16)+rand())
#define id(x) ((x)<=B?(x):m-n/(x)+1)
#define ls p<<1
#define rs p<<1|1

const ll MOD=1e9+7,inv2=(MOD+1)/2;
      double eps=1e-6;
      int dx[4]={-1,1,0,0};
      int dy[4]={0,0,-1,1};

int head[N],vet[N],len[N],nxt[N],dis[N],num[N][2],vis[N],s,S,T,tot,n,m;

int read()
{
   int v=0,f=1;
   char c=getchar();
   while(c<48||57<c) {if(c=='-') f=-1; c=getchar();}
   while(48<=c&&c<=57) v=(v<<3)+v+v+c-48,c=getchar();
   return v*f;
}

void add(int a,int b,int c)
{
    nxt[++tot]=head[a];
    vet[tot]=b;
    len[tot]=c;
    head[a]=tot;

    nxt[++tot]=head[b];
    vet[tot]=a;
    len[tot]=0;
    head[b]=tot;
}

bool bfs()
{
    queue<int>q;
    rep(i,1,s) dis[i]=-1;
    q.push(S),dis[S]=0;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        int e=head[u];
        while(e)
        {
            int v=vet[e];
            if(len[e]>0&&dis[v]==-1)
            {
                dis[v]=dis[u]+1;
                q.push(v);
            }
            e=nxt[e];
        }
    }
    return dis[T]!=-1;
}

int dfs(int u,int aug)
{
    if(u==T) return aug;
    int e=head[u],val=0,flow=0;
    while(e)
    {
        int v=vet[e];
        if(len[e]>0&&dis[v]==dis[u]+1)
        {
            int t=dfs(v,min(len[e],aug));
            if(!t)
            {
                e=nxt[e];
                continue;
            }
            flow+=t;
            aug-=t;
            len[e]-=t;
            len[e^1]+=t;
            if(!aug) break;
        }
        e=nxt[e];
    }
    if(!flow) dis[u]=-1;
    return flow;
}

void print(int u)
{
    //printf("u=%d\n",u);
    if(u<=0||u==S) return;
    printf("%d ",u);
    int e=head[u];
    while(e)
    {
        int v=vet[e];
        if(!len[e]&&v<S) print(v-n);
        e=nxt[e];
    }
}

int main()
{
    n=read(),m=read();
    s=0;
    rep(i,1,n) num[i][0]=++s;
    rep(i,1,n) num[i][1]=++s;
    S=++s; T=++s;
    rep(i,1,s) head[i]=0;
    tot=1;
    while(m--)
    {
        int x=read(),y=read();
        add(num[x][0],num[y][1],1);
    }
    rep(i,1,n) add(S,num[i][0],1);
    rep(i,1,n) add(num[i][1],T,1);
    int ans=n;
    while(bfs()) ans-=dfs(S,INF);
    int e=head[T];
    while(e)
    {
        int v=vet[e];
        if(len[e])
        {
            e=nxt[e];
            continue;
        }
        print(v-n);
        printf("\n");
        e=nxt[e];
    }

    printf("%d\n",ans);
    return 0;
}