HDU 3861 The King’s Problem 缩点+二分匹配

题意：有一个有向图，这个图中对于块的定义是：1.如果有两个点u，v，从u到v有一条边并且从v到u也有一条边，那么一定属于块；2.每一个块中的两个点u，v从u到v有一条边或者从v到u有一条边，u到v的过程中不能经过其它的块，那么他也属于块。问你这个图最少可以分为多少个块。

想法：对于强连通的块属于题中的块，那么从强连通的块之间找关系，来确定题中的块，则强连通的块需要满足题中的2号条件，有2号条件和有向边可知，一条走到底的路径可以将上面的所有强连通块归纳到一个题中的块中，即：Kuai1->Kuai2->Kuai4->...->Kuain，对于这样的就可以，那么问题就又转化为了，求最小的路径覆盖数，那么就是二分匹配问题，即强连通块数-最大二分匹配数，就是答案。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
#include<vector>
using namespace std;
const int nodes=5000+5;
const int edges=100000+50;
int n,m;
struct node
{
    int v,next;
}e[edges];
vector<int>ve[nodes];
stack<int>s;
int head[nodes],cnt;
int link[nodes],vis[nodes];
int dfn[nodes],low[nodes],instack[nodes],paint[nodes];
int index,col;
void Init()
{
     memset(head,-1,sizeof(head));
     memset(dfn,0,sizeof(dfn));
     memset(low,0,sizeof(low));
     while(!s.empty()) s.pop();
     for(int i=1;i<=n;i++)
     ve[i].clear();
     memset(instack,0,sizeof(instack));
     memset(paint,0,sizeof(paint));
     index=col=1; 
     cnt=0;
} 
void add(int a,int b)
{
    e[cnt].v=b;
    e[cnt].next=head[a];
    head[a]=cnt++;
}
int Min(int a,int b)
{
    if(a<b) return a;
    return b;
}
void tarjan(int u)
{
    dfn[u]=low[u]=index++;
    instack[u]=1;
    s.push(u);
    for(int i=head[u];i+1;i=e[i].next)
    {
        int v=e[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=Min(low[u],low[v]);
        }
        else if(instack[v])
        {
            low[u]=Min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u])
    {
        int k=s.top();
        while(k!=u)
        {
            s.pop();
            instack[k]=0;
            paint[k]=col;
            k=s.top();
        }
        s.pop();
        instack[u]=0;
        paint[u]=col;
        col++;
    }
}
void tarjan_slove()
{
    for(int i=1;i<=n;i++)
    {
        if(!dfn[i]) tarjan(i);
    }
    col--;
}
void build_map()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=head[i];j+1;j=e[j].next)
        {
            int a=i,b=e[j].v;
            if(paint[a]!=paint[b])
            {
                ve[paint[a]].push_back(paint[b]);
            }
        }
    }
}
int dfs(int u)
{
    for(int i=0;i<ve[u].size();i++)
    {
        int v=ve[u][i];
        if(!vis[v])
        {
            vis[v]=1;
            if(link[v]==-1||dfs(link[v]))
            {
                link[v]=u;
                return 1;
            }
        }
    }
    return 0;
}
void slove()
{
    memset(link,-1,sizeof(link));
    int res=0;
    for(int i=1;i<=col;i++)
    {
        memset(vis,0,sizeof(vis));
        res+=dfs(i);
    }
    printf("%d\n",col-res);
}
int main()
{
    int test;
    scanf("%d",&test);
    while(test--)
    {
        scanf("%d%d",&n,&m);
        Init();
        for(int i=1;i<=m;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            add(a,b);
        }
        tarjan_slove();
        build_map();
        slove();
    }
    return 0;
}