hdu3861 强联通＋最小路经覆盖

题意：国王有n个城市和m条道路要划分为州

有三个条件 1.在一个州里的两个城市x，y 至少要有一条路 从x－》y或者从y－》x

   2每个城市只能存在于一个州里

   3如果两个城市能够互相到达 那么这两个城市一定在一个州里

解法：先进行缩点 所得到的一定是在一个州中的 然后进行二分匹配

此时匹配完的可以完成条件1

那么好 我们可以发现把匹配对进行合并之后就是所需要的州数

这个其实就是个二分匹配 

然后最小路径覆盖数指的是缩点以后的DAG图上的（其实就是最大匹配数）

#pragma comment(linker,"/STACK:102400000,102400000")
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <string>
#include <math.h>
#include <queue>
#include <stack>
#include <map>
#include <set>
using namespace std;
typedef long long ll;   //记得必要的时候改成无符号
const int maxn=100005;   //点数
const int maxm=500005;   //边数
const int INF=1000000000;
struct EdgeNode
{
    int from;
    int to;
    int next;
}edge[maxm];
int head[maxn],cnt;
void add(int x,int y)
{
    edge[cnt].from=x;edge[cnt].to=y;edge[cnt].next=head[x];head[x]=cnt++;
}

void init()
{
    cnt=1;
    memset(head,-1,sizeof(head));
}

int dfn[maxn],low[maxn],ins[maxn];
int cixu,scc_count,n,ru[maxn],chu[maxn],sd[maxn];
stack<int>S;

void dfs(int u)
{
    int v,x;
    dfn[u]=low[u]=++cixu;
    S.push(u);
    ins[u]=1;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(!dfn[v]){
            dfs(v);
            low[u]=min(low[u],low[v]);
        }
        else if(ins[v])
            //如果已经搜过，并且在栈里面，如果不在栈里面，说明该点属于其他的强连通分量里面
            low[u]=min(low[u],dfn[v]);
             //此处low代替dfn也是可以的，但是在tarjan求无向图的时候不能
    }
    if(dfn[u]==low[u])
//表示u为此强连通分量第一个被发现的点，属于该强连通分量的所有的其他点都在栈中，他的上面
    {
        scc_count++;
        do
        {
            x=S.top();
            S.pop();
            sd[x]=scc_count;
            ins[x]=0;
        }while(x!=u);
    }
}

void tarjan()
{
    for(int i=1;i<=n;i++)sd[i]=i;   //缩点标记数组
    memset(ins,0,sizeof(ins));
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    cixu=scc_count=0;
    for(int i=1;i<=n;i++)        //可能所给的图为不连通的图，分块，因此需要遍历所有的点
    {
        if(!dfn[i])
            dfs(i);
    }
}

void SD()
{
    int x,y,len=cnt;
    init();
    memset(ru,0,sizeof(ru));
    memset(chu,0,sizeof(chu));
    for(int i=1;i<len;i++){
        x=sd[edge[i].from]; y=sd[edge[i].to];
        if(x==y)continue;
        add(x,y);
        chu[x]++; ru[y]++;
    }
}

int link[maxn],vis[maxn];
int dfss(int l){
    vis[l]=1;
    for(int i=head[l];i!=-1;i=edge[i].next){
        int r=edge[i].to;
        if(!vis[r]){
            vis[r]=1;
            if(link[r]==-1||dfss(link[r])){
                link[r]=l;
                return 1;
            }
        }
    }
    return 0;
}
int find(){
    int res=0;
    memset(link,-1,sizeof link);
    for(int i=1;i<=scc_count;++i){
        memset(vis,0,sizeof vis);
        if(dfss(i))res++;
    }
    return res;
}
int value[maxn],va[maxn];
// scc_count 1...
int main()
{
    int m,i,p,sum,x,y;
    int _;scanf("%d",&_);
    while(_--){
        scanf("%d%d",&n,&m);
        init(); sum=0; p=0;
        for(i=1;i<=m;i++){
            scanf("%d%d",&x,&y);
            add(x,y);
        }
        tarjan();
        SD();
        int x=find();
        printf("%d\n",scc_count-x);
    }
    return 0;
}