[网络流24题] 最小路径覆盖问题 (最大流/匈牙利 二分图匹配)

洛谷传送门 LOJ传送门

和部落战争这道题差不多

让我们求一个有向图中的所有点，最少被多少条不相交的链覆盖，并输出方案

链除了两头，中间的点出度入度都是$1$。

我们把链压成弹簧形，问题转化成了二分图匹配？

所有找不到匹配的位置都是链头！

而匈牙利的时间复杂度十分不友好，那么怎么用网络流做呢？

由于是有向图，所以我们要把每个点都拆成入点和出点，来起到有向边的作用

源点$S$向入点连流量为$1$的边，每个出点向汇点$T$连流量为$1$的边

图中的每条边，都从入点连向对应标号的出点，流量为$1$

在跑完最大流之后，如果某个点不是链尾，它入点的流量一定为$1$，因为在链中它后面还有点，否则它就是链尾

输出方案，重新建图，$dfs$一遍就行了

#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define N1 350
#define M1 20010
#define ll long long
#define dd double
#define inf 0x3f3f3f3f
using namespace std;

int gint()
{
    int ret=0,fh=1;char c=getchar();
    
    while(c<'0'||c>'9'){if(c=='-')fh=-1;c=getchar();}
    while(c>='0'&&c<='9'){ret=ret*10+c-'0';c=getchar();}
    return ret*fh;
}

int n,m,nm,S,T;
struct Edge{
int head[N1],to[M1<<1],nxt[M1<<1],flow[M1<<1],cte;
void ae(int u,int v,int F)
{
    cte++; to[cte]=v; flow[cte]=F;  
    nxt[cte]=head[u]; head[u]=cte;
}
}e,g;

int que[M1*2],hd,tl,cur[N1],dep[N1],inc[N1],ouc[N1];
int bfs()
{
    int x,j,v;
    memset(dep,-1,sizeof(dep)); memcpy(cur,e.head,sizeof(cur));
    hd=1,tl=0; que[++tl]=S; dep[S]=0;
    while(hd<=tl)
    {
        x=que[hd++];
        for(j=e.head[x];j;j=e.nxt[j])
        {
            v=e.to[j]; if(!e.flow[j]||dep[v]!=-1) continue;
            dep[v]=dep[x]+1; que[++tl]=v;
        }
    }
    return dep[T]!=-1;
}
int dfs(int x,int limit)
{
    int j,v,flow,ans=0; if(x==T||!limit) return limit;
    for(j=cur[x];j;j=e.nxt[j])
    {
        cur[x]=j; v=e.to[j];
        if( dep[v]==dep[x]+1 && (flow=dfs(v,min(limit,e.flow[j]))) )
        {
            limit-=flow, ans+=flow;
            e.flow[j]-=flow, e.flow[j^1]+=flow;
            if(!limit) break;
        }
    }
    return ans;
}
void dfs_ans(int x)
{
    int j,v;
    if(x!=S) printf("%d ",x);
    for(j=g.head[x];j;j=g.nxt[j])
    {
        v=g.to[j];
        dfs_ans(v);
        if(x==S) puts("");
    }
}
int Dinic()
{
    int mxflow=0,x,j,v,i;
    while(bfs())
    {
        mxflow+=dfs(S,inf);
    }
    for(x=1;x<=n;x++)
        for(j=e.head[x];j;j=e.nxt[j])
        {
            v=e.to[j]; 
            if(v<=n||v>n+n||e.flow[j]) continue;
            g.ae(x,v-n,0); inc[v-n]++; //ouc[x]++;
        }
    for(i=1;i<=n;i++) if(!inc[i]) g.ae(S,i,0); //ouc[S]++;
    dfs_ans(S);
    return mxflow;
}


int main()
{
    scanf("%d%d",&n,&m);
    int i,j,x,y,ans; S=n+n+1,T=n+n+2; e.cte=1;
    for(i=1;i<=n;i++) e.ae(S,i,1), e.ae(i,S,0), e.ae(i+n,T,1), e.ae(T,i+n,0);
    for(i=1;i<=m;i++) x=gint(), y=gint(), e.ae(x,y+n,1), e.ae(y+n,x,0);
    printf("%d
",n-Dinic());
    return 0;
}