链接：POJ - 2594 Treasure Exploration

题意：

给出一个含有 $n\,(1\le n\le 500)$个结点、 $m(0\le m\le 5000)$条边的有向无环图（DAG），机器人可以从任意点出发，问至少需要多少机器人，才能遍历图上所有点？（允许同一点同时存在多个机器人）

分析：

即求DAG上 最小可相交路径覆盖；

利用floyd算法，求出该图的传递闭包（若 $i\rarr j$可达，则连边 $<i,j>$），然后在传递闭包上求 最小不相交路径覆盖 即可。

• 最小不相交路径覆盖 $=$总点数 $-$对应二分图最大匹配

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long LL;
const int INF=0x3f3f3f3f;
const int maxn=1e6+10;
int s=0,t=maxn-1;
int head[maxn],cnt;
struct edge
{
	int w;           //边的流量（残量）
	int to;          //该边通向的结点v
	int next;        //点u邻接表的下一条边
}e[maxn];
void add_edge(int u,int v,int w)   //添加一条u->v，最大容量为w的边
{
    //建立正向边
	e[cnt].w=w;
	e[cnt].to=v;
	e[cnt].next=head[u];
	head[u]=cnt;
	cnt++;
	//建立反向边
	e[cnt].w=0;        //有些图是需要建立双向边(例如求最小割时），则反向边的初始残量不为0
	e[cnt].to=u;
	e[cnt].next=head[v];
	head[v]=cnt;
	cnt++;
}
int dis[maxn];     //dis数组记录层次
bool bfs()         //利用BFS建立分成图，从而可以多次DFS增广
{
	memset(dis,-1,sizeof(dis));     //初始化dis数组
	queue<int> q;
	q.push(s);
	dis[s]=0;      //源点层次为0
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		for(int i=head[u];i!=-1;i=e[i].next)
		{
			int v=e[i].to;
			if(e[i].w>0&&dis[v]==-1)     //可达&&未分层
			{
				dis[v]=dis[u]+1;         //分层
				if(v==t)                 //若到达汇点，则分层结束，返回true
					return true;
				q.push(v);
			}
		}
	}
	return false;  //运行到此处，说明汇点已不可达，返回false
}
int cur[maxn];     //弧优化：cur数组用于记录上一次DFS增广时u已经增广到第几条边，从而优化时间
int dfs(int u,int flow)       //flow代表流入u点的最大流量
{
	if(u==t)
		return flow;          //到达汇点，直接返回flow
	for(int &i=cur[u];i!=-1;i=e[i].next)
	{                         //注意i前面用&引用，这样就可以直接改变cur[u]
		int v=e[i].to;
		if(dis[v]==dis[u]+1&&e[i].w>0)   //v为u的下一层&&可达
		{
			int k=dfs(v,min(flow,e[i].w));
			if(k>0)
			{
				e[i].w-=k;         //正向边-=k
				e[i^1].w+=k;       //反向边+=k
				return k;
			}
		}
	}
	return 0;       //无法继续增广，返回0
}
int dinic()
{
	int ans=0;      //记录总流量
	while(bfs())    //分层
	{
		for(int i=0;i<maxn;i++)    //初始化cur数组，即将head数组赋给cur数组
			 cur[i]=head[i];
		while(int k=dfs(s,INF))    //增广
			ans+=k;
	}
	return ans;
}
int n,m;
bool g[600][600];
void floyd()
{
    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])     //若i可到k,k可到j，则i可到j
                    g[i][j]=true;
            }
        }
    }
}
int main()
{
    while(scanf("%d %d",&n,&m)&&n+m)
    {
        memset(g,0,sizeof(g));
        memset(head,-1,sizeof(head));
        cnt=0;
        for(int i=1;i<=m;i++)
        {
            int a,b;
            scanf("%d %d",&a,&b);
            g[a][b]=true;
        }
        floyd();    //求传递闭包
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(g[i][j])
                    add_edge(i,n+j,1);    //建立网络流二分图匹配模型,求最小不相交路径覆盖
            }
        }
        for(int i=1;i<=n;i++)
        {
            add_edge(s,i,1);
            add_edge(n+i,t,1);
        }
        printf("%d\n",n-dinic());
    }
    return 0;
}