POJ 2594 Treasure Exploration 最小可相交路径覆盖

最小路径覆盖

DAG的最小可相交路径覆盖：

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

这里解释一下floyd的作用如果1->2->3->4那么1可以到达2，3，4只要需要借助一些点，那么就可以直接把1与2，3，4相连，这就是floyd要做的事。

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

POJ 2594题意：

首先给你一个DAG，你需要派机器人到达某个宝藏的位置，然后机器人可以沿着道路走下去。这些宝藏可以被多个机器人到达。问至少需要多少个机器人

可以把所有宝藏位置都探索一边

题解：

如果把宝藏当作顶点，首先我们可以判断某些顶点可能不止使用一次。这道题的一部分和 这道题 很相似，这里都不复述了。同样也需要用到拆点操作

知道拆点和最小不相交路径覆盖就可以解决了

代码：

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<iostream>
#include<queue>
#include<vector>
using namespace std;
const int maxn=510;
int n,match[maxn],visit[maxn],v[maxn][maxn];
int floyd()  //就光多了这一个函数
{
    for(int i=1;i<=n;++i)
    {
        for(int j=1;j<=n;++j)
        {
            for(int k=1;k<=n;++k)
            {
                if(v[i][k] && v[k][j])
                    v[i][j]=1;
            }
        }
    }
}
int dfs_solve(int x)
{
    for(int i=1;i<=n;++i)
    {
        if(v[x][i] && !visit[i])
        {
            visit[i]=1;
            if(match[i]==0 || dfs_solve(match[i]))
            {
                match[i]=x;
                return 1;
            }
        }
    }
    return 0;
}
int hungran()
{
    int ans=0;
    memset(match,0,sizeof(match));
    for(int i=1;i<=n;++i)
    {
        memset(visit,0,sizeof(visit));
        ans+=dfs_solve(i);
    }
    return ans;
}
int main()
{
    int m;
    while(~scanf("%d%d",&n,&m))
    {
        if(!n && !m) break;
        memset(v,0,sizeof(v));
        while(m--)
        {
            int u,vv;
            scanf("%d%d",&u,&vv);
            v[u][vv]=1;
        }
        floyd();
        printf("%d
",n-hungran());
    }
    return 0;
}