《算法竞赛进阶指南》tarjan做法 银河

银河中的恒星浩如烟海，但是我们只关注那些最亮的恒星。

我们用一个正整数来表示恒星的亮度，数值越大则恒星就越亮，恒星的亮度最暗是 1。

现在对于 N 颗我们关注的恒星，有 M 对亮度之间的相对关系已经判明。

你的任务就是求出这 N 颗恒星的亮度值总和至少有多大。

输入格式

第一行给出两个整数 N 和 M。

之后 M 行，每行三个整数 T,A,B，表示一对恒星 (A,B) 之间的亮度关系。恒星的编号从 1 开始。

如果 T=1，说明 A 和 B 亮度相等。
如果 T=2，说明 A 的亮度小于 B 的亮度。
如果 T=3，说明 A 的亮度不小于 B 的亮度。
如果 T=4，说明 A 的亮度大于 B 的亮度。
如果 T=5，说明 A 的亮度不大于 B 的亮度。

输出格式

输出一个整数表示结果。

若无解，则输出 −1−1。

数据范围

N≤100000,M≤10000

输入样例：

5 7 
1 1 2 
2 3 2 
4 4 1 
3 4 5 
5 4 5 
2 3 5 
4 5 1 

输出样例：

11

这里也可以用差分约束的做法：

(15条消息) 《图论：差分约束算法详解 + 算法证明》+ 模板题：糖果_wsh1931的博客-CSDN博客 这两个题目是一样的连数据都是一样的，但上面用的是差分约束的做法

我们重点将一下tarjan算法：

若不懂tarjan算法的可以看看这篇博客：(15条消息) 有向图强连通分量tarjan算法详解（适合新手） + 模板题：《信息学奥赛一本通》 , USACO , HAOI2006 受欢迎的牛_wsh1931的博客-CSDN博客

1：首先建边和差分约束是一样的：

t == 1, a >= b, b >= a

t == 2, b >= a + 1;

t == 3, a >= b

t == 4, a >= b + 1

t == 5, b >= a;

if (t == 1)
{
    add(h, a, b, 0);
    add(h, b, a, 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 if (t == 5) add(h, a, b, 0);

在建立一个超级源点，这个点的特性是可以遍历到所有的其他点，又因为亮度最小为一，所以我们从0 -> i 建立一条长度为1的点

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

2：利用tarjan算法缩点

因为每个联通分量的每个点都可以相互到达，所以若是一个联通分量的权值大于1则说明他是一个正环，即代表无解的情况

3：最后建图，利用联通分量递减的顺序是拓扑图的性质计算出最大值.

以上说的名词和性质在tarjan算法模板里面都有证明。

#include 
#include 
#include 
#include 

using namespace std;

typedef long long LL;

const int N = 100010, M = 600010;//首先题目输入可能都是双向边则有2 * N，建立超级源点N，
                                 //要新建一个图3 * N所以共6 * N个点
int n, m;
int id[N];
int dist[N];
stack stk;
bool in_stk[N];
int Size[N], scc_cnt;
int dfn[N], low[N], timestamp;
int h[N], hs[N], e[M], ne[M],w[M], idx;

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

void tarjan(int u)//tarjan算法模板,若不懂tarjan的同学可以看：https://blog.csdn.net/qq_61935738/article/details/126738405
{
    dfn[u] = low[u] = ++ timestamp;
    stk.push(u), in_stk[u] = true;
    
    for (int i = h[u]; i != -1; 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])
    {
        int y;
        scc_cnt ++ ;
        
        do
        {
            y = stk.top();
            stk.pop();
            in_stk[y] = false;
            id[y] = scc_cnt;
            Size[scc_cnt] ++ ;
        } while (y != u);
    }
}

int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    memset(hs, -1, sizeof hs);
    
    while (m -- )//读入每种情况
    {
        int t, a, b;
        scanf("%d %d %d", &t, &a, &b);
        if (t == 1)
        {
            add(h, a, b, 0);
            add(h, b, a, 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 if (t == 5) add(h, a, b, 0);
    }
    
    for (int i = 1; i <= n; i ++ ) add(h, 0, i, 1);//建立超级源点
    
    tarjan(0);//因为0可以遍历到所有点，所以从0开始
    
    bool success = true;
    for (int i = 0; i <= n; i ++ )//缩点之后建图
    {
        for (int j = h[i]; j != -1; j = ne[j])
        {
            int k = e[j];
            int a = id[i], b = id[k];
            
            if (a == b)//若他们在一个联通块中
            {
                if (w[j] > 0)//因为亮度最小为1，若一个联通块中存在权值大于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 != -1; 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] * Size[i];//将每个连通块中的点到起点0的权值全部加起来即为答案
        
        cout << res << endl;
    }
    
    return 0;
        
}