最小路徑覆蓋問題（網絡流24題）

鏈接

思路：

在一個有向圖中找出最少的路徑，使得路徑能夠覆蓋所有的點。

要找最少的路徑可以看成把縮邊，這樣就變爲了求最多有多少條邊可以被縮掉
建邊：

把每個拆成出和入兩個點
所有的出點和源點有一條權爲1的邊，所有的入點和匯點也有一條權爲1的邊。在縮邊的過程中，一個點出來的邊最多隻有一條可以被縮，進去的也是。
在原圖中有邊$i->j$，那麼就要建$out_{i}->in_{j}$權爲無限的邊。

如何輸出方案，遍歷所有的邊，找出有流經過的邊，且這個邊不含源點和匯點，可以知道這兩個點是在一起的，利用並查集處理一下，就能夠得到方案了。

參考代碼：

#include <bits/stdc++.h>
using namespace std;
const int N=505;

const int MAXN = 1<<26;
struct Edge{
    int u,v,c;
    int nxt;
}edge[N*N];

int n,m;
int head[N],edn;
int d[N];
int sp,tp;

int to[N];

void add_edge(int u,int v,int c)
{
    edge[edn].u=u; edge[edn].v=v; edge[edn].c=c;
    edge[edn].nxt=head[u]; head[u]=edn++;

    edge[edn].u=v; edge[edn].v=u; edge[edn].c=0;
    edge[edn].nxt=head[v]; head[v]=edn++;
}
int bfs()
{
    queue <int> q;
    memset(d,-1,sizeof(d));
    d[sp]=0;
    q.push(sp);
    while(!q.empty())
    {
        int cur=q.front();
        q.pop();
        for(int i=head[cur];i!=-1;i=edge[i].nxt)
        {
            int v=edge[i].v;
            if(d[v]==-1 && edge[i].c>0)
            {
                d[v]=d[cur]+1;
                q.push(v);
            }
        }
    }
    return d[tp] != -1;
}
int dfs(int a,int b)
{
    int r=0;
    if(a==tp)return b;
    for(int i=head[a];i!=-1 && r<b;i=edge[i].nxt)
    {
        int v=edge[i].v;
        if(edge[i].c>0 && d[v]==d[a]+1)
        {
            int x=min(edge[i].c,b-r);
            x=dfs(v,x);
            to[a]=v;
            r+=x;
            edge[i].c-=x;
            edge[i^1].c+=x;
        }
    }
    if(!r)d[a]=-2;
    return r;
}

int dinic(int sp,int tp)
{
    int total=0,t;
    while(bfs())
    {
        while(t=dfs(sp,MAXN))
            total+=t;
    }
    return total;
}

int fa[N];
bool vis[N];

int findfa(int x){
    return fa[x]=fa[x]==x?x:findfa(fa[x]);
}

int main(){
    scanf("%d%d",&n,&m);
    memset(head,-1, sizeof(head));
    edn=0;
    sp=301,tp=302;
    for(int i=1;i<=n;i++){
        add_edge(sp,i,1);
        add_edge(n+i,tp,1);
    }

    for(int i=1,u,v;i<=m;i++){
        scanf("%d%d",&u,&v);
        add_edge(u,n+v,MAXN);
    }

    int ans=n-dinic(sp,tp);

    for(int i=1;i<=n;i++){
        fa[i]=i;
    }
    for(int i=0;i<edn;i++){
        if(edge[i].u>=1&&edge[i].u<=n&&edge[i].v>=n+1&&edge[i].v<=n+n&&edge[i^1].c){
            int fau=findfa(edge[i].u);
            int fav=findfa(edge[i].v-n);
            if(fau!=fav){
                fa[fav]=fau;
            }
        }
    }
    for(int i=1;i<=n;i++){
        if(vis[i])continue;
        vis[i]= true;
        printf("%d",i);
        for(int j=i+1;j<=n;j++){
            if(findfa(j)==findfa(i)){
                printf(" %d",j);
                vis[j]= true;
            }
        }
        printf("\n");
    }

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