[强联通分量_tarjan] 0725

tarjan算法的思路不难理解，用low来标记同一个强联通分量中的点，初始时low[i]=dfn[i]，当访问到已经在当前栈中的顶点时，相当于找到了一个强联通分量的根节点（一个强联通分量中最早访问到的作为根节点），然后递归地更新栈中所有节点，如果遇到low[k]=dfn[k]，说明k就是这个分量的根，于是对之前的所有点出栈并标记（此处标记用连续的值1，2，3代表第几个强联通分量，其实可以直接用low就行，cols记录强联通分量的个数）。

# include <cstdio>
# include <cstring>

# define N (100 + 5)
# define M (N * N)

int n, m;
int top, cols, tmpdfn;
char ins[N];
int first[N], dfn[N], low[N], s[N], in[N], out[N], c[N];
int u[M], v[M], next[M];

int Min(int x, int y)
{
    return x<y ? x:y;
}

void tarjan(int x)
{
    dfn[x] = low[x] = ++tmpdfn;
    s[top++] = x;
    ins[x] = 1;
    for (int e = first[x]; e != -1; e = next[e])
    {
        int y = v[e];
        if (!dfn[y])
        {
            tarjan(y);
            low[x] = Min(low[x], low[y]);
        }
        else if (ins[y])
            low[x] = Min(low[x], dfn[y]);
    }
    if (dfn[x] == low[x])
    {
        int t;
        ++cols;
        do
        {
            t = s[--top];
            ins[t] = 0;
            c[t] = cols;
        } while (x != t);
    }
}

void cal(void)
{
    top = 0, cols = 0, tmpdfn = 0;
    memset(dfn+1, 0, sizeof(int)*n);
    memset(ins+1, 0, sizeof(char)*n);
    for (int i = 1; i <= n; ++i) if (!dfn[i])
        tarjan(i);
}

void solve(void)
{
    cal();
    if (cols == 1)
    {
        printf("1\n0\n");
        return ;
    }
    memset(in+1, 0, sizeof(int)*cols);
    memset(out+1, 0, sizeof(int)*cols);
    for (int i = 1; i <= n; ++i)
    for (int e = first[i]; e != -1; e = next[e])
    {
        int j = v[e];
        if (c[i] != c[j])
        {
            ++in[c[j]];
            ++out[c[i]];
        }
    }
    int zin = 0, zout = 0;
    for (int i = 1; i <= cols; ++i)
    {
        if (!in[i]) ++zin;
        if (!out[i]) ++zout;
    }
    printf("%d\n%d\n", zin, zin>zout ? zin:zout);
}

void read_graph(void)
{
    memset(first+1, -1, sizeof(int)*n);
    for (int i = 1; i <= m; ++i)
    {
        scanf("%d%d", &u[i], &v[i]);
        next[i] = first[u[i]];
        first[u[i]] = i;
    }
}

int main()
{
    while (~scanf("%d%d", &n, &m))
    {
        read_graph();
        solve();
    }
    
    return 0;
}

targin的主体比较”死板“，整体相比两遍DFS（kosaraju）代码不短多少，只是思路是一条线，复杂度和后者只是常数的区别，但可以使用邻接表加速，后者不好使用。