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 = ;

 int maps[maxn][maxn], n, m;

 int used[maxn], vis[maxn];

 void floyd ()

 {

     for (int k=; k<=n; k++)

         for (int i=; i<=n; i++)

             for (int j=; j<=n; j++)

                 if (maps[i][k] && maps[k][j])

                     maps[i][j] = ;

 }

 int Find (int u)

 {

     for (int i=; i<=n; i++)

     {

         if (!vis[i] && maps[u][i])

         {

             vis[i] = ;

             if (!used[i] || Find(used[i]))

             {

                 used[i] = u;

                 return ;

             }

         }

     }

     return ;

 }

 int main ()

 {

     while (scanf ("%d %d", &n, &m), n||m)

     {

         memset (maps, , sizeof(maps));

         while (m --)

         {

             int u, v;

             scanf ("%d %d", &u, &v);

             maps[u][v] = ;

         }

         floyd ();

         memset (used, , sizeof(used));

         int res = ;

         for (int i=; i<=n; i++)

         {

             memset (vis, , sizeof(vis));

             res += Find(i);

         }

         printf ("%d\n", n - res);

     }

     return ;

 }

 #include <iostream>//H_K算法

 #include <cstring>

 #include <queue>

 #include <cmath>

 #include <cstdio>

 using namespace std;

 const int maxn = ;

 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=; k<=n; k++)

         for (int i=; i<=n; i++)

             for (int j=; j<=n; j++)

                 if (maps[i][k] && maps[k][j])

                     maps[i][j] = ;

 }

 bool bfs ()

 {

     queue <int> Q;

     dis = INF;

     memset (dx, -, sizeof(dx));

     memset (dy, -, sizeof(dy));

     for (int i=; i<=n; i++)

         if (cx[i] == -)

             {

                 Q.push(i);

                 dx[i] = ;

             }

     while (!Q.empty())

     {

         int u = Q.front();

         Q.pop();

         if (dx[u] > dis)

             break;

         for (int i=; i<=n; i++)

         {

             if (dy[i]==- && maps[u][i])

             {

                 dy[i] = dx[u] + ;

                 if (cy[i] == -)

                     dis = dy[i];

                 else

                 {

                     dx[cy[i]] = dy[i] +;

                     Q.push (cy[i]);

                 }

             }

         }

     }

     return dis != INF;

 }

 int dfs (int u)

 {

     for (int v=; v<=n; v++)

     {

         if (!vis[v] && dx[u]+==dy[v] && maps[u][v])

         {

             vis[v] = ;

             if (cy[v]!=- && dis==dy[v])

                 continue;

             if (cy[v]==- || dfs(cy[v]))

             {

                 cx[u] = v;

                 cy[v] = u;

                 return ;

             }

         }

     }

     return ;

 }

 int Max_match ()

 {

     int res = ;

     memset (cx, -, sizeof(cx));

     memset (cy, -, sizeof(cy));

     while (bfs())

     {

         memset (vis, , sizeof(vis));

         for (int i=; i<=n; i++)

             if (cx[i] == -)

                 res += dfs (i);

     }

     return res;

 }

 int main ()

 {

     while (scanf ("%d %d", &n, &m), n||m)

     {

         memset (maps, , sizeof(maps));

         while (m --)

         {

             int u, v;

             scanf ("%d %d", &u, &v);

             maps[u][v] = ;

         }

         floyd ();

         printf ("%d\n", n - Max_match());

     }

     return ;

 }