洛谷2764 最小路径覆盖问题

题目链接：最小路径覆盖问题

首先引出定理：二分图的最小路径覆盖数=(n-)二分图最大匹配数，我们用类似数学归纳法的方法证明

首先在(n=0)的时候显然成立

当增加了某一条边对最大匹配数没有影响时，那么这一条边一定可以被最大匹配中的某一条边所覆盖；否则这条边的两个端点都不会被边覆盖，因此需要一条全新的路径来覆盖它

基于上面的原理，我们来考虑重新构图

直接拆点即可，把每一个点拆成“入点”和“出点”，即拆后每一个点只会有入边和出边。

这样第二问就直接做完了

对于第一问，我们注意到在跑dinic的时候所有用到的边的(flow)已经全部被标为了0

因此直接dfs即可

最后在确定联通块时使用并查集即可

#include<iostream>
#include<string>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
using namespace std;
#define maxd 1e9+7

struct network_flows{
    struct node{
        int from,to,nxt,flow;
    }sq[100100];
    int all,dep[100100],head[100100],cur[100100],n,m,s,t;
    bool vis[100100];

    void init(int n)
    {
        this->s=2*n+1;this->t=2*n+2;
        this->n=2*n+2;this->all=1;
        memset(head,0,sizeof(head));
    }

    void add(int u,int v,int w)
    {
        all++;sq[all].from=u;sq[all].to=v;sq[all].nxt=head[u];sq[all].flow=w;head[u]=all;
        all++;sq[all].from=v;sq[all].to=u;sq[all].nxt=head[v];sq[all].flow=0;head[v]=all;
    }

    bool bfs()
    {
        queue<int> q;int i;
        memset(vis,0,sizeof(vis));
        vis[s]=1;q.push(s);dep[s]=0;
        while (!q.empty())
        {
            int u=q.front();q.pop();
            for (i=head[u];i;i=sq[i].nxt)
            {
                int v=sq[i].to;
                if ((!vis[v]) && (sq[i].flow))
                {
                    vis[v]=1;dep[v]=dep[u]+1;q.push(v);
                }
            }
        }
        if (!vis[t]) return 0;
        for (i=1;i<=n;i++) cur[i]=head[i];
        return 1;
    }

    int dfs(int now,int to,int lim)
    {
        if ((!lim) || (now==to)) return lim;
        int i,sum=0;
        for (i=head[now];i;i=sq[i].nxt)
        {
            int v=sq[i].to;
            if (dep[now]+1==dep[v])
            {
                int f=dfs(v,to,min(lim,sq[i].flow));
                if (f)
                {
                    lim-=f;sum+=f;
                    sq[i].flow-=f;
                    sq[i^1].flow+=f;
                    if (!lim) break;
                }
            }
        }
        return sum;
    }

    int work()
    {
        int ans=0;
        while (bfs()) ans+=dfs(s,t,maxd);
        return ans;
    }
}dinic;

int n,m,fa[100100],s,t,ans;

int read()
{
    int x=0,f=1;char ch=getchar();
    while ((ch<'0') || (ch>'9')) {if (ch=='-') f=-1;ch=getchar();}
    while ((ch>='0') && (ch<='9')) {x=x*10+(ch-'0');ch=getchar();}
    return x*f;
}

void init()
{
    n=read();m=read();int i;
    dinic.init(n);s=2*n+1;t=2*n+2;
    for (i=1;i<=n;i++) {dinic.add(s,i,1);dinic.add(i+n,t,1);}
    for (i=1;i<=m;i++)
    {
        int u=read(),v=read();
        dinic.add(u,v+n,1);
    }
}

int find(int u)
{
    if (fa[u]==u) return u;
    fa[u]=find(fa[u]);
    return fa[u];
}

void out_road(int u)
{
    printf("%d ",u);int i;
    for (i=dinic.head[u];i;i=dinic.sq[i].nxt)
    {
        int v=dinic.sq[i].to;
        if ((v>n) && (v<=2*n) && (!dinic.sq[i].flow)) out_road(v-n);
    }
}

void out()
{
    int i;
    for (i=1;i<=n;i++) fa[i]=i;
    //cout << n << endl;
    for (i=2;i<=dinic.all;i++)
    {
        if ((dinic.sq[i].from>=1) && (dinic.sq[i].from<=n) && (dinic.sq[i].to>n) && (dinic.sq[i].to<=2*n) && (!dinic.sq[i].flow))
        {
            int u=dinic.sq[i].from,v=dinic.sq[i].to-n;
            int fu=find(u),fv=find(v);
            if (fu!=fv) fa[fv]=fu;
        }
    }
    for (i=1;i<=n;i++) 
        if (fa[i]==i) {out_road(i);printf("
");}
    printf("%d",n-ans);
}

int main()
{
    init();
    ans=dinic.work();
    out();
    return 0;
}