HDU

思路：tarjarn缩点，然后剩下的就是纯粹的最小路径覆盖，最小路径覆盖=顶点数-匹配数。匹配数跑一遍匈牙利即可。

#include <iostream>
#include <queue>
#include <stack>
#include <cstdio>
#include <vector>
#include <map>
#include <set>
#include <bitset>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <string>
#include <sstream>
#include <time.h>
#define x first
#define y second
#define pb push_back
#define mp make_pair
#define lson l,m,rt*2
#define rson m+1,r,rt*2+1
#define mt(A,B) memset(A,B,sizeof(A))
using namespace std;
typedef long long LL;
//const double PI = acos(-1);
const int N=5e5+10;
const LL mod=1e9+7;
const int inf = 0x3f3f3f3f;
const LL INF=0x3f3f3f3f3f3f3f3fLL;
const int MAXN = 5010;//点数
const int MAXM = 200010;//边数
struct Edge
{
    int to,next;
} edge[MAXM],edge1[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];//Belong数组的值是1~scc
int Index,top;
int scc;//强连通分量的个数
bool Instack[MAXN];
int num[MAXN];//各个强连通分量包含点的个数，数组编号1~scc
//num数组不一定需要，结合实际情况
void addedge(int u,int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}
void Tarjan(int u)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        v = edge[i].to;
        if( !DFN[v] )
        {
            Tarjan(v);
            if( Low[u] > Low[v] )Low[u] = Low[v];
        }
        else if(Instack[v] && Low[u] > DFN[v])
            Low[u] = DFN[v];
    }
    if(Low[u] == DFN[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = scc;
            num[scc]++;
        }
        while( v != u);
    }
}
void solve(int N)
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    memset(num,0,sizeof(num));
    Index = scc = top = 0;
    for(int i = 1; i <= N; i++)
        if(!DFN[i])
            Tarjan(i);
}
int head1[MAXN],tot1;
void init()
{
    tot = 0;
    tot1 = 0;
    memset(head,-1,sizeof(head));
    memset(head1,-1,sizeof(head1));
}
void addedge1(int u,int v)
{
    edge1[tot1].to = v;
    edge1[tot1].next = head1[u];
    head1[u] = tot1++;
}
int linker[MAXN];
bool used[MAXN];
bool dfs(int u)
{
    for(int i = head1[u]; i != -1 ; i = edge1[i].next)
    {
        int v = edge1[i].to;
        if(!used[v])
        {
            used[v] = true;
            if(linker[v] == -1 || dfs(linker[v]))
            {
                linker[v] = u;
                return true;
            }
        }
    }
    return false;
}
int hungary(int uN)
{
    int res = 0;
    memset(linker,-1,sizeof(linker));
    for(int u = 1; u <=uN; u++)
    {
        mt(used,0);
        if(dfs(u))
        {
            res++;
        }
    }
    return res;
}
int main()
{
#ifdef Local
    freopen("data.txt","r",stdin);
#endif
    ios::sync_with_stdio(false);
    cin.tie(0);
    int T;
    int n,m,u,v;
    cin>>T;
    while(T--)
    {
        cin>>n>>m;
        init();
        for(int i=0; i<m; i++)
        {
            cin>>u>>v;
            addedge(u,v);
        }
        solve(n);
        for(int i=1; i<=n; i++)
        {
            for(int j=head[i]; ~j; j=edge[j].next) //j表示读入的是第几条边
            {
                if(Belong[i]!=Belong[edge[j].to])
                {
                   addedge1(Belong[i],Belong[edge[j].to]);
                   //cout<<Belong[i]<<"->"<<Belong[edge[j].to]<<endl;
                }
            }
        }
        //cout<<hungary(scc)<<endl;
        cout<<scc-hungary(scc)<<endl;
    }
#ifdef Local
    cerr << "time: " << (LL) clock() * 1000 / CLOCKS_PER_SEC << " ms" << endl;
#endif
}