Treasure Exploration poj2594(传递闭包+最少路径覆盖)

Sample Input

1 0
2 1
1 2
2 0
0 0

Sample Output

1
1
2

题意：一副地图，单向边，但没有环，问最少有几条路径能覆盖全图（一条路径不能重复点，多条路径可以交叉）。
思路：先跑floyd闭环，找出那些点可达，然后用最小路径覆盖找到那些边，最后答案是总点-cnt。
补题参考链接：https://blog.csdn.net/guagua_de_xiaohai/article/details/86564298
代码：

#pragma comment(linker, "/STACK:1024000000,1024000000")
#pragma GCC optimize(2)
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<queue>
#include<set>
#include<cmath>
#include<string>
#include<map>
#include<vector>
#include<ctime>
#include<stack>
using namespace std;
#define mm(a,b) memset(a,b,sizeof(a))
typedef long long ll;
const long long mod = 1e9+7;
const int maxn = 5e2+10;
const int inf = 0x3f3f3f3f;
int un,vn;
int g[maxn][maxn];
int linker[maxn];
int used[maxn];
int n,mm;

bool dfs(int u)
{
    for(int v=1;v<=vn;v++)
    {
        if(g[u][v]&&!used[v])
        {
            used[v]=true;
            if(linker[v]==-1||dfs(linker[v]))
            {
                linker[v]=u;
                return true;
            }
        }
    }
    return false;
}

int hungary()
{
    int res=0;
    mm(linker,-1);
    for(int u=1;u<=un;u++)
    {
        mm(used,false);
        if(dfs(u)) res++;
    }
    return res;
}
int main()
{
    while(cin>>n>>mm&&n+mm)
    {
        int u,v;
        mm(g,0);
        while(mm--)
        {
            scanf("%d %d",&u,&v);
            g[u][v]=1;
        }
        un=vn=n;
        for(int k=1;k<=n;k++)
        {
            for(int i=1;i<=n;i++)
            {
                for(int j=1;j<=n;j++)
                {
                    if(g[i][k]&&g[k][j])
                        g[i][j]=1;
                }
            }
        }
        int ans=hungary();
        ans=n-ans;
        printf("%d\n",ans);
    }
    return 0;
}