最小路徑覆蓋問題

吃什麼

---

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;
}