二分图最小路径覆盖

原博客：点击打开链接

最小路径覆盖

定义：在一个有向图中，找出最少的路径，使得这些路径经过了所有的点。

最小路径覆盖分为最小不相交路径覆盖和最小可相交路径覆盖。

最小不相交路径覆盖：每一条路径经过的顶点各不相同。如图，其最小路径覆盖数为3。即1->3>4，2，5。

最小可相交路径覆盖：每一条路径经过的顶点可以相同。如果其最小路径覆盖数为2。即1->3->4，2->3>5。

特别的，每个点自己也可以称为是路径覆盖，只不过路径的长度是0。

DAG的最小不相交路径覆盖

算法：把原图的每个点V拆成    

和     两个点，如果有一条有向边A->B，那么就加边      

。这样就得到了一个二分图。那么最小路径覆盖=原图的结点数-新图的最大匹配数。

证明：一开始每个点都是独立的为一条路径，总共有n条不相交路径。我们每次在二分图里找一条匹配边就相当于把两条路径合成了一条路径，也就相当于路径数减少了1。所以找到了几条匹配边，路径数就减少了多少。所以有最小路径覆盖=原图的结点数-新图的最大匹配数。

因为路径之间不能有公共点，所以加的边之间也不能有公共点，这就是匹配的定义。

POJ1422

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int n,m;
int mapp[150][150];
int pp[150];
bool used[150];
int found(int x)
{
    for(int i=1;i<=n;i++)
    {
        if(mapp[x][i]&&!used[i])
        {
            used[i]=1;
            if(!pp[i]||found(pp[i]))
            {
                pp[i]=x;
                return 1;
            }
        }
    }
    return 0;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        scanf("%d",&m);
        int a,b;
        memset(mapp,0,sizeof(mapp));
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&a,&b);
            mapp[a][b]=1;
        }
        memset(pp,0,sizeof(pp));
        int sum=0;
        for(int i=1;i<=n;i++)
        {
            memset(used,0,sizeof(used));
            if(found(i)) sum++;
        }
        printf("%d\n",n-sum);
    }
}

DAG的最小可相交路径覆盖

算法：先用floyd求出原图的传递闭包，即如果a到b有路径，那么就加边a->b。然后就转化成了最小不相交路径覆盖问题。

证明：为了连通两个点，某条路径可能经过其它路径的中间点。比如1->3->4，2->4->5。但是如果两个点a和b是连通的，只不过中间需要经过其它的点，那么可以在这两个点之间加边，那么a就可以直达b，不必经过中点的，那么就转化成了最小不相交路径覆盖。

http://poj.org/problem?id=2594

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int n,m;
int mapp[505][505],pp[505];
bool used[505];
void floyd()//避免了1-3-4,2-3-5，这样可以把1-4,2-5当做路，这么一来就有了1-3，2-3，1-4,2-5三个路了
//最大匹配数增加了，n-最大匹配数减少了也就是最小路径减少了
{
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
            for(int k=1; k<=n; k++)
            {
                if(mapp[i][k]&&mapp[k][j])
                    mapp[i][j]=1;
            }
}
int found(int x)
{
    for(int i=1; i<=n; i++)
    {
        if(mapp[x][i]&&!used[i])
        {
            used[i]=1;
            if(!pp[i]||found(pp[i]))
            {
                pp[i]=x;
                return 1;
            }
        }
    }
    return 0;
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        if(n==0&&m==0)
            break;
        memset(mapp,0,sizeof(mapp));
        int a,b;
        for(int i=0; i<m; i++)
        {
            scanf("%d%d",&a,&b);
            mapp[a][b]=1;
        }
        floyd();
        memset(pp,0,sizeof(pp));
        int sum=0;
        for(int i=1; i<=n; i++)
        {
            memset(used,0,sizeof(used));
            if(found(i)) sum++;
        }
        printf("%d\n",n-sum);
    }
}