hdu3861 The King’s Problem （强连通+最小路径覆盖）

题意：题目的意思很清晰，对于一个有向图，将N个点划分成最少的集合个数，同时满足俩个条件：

首先，最小路径覆盖=总节点数-最大匹配数。这个应该已经是路人皆知了。

所谓最小路径覆盖，是指在一个有向图中，找出最少的几条路径，用它们来覆盖全图

1） 任意俩点，若互相可达，则必须在同一个集合中

2）属于同一个集合的任意俩个点对（u，v），至少存在一条路径，使得v对于u 可达 或者 u 对于v 可达

分析：对于上述俩个条件，为了简化问题，需要进行缩点，属于同一个强连通分量的点，缩成同一个点，重新构图，可以用tarjan 算法；

这样，第一个条件就一定满足了，接着只剩下第二个条件了，其实，任意俩点，只要在同一条有向路径上，则可以属于一个集合，所以这条路径上的点都是一个集合，最小路径有多少条，就可以分为多少的集合（子图），，那么问题就转化为用最小的有向路径去覆盖所有的点（最小路径覆盖数==点数-最大匹配数）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>


using namespace std;


const int VM=50100;
const int EM=100010;
const int INF=0x3f3f3f3f;


struct Edge{
    int to,nxt;
}edge[EM<<1];


int n,m,cnt,head[VM];
int dep,top,atype;
int dfn[VM],low[VM],vis[VM],stack[VM],belong[VM];
vector<int> vt[VM];


void addedge(int cu,int cv){
    edge[cnt].to=cv;    edge[cnt].nxt=head[cu];     head[cu]=cnt++;
}


void Tarjan(int u){              
    dfn[u]=low[u]=++dep;
    stack[top++]=u;
    vis[u]=1;   //开始这里写成=0,WA～～～～～！！！！！！！！
    for(int i=head[u];i!=-1;i=edge[i].nxt){
        int v=edge[i].to;
        if(!dfn[v]){
            Tarjan(v);
            low[u]=min(low[u],low[v]);
        }else if(vis[v]){
            low[u]=min(low[u],dfn[v]);
        }
    }
    int j;
    if(dfn[u]==low[u]){
        atype++;
        do{
            j=stack[--top];
            belong[j]=atype;      //j点属于atype连通分量
            vis[j]=0;
        }while(u!=j);
    }
}


void init(){
    cnt=0;
    memset(head,-1,sizeof(head));
    dep=0,  top=0,  atype=0;
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(vis,0,sizeof(vis));
    memset(belong,0,sizeof(belong));
}


int linker[VM];


int DFS(int u){       
    int v;
    for(int i=0;i<(int)vt[u].size();i++){
        v=vt[u][i];
        if(!vis[v]){
            vis[v]=1;
            if(linker[v]==-1 || DFS(linker[v])){
                linker[v]=u;
                return 1;
            }
        }
    }
    return 0;
}


int Hungary(){
    int ans=0,u;
    memset(linker,-1,sizeof(linker));
    for(u=1;u<=atype;u++){
        memset(vis,0,sizeof(vis));
        if(DFS(u))
            ans++;
    }
    return ans;
}


int main(){


    //freopen("input.txt","r",stdin);


    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&m);
        init();
        for(int i=1;i<=n;i++)
            vt[i].clear();
        int u,v;
        while(m--){
            scanf("%d%d",&u,&v);
            addedge(u,v);
        }
        for(int i=1;i<=n;i++)       //求强连通分量
            if(!dfn[i])
                Tarjan(i);
        for(int u=1;u<=n;u++)      //缩点，重新构图
            for(int i=head[u];i!=-1;i=edge[i].nxt){
                int v=edge[i].to;
                if(belong[u]!=belong[v])      //两点属于不同连通分量，连边
                    vt[belong[u]].push_back(belong[v]);
            }
        //printf("atype=%d\n",atype);
        printf("%d\n",atype-Hungary());    //最小路径覆盖
    }
    return 0;
}