Poj 2594 Treasure Exploration (最小边覆盖+传递闭包)

题目链接：

　　Poj 2594 Treasure Exploration

题目描述：

　　在外星上有n个点需要机器人去探险，有m条单向路径。问至少需要几个机器人才能遍历完所有的点，一个点可以被多个机器人经过。

解题思路：

　　一眼看上去是普通的最小边覆盖，但是仔细想后发现如果在原图上进行最大匹配的话，每个点只能经过一次。这样的话对于本题求出的并不是最优解，所以我们要先对原图进行传递闭包处理，然后再进行最大匹配。

这个题目点数太少H_K和匈牙利算法在空间和时间上并没有什么差，就代码复杂度而言匈牙利算法更有优势。

#include <iostream>//匈牙利算法
#include <cstring>
#include <queue>
#include <cmath>
#include <cstdio>
using namespace std;

const int maxn = 510;
int maps[maxn][maxn], n, m;
int used[maxn], vis[maxn];
void floyd ()
{
    for (int k=1; k<=n; k++)
        for (int i=1; i<=n; i++)
            for (int j=1; j<=n; j++)
                if (maps[i][k] && maps[k][j])
                    maps[i][j] = 1;
}
int Find (int u)
{
    for (int i=1; i<=n; i++)
    {
        if (!vis[i] && maps[u][i])
        {
            vis[i] = 1;
            if (!used[i] || Find(used[i]))
            {
                used[i] = u;
                return 1;
            }
        }
    }
    return 0;
}
int main ()
{
    while (scanf ("%d %d", &n, &m), n||m)
    {
        memset (maps, 0, sizeof(maps));
        while (m --)
        {
            int u, v;
            scanf ("%d %d", &u, &v);
            maps[u][v] = 1;
        }
        floyd ();
        memset (used, 0, sizeof(used));
        int res = 0;
        for (int i=1; i<=n; i++)
        {
            memset (vis, 0, sizeof(vis));
            res += Find(i);
        }
        printf ("%d\n", n - res);
    }
    return 0;
}

#include <iostream>//H_K算法
#include <cstring>
#include <queue>
#include <cmath>
#include <cstdio>
using namespace std;

const int maxn = 510;
const int INF = 0x3f3f3f3f;
int maps[maxn][maxn], n, m, dx[maxn], dy[maxn];
int vis[maxn], cx[maxn], cy[maxn], dis;
void floyd ()
{
    for (int k=1; k<=n; k++)
        for (int i=1; i<=n; i++)
            for (int j=1; j<=n; j++)
                if (maps[i][k] && maps[k][j])
                    maps[i][j] = 1;
}
bool bfs ()
{
    queue <int> Q;
    dis = INF;
    memset (dx, -1, sizeof(dx));
    memset (dy, -1, sizeof(dy));
    for (int i=1; i<=n; i++)
        if (cx[i] == -1)
            {
                Q.push(i);
                dx[i] = 0;
            }
    while (!Q.empty())
    {
        int u = Q.front();
        Q.pop();
        if (dx[u] > dis)
            break;
        for (int i=1; i<=n; i++)
        {
            if (dy[i]==-1 && maps[u][i])
            {
                dy[i] = dx[u] + 1;
                if (cy[i] == -1)
                    dis = dy[i];
                else
                {
                    dx[cy[i]] = dy[i] +1;
                    Q.push (cy[i]);
                }
            }
        }
    }
    return dis != INF;
}
int dfs (int u)
{
    for (int v=1; v<=n; v++)
    {
        if (!vis[v] && dx[u]+1==dy[v] && maps[u][v])
        {
            vis[v] = 1;
            if (cy[v]!=-1 && dis==dy[v])
                continue;
            if (cy[v]==-1 || dfs(cy[v]))
            {
                cx[u] = v;
                cy[v] = u;
                return 1;
            }
        }
    }
    return 0;
}
int Max_match ()
{
    int res = 0;
    memset (cx, -1, sizeof(cx));
    memset (cy, -1, sizeof(cy));
    while (bfs())
    {
        memset (vis, 0, sizeof(vis));
        for (int i=1; i<=n; i++)
            if (cx[i] == -1)
                res += dfs (i);
    }
    return res;
}
int main ()
{
    while (scanf ("%d %d", &n, &m), n||m)
    {
        memset (maps, 0, sizeof(maps));
        while (m --)
        {
            int u, v;
            scanf ("%d %d", &u, &v);
            maps[u][v] = 1;
        }
        floyd ();
        printf ("%d\n", n - Max_match());
    }
    return 0;
}