HDU3861 The King’s Problem 缩点变DAG 求分割出最小单连通子图数

/*
*State:  HDU3861 46MS 1468K 3001 B C++ 
*题目大意：
*        给定一个含有n个点的有向图，然后要求把这个有向图分为多个图，
*        要求如果图中有两个点能够互相到达的，必须把它们分为同一个图。
*        然后要求分割出来的图中，任意两个点之间一定可以互达。
*解题思路：
*        题目要求如果图中两个点可以互达，要分为同一个图，那么可以先
*        求出强连通分量，然后缩点。之后就是一个ADG，用笔画了很久，发现
*        一个ADG要分为多个分量，然后每个分量重每两个点有路径通过，最
*        最小分量，其实就是求这个ADG中有多少个不互相包含的链的个数。
*        求链的个数，我用了深搜，直接暴力一遍即可。
*/

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
using namespace std;

const int MAXN = 5005;
const int MAXE = 100005;

typedef struct _node
{
    int v, next;
}N;
N edge[MAXE];
int dfn[MAXN], low[MAXN], step;
int head[MAXN], myS[MAXN], top, cntEdge;
int inS[MAXN], minStateNum, id[MAXN], scc;

//bulid_ADG
vector<int> sccvec[MAXN];
int in[MAXN], vst[MAXN];

int vstval[MAXN], Flag;

void init()
{
    scc = 1;
    cntEdge = top = step = minStateNum = 0;
    for(int i = 0; i < MAXN; i++)
    {
        in[i] = vst[i] = 0;
        sccvec[i].clear();
        inS[i] = 0;
        head[i] = id[i] = -1;
        dfn[i] = low[i] = -1;
    }
}

void addEdge(int u, int v)
{
    edge[cntEdge].v = v;
    edge[cntEdge].next = head[u];
    head[u] = cntEdge++;
}

void tarjan_scc(int n)
{
    dfn[n] = low[n] = ++step;
    myS[top++] = n;
    inS[n] = 1;
    for(int f = head[n]; f != -1; f = edge[f].next)
    {
        int son = edge[f].v;
        if(dfn[son] == -1)
        {
            tarjan_scc(son);
            low[n] = min(low[n], low[son]);
        }
        else if(inS[son] == 1)
            low[n] = min(low[n], dfn[son]);
    }

    if(low[n] == dfn[n] && top != 0)
    {
        int tmp;
        do
        {
            
            tmp = myS[--top];
            id[tmp] = scc;
            inS[tmp] = 0;
        }while(top != 0 && tmp != n);
        scc++;
    }
}

bool judge(int n)
{
    for(unsigned i = 0; i < sccvec[n].size(); i++)
    {
        int son = sccvec[n][i];
        if(!vst[son])
            return false;
    }
    return true;
}

void dfs(int n, int step)
{
    if(Flag)
        return ;
    vstval[step] = n;
    if(sccvec[n].empty() || judge(n))
    {
        for(int i = 0; i <= step; i++)
        {
            vst[vstval[i]] = 1;
        }
        minStateNum++;
        Flag = 1;
    }
    for(unsigned i = 0; i < sccvec[n].size(); i++)
    {
        int son = sccvec[n][i];
        in[son]--;
        if(!vst[son])
        {
            dfs(son, step + 1);
        }
    }
}

bool isAll()
{
    for(int i = 1; i < scc; i++)
    {
        if(!vst[i])
            return true;
    }
    return false;
}

void bulid_ADG(int n)
{
    int u, v;
    for(int i = 1; i <= n; i++)
    {
        for(int f = head[i]; f != -1; f = edge[f].next)
        {
            u = i, v = edge[f].v;
            if(id[u] == id[v])
                continue;
            else
            {
                sccvec[id[u]].push_back(id[v]);
                in[id[v]]++;
            }
        }
    }
    while(isAll())
    {
        for(int i = 1; i < scc; i++)
        {
            if(in[i] == 0 && vst[i] == 0)
            {
                Flag = 0;
                dfs(i, 0);
            }
        }
    }
}

int main(void)
{
#ifndef ONLINE_JUDGE
    freopen("inHDU3861.txt", "r", stdin);
#endif

    int cas;
    scanf("%d", &cas);
    while(cas--)
    {
        init();
        int n, m, u, v;
        scanf("%d %d", &n, &m);
        for(int i = 0; i < m; i++)
        {
            scanf("%d %d", &u, &v);
            addEdge(u, v);
        }
        for(int i = 1; i <= n; i++)
        {
            if(dfn[i] == -1)
                tarjan_scc(i);
        }

        bulid_ADG(n);
        printf("%d\n", minStateNum);
    }
    return 0;
}