网络流24题3 最小路径覆盖问题 洛谷 2764

分析

设所求路径条数为p，所有路径所包含边总数为e，则易得p=n-e（定理1或证明1），要求最小的p就是求最大的e（即使得路径末尾的点数最少）。

现在问题在于如何求最大的e：我们将有向图转化为无向图，有向图的每个点拆成X集i和Y集i’，接下来：
1.若图中存在点i—>j，则二分图中i与i’相连
2.求最大匹配m(e)
3.ans=n-m

定理1：
每一条覆盖路径的边数=覆盖点数-1（即减去了路径末尾的那个顶点）

证明1：
一开始覆盖N个节点的是N条路径，设每个路径为一个集合，则每添加一条边，就合并两个集合（因为是无环图，所以集合内的节点不会互相连接），所以边越多，则集合越少，所以最小路径覆盖仅适合添加一条边能够合并两条路径的题目。

所以可以用网络流，注意输出方案时要注意不能用dfs会爆栈

code

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<string>
#include<algorithm>

using namespace std;

struct arr{
    int x,y,w;
    int op;
    int next;
}edge[5000000];
int ls[20000];
int v[20000];
int w[2000001];
int f[20000];
int queue[2000001];
int dis[20000];
int vv[20000];
int s,t;
int n,m,nn;
int min1;
int ans;

void er(int ww)
{
    w[nn]=ww;
}

void add(int x,int y,int w)
{
    nn++;
    edge[nn].x=x;
    edge[nn].y=y;
    edge[nn].w=w;
    edge[nn].op=nn+1;
    edge[nn].next=ls[x];
    ls[x]=nn;
    v[x]=nn;
    er(w);

    nn++;
    edge[nn].x=y;
    edge[nn].y=x;
    edge[nn].w=w;
    edge[nn].op=nn-1;
    edge[nn].next=ls[y];
    ls[y]=nn;
    v[y]=nn;
    er(0);
}

bool bfs()
{
    memset(dis,-1,sizeof(dis));
    memset(queue,0,sizeof(queue));
    int head,tail;
    head=0; tail=1;
    queue[head]=0;
    dis[0]=0;
    do
    {
        head++;
        int i=ls[queue[head]];
        while (i!=0)
        {
            if ((w[i]>0)&&(dis[edge[i].y]==-1))
            {
                dis[edge[i].y]=dis[edge[i].x]+1;
                tail++;
                queue[tail]=edge[i].y;
                if (edge[i].y==t)  return true;
            }
            i=edge[i].next;
        }
    }while (head<tail);
    return false;
}

bool find(int x,int num)
{
    if (x!=s) min1=min(min1,w[num]);
    if (x==t) return true;
    for (int i=v[x];i!=0;i=edge[i].next)
    {
        int x=edge[i].x;
        int y=edge[i].y;
        if ((dis[x]+1==dis[y])&&(w[i]!=0)&&(find(y,i)))
        {
            f[x]=y;
            w[i]-=min1;
            w[edge[i].op]+=min1;
            return true;
        }
    }
    return false;
}

int dinic()
{
    while (bfs())
    {
        min1=2000000000;
        find(s,0);
        ans=ans+min1;
    }
    bfs();
    for (int i=1;i<=n;i++)
    {
        if (f[i]!=0)
        {
            int x=i;
            do
            {
                printf("%d ",x);
                if (f[x]==0) break;
                int y=f[x];
                f[x]=0;
                x=y-n;
            }while (1==1);
            printf("\n");
        }
    }
    printf("%d",n-ans); 
}

int main()
{
    scanf("%d%d",&n,&m);
    int x,y;
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y+n,1);
    }
    s=0;
    t=n+n+1;
    for (int i=1;i<=n;i++)
    {
        add(s,i,1);
    }
    for (int i=n+1;i<=n+n;i++)
    {
        add(i,t,1);
    }
    dinic();
    return 0;
}