最小路径覆盖问题

吃什么

---

Sol

• 先说结论：
  二分图定理之一：最小路径覆盖数=顶点数-最大匹配
  将一个点拆拆成两个点
  如果x->y有一条边： $add(x,y',1)$
  对于所有的点 ：$add(S,i,1)$，$add(i',T,1)$

• 以下是证明

  • 为什么可以转化成二分图及有什么好处
    因为是“路径”，所有不能有“分叉”，或者说每个点的入度+出度<=2
    二分图的一次匹配就是原图的一个合法路径的一部分
    将一个点拆拆成两个点，那么哪个点连向i’和i能连向哪个点互不干扰，可以保证找到最长的路径

  • 网络流跑最大匹配的正确性：
    为什么不会多：S连向每个点和每个点连向T的边容量都是1，因此一个点最多匹配一次，满足匹配的定义
    为什么不会少：i和i’之间并没有边，也就是哪个点连向i’和i能连向哪个点互不干扰
    可以想一下为什么不能这样连边：
    $add(x,y,1)$

---

Code

// by spli
#include<cstring>
#include<algorithm>
#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;

const int N=155<<1;
const int M=6000+N;
const int inf=0x3f3f3f3f;
int n,m;
struct node{
    int to,nxt,fl;
}e[M<<1];int head[N],cnt;
queue<int>q;
int lev[N];
bool vis[N];
int t[N];

void add(int f,int t,int fl){
    e[cnt]=(node){t,head[f],fl};
    head[f]=cnt++;
}

void add_edge(int f,int t,int fl){
    add(f,t,fl);
    add(t,f,0);
}

bool bfs(int S,int T){
    memset(lev,-1,sizeof(lev));
    lev[S]=1;
    q.push(S);
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int i=head[u];~i;i=e[i].nxt){
            int v=e[i].to;
            if(e[i].fl>0&&lev[v]==-1){
                lev[v]=lev[u]+1;
                q.push(v);
            }
        }
    }
    return lev[T]>0;
}

int dfs(int u,int mf,int T){
    if(u==T||!mf) return mf;
    int ret=0;
    for(int i=head[u];~i;i=e[i].nxt){
        int v=e[i].to;
        if(e[i].fl>0&&lev[v]==lev[u]+1){
            int tmp=dfs(v,min(mf,e[i].fl),T);
            if(!tmp) continue;//!!!!!!!!!!!!!!
            mf-=tmp;
            e[i].fl-=tmp;
            e[i^1].fl+=tmp;
            ret+=tmp;
            t[u]=v;
            if(!mf) return ret;
        }
    }
    return ret;
}

int dinic(int S,int T){
    int ret=0;
    while(bfs(S,T))
        ret+=dfs(S,inf,T);
    return ret;
}

int main(){
    memset(head,-1,sizeof(head));
    scanf("%d%d",&n,&m);
    int x,y;
    int S=0,T=n*2+1;
    for(int i=1;i<=m;++i){
        scanf("%d%d",&x,&y);
        add_edge(x,y+n,1);
    }
    for(int i=1;i<=n;++i){
        add_edge(S,i,1);
        add_edge(i+n,T,1);
    }
    int ans=dinic(S,T);
    for(int i=1;i<=n;++i){
        if(!t[i]) continue;
        int x=i,pre;
        while(x){
            if(x>n) x-=n;
            printf("%d ",x);
            pre=x;
            x=t[x];
            t[pre]=0;
        }
        puts("");
    }
    printf("%d",n-ans);
    return 0;
}