有向图的强连通分量

tarjan算法可以用来求强连通分量（SCC）
作用： 将有向图（通过缩点,将所有连通分量缩成一点）——>有向无环图（DAG）满足拓扑序。
tarjan算法梳理的思路：
1.加时间戳；
2.放入栈中，做好标记；
3.遍历邻点：
1)如果没遍历过，tarjan一遍，用low[j]更新最小值low；
2) 如果在栈中，用dfn[j]更新最小值low
4.找到最高点：
1）scc个数++
2）do-while循环：从栈中取出每个元素；标志为出栈；对元素做好属于哪个scc；该scc中点的数量++
例题：Acwing1174. 受欢迎的牛
现在有 N 头牛，编号从 1 到 N，给你 M 对整数 (A,B)，表示牛 A 认为牛 B 受欢迎。这种关系是具有传递性的，如果 A 认为 B 受欢迎，B 认为 C 受欢迎，那么牛 A 也认为牛 C 受欢迎。求出有多少头牛被除自己之外的所有牛认为是受欢迎的。
思路：
当出度为0的强连通分量只有一个,则该强连通分量中的所有点都被其他强连通分量的牛欢迎，且连通分量里的牛是相互欢迎的。所以答案为出度为0强连通分量里的节点数。
但假如存在两及以上个出度为0的强连通分量，则没有牛被所有牛欢迎。

#include<bits/stdc++.h>
using namespace std;

const int N = 1e4+5, M = 5e5+5;
int head[N],ne[M],e[M],idx;
int dfn[N],low[N],te;
//dfn[u]:表示遍历到u的时间戳
//low[u]:表示从u开始走，所能遍历到的最小时间戳
int stk[N],top;
bool in_stk[N];
int id[N],scc_cnt,sz[N];//每个强连通分量的节点个数
int dout[N];

void add(int a,int b){
    e[idx] = b, ne[idx] = head[a], head[a] = idx++;
}


void tarjan(int u){
    low[u] = dfn[u] = ++te;//u的时间戳
    stk[++top] = u; in_stk[u] = true;
    for(int i = head[u]; ~i; i = ne[i]){
        int j = e[i];
        if(!dfn[j]){//j点为遍历过
            tarjan(j);
            low[u] = min(low[u], low[j]);
            //用儿子节点j能走的最小时间戳更新u能走到的最小时间戳
        }
        else if(in_stk[j]){
            //如果那个点还在栈中
            //说明出现了一个强连通分量SCC，而且当前这个强连通分量还没有被遍历完
            //则这个j，要么是当前点u的祖先，要么是u通过横叉边连到另一个强联通分量
            //无论如何，这个j的时间戳都必定小于当前u的时间戳
            //我们就用他的时间戳来更新一下u的low
            low[u] = min(low[u], dfn[j]);
        }
    }
    // 所以当遍历完u的所有能到的点后 发现u最高能到的点是自己
    // 1 则u为强连通分量中的最高点,则以u为起点往下把该强连通分量所有节点都找出来
    // 2 要么它就没有环,就是一个正常的往下的点
    if(low[u] == dfn[u]){
        ++scc_cnt;
        int y;
        do{
            y = stk[top--];
            in_stk[y] = false;
            id[y] = scc_cnt;
            sz[scc_cnt] ++;
        }while(y != u);
    }
}

int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    memset(head,-1,sizeof head);
    while(m--){
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b);
    }
    
    for(int i=1;i<=n;i++){
        if(!low[i]) tarjan(i);
    }
    //缩点，建立拓扑图（DAG）
    for(int i=1;i<=n;i++){
        for(int j=head[i];~j;j=ne[j]){
            int k = e[j];
            int a = id[i], b = id[k];
            if(a != b) dout[a]++;
        }
    }
    //和题目有关：如果出度为0的点大于1个，则这这些出度为0的连通块里的人不能相互喜欢，所以答案为0
    //如果出度为0的点只有一个，这该点连通分量的节点个数就是答案
    int zeros = 0, sum = 0;
    for(int i=1;i<=scc_cnt;i++){
        if(!dout[i]){
            zeros++;
            sum+=sz[i];
            if(zeros > 1){
                sum = 0;
                break;
            }
        }
    }
    printf("%d",sum);
    
    return 0;
}

---

用tarjan解决差分约束问题
例题
AcWing 368. 银河
做法：
1 不等式建图
2 超级源点连边(加绝对关系限制）
3 跑tarjan算法
4 建立拓扑图（缩点）
5 如果SCC内部有正边，返回无解
6 按照拓扑图跑一边求从0点到每个SCC的最长路
7 加总每个SCC的最长路 * SCC的size

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 100010, M = 600010;
//注意边要开的空间大小
int n, m;
int h[N], hs[N], e[M], ne[M], w[M], idx;
int dfn[N], low[N], timestamp;
int stk[N], top;
bool in_stk[N];
int id[N], scc_cnt, sz[N];
int dist[N];

void add(int h[], int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

void tarjan(int u)
{
    dfn[u] = low[u] = ++ timestamp;
    stk[ ++ top] = u, in_stk[u] = true;

    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (!dfn[j])
        {
            tarjan(j);
            low[u] = min(low[u], low[j]);
        }
        else if (in_stk[j]) low[u] = min(low[u], dfn[j]);
    }

    if (dfn[u] == low[u])
    {
        ++ scc_cnt;
        int y;
        do {
            y = stk[top -- ];
            in_stk[y] = false;
            id[y] = scc_cnt;
            sz[scc_cnt] ++ ;
        } while (y != u);
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);
    memset(hs, -1, sizeof hs);

    for (int i = 1; i <= n; i ++ ) add(h, 0, i, 1);

    while (m -- )
    {
        int t, a, b;
        scanf("%d%d%d", &t, &a, &b);
        if (t == 1) add(h, b, a, 0), add(h, a, b, 0);
        else if (t == 2) add(h, a, b, 1);
        else if (t == 3) add(h, b, a, 0);
        else if (t == 4) add(h, b, a, 1);
        else add(h, a, b, 0);
    }

    tarjan(0);

    bool success = true;
    for (int i = 0; i <= n; i ++ )
    {
        for (int j = h[i]; ~j; j = ne[j])
        {
            int k = e[j];
            int a = id[i], b = id[k];
            if (a == b)
            {
                if (w[j] > 0)
                {
                    success = false;
                    break;
                }
            }
            else add(hs, a, b, w[j]);
        }
        if (!success) break;
    }

    if (!success) puts("-1");
    else
    {
        for (int i = scc_cnt; i; i -- )
        {
            for (int j = hs[i]; ~j; j = ne[j])
            {
                int k = e[j];
                dist[k] = max(dist[k], dist[i] + w[j]);
            }
        }

        LL res = 0;
        for (int i = 1; i <= scc_cnt; i ++ ) res += (LL)dist[i] * sz[i];

        printf("%lld\n", res);
    }

    return 0;
}