(图论) Tarjan 算法

已于 2022-06-14 19:49:54 修改
阅读量908 收藏 9
点赞数 2
分类专栏： 算法竞赛 文章标签： 图论 算法 深度优先 dfs
于 2022-06-14 19:48:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CUBE_lotus/article/details/125284917
版权

文章目录

前言

Tarjan 算法是图论中非常著名和常用的算法之一，能解决最近公共祖先（LCA），强连通分量，割点和割边(桥)，双连通分量等问题。

Tarjan 是基于dfs搜索的算法，依据递归栈，时间戳等信息能解决多种问题。在dfs中每个点只递归一次，边也只利用一次，因此时间复杂度为 O ( n + m ) {O(n+m)} O(n+m)。

本文主要以记录模板为主，不做详细教学，需要读者有一定的dfs基础，希望读者能总结出属于自己的模板。

在求强联通分量处，给出了另一种kosaraju算法的模板。

本文并没有求双联通分量的模板，以后有机会会给出。

img

最近公共祖先 (LCA)

LCA - Lowest Common Ancestors

  • 建树的边 (双向)
  • 建查询的边 (双向)
  • dfs
    • 入 vis 遍历子节点dfs
    • 回 并查集nex存cur
    • 离 枚举查询组 借助并查集的路径压缩

视频讲解：

322 最近公共祖先 Tarjan算法_哔哩哔哩_bilibili

练习题：

洛谷：P3379 【模板】最近公共祖先（LCA）

// P3379 【模板】最近公共祖先（LCA）
#include <bits/stdc++.h>
using namespace std;

const int M = 10 + 500000;
vector<vector<int>> graph(M);             // 存图（树）
vector<vector<pair<int, int>>> query(M);  // 询问

int father[M];  // 并查集
bool vis[M];    // vis
int ans[M];     // 第几组询问的答案

void initUnionFind(int n) {
    for (int i = 0; i <= n; i++) {
        father[i] = i;
    }
}
// 必须路径压缩
int unionFind(int x) {
    return x == father[x] ? x : father[x] = unionFind(father[x]);
}
// Tarjan 算法
void Tarjan(int cur) {
    // dfs 入
    vis[cur] = true;
    for (int& nex : graph[cur]) {
        if (!vis[nex]) {
            Tarjan(nex);
            // dfs 回
            father[nex] = cur;
        }
    }

    // dfs 离开
    for (auto& it : query[cur]) {
        int &to = it.first, &idx = it.second;
        // 若访问过，则可以记录
        if (vis[to]) {
            ans[idx] = unionFind(to);
        }
    }
}

int main() {
    // 边数 询问数 根节点
    int n, m, root;
    scanf("%d %d %d", &n, &m, &root);
    initUnionFind(n);

    // 存无向图
    for (int i = 1, a, b; i <= n - 1; i++) {
        scanf("%d %d", &a, &b);
        graph[a].emplace_back(b);
        graph[b].emplace_back(a);
    }

    // 询问 也要双向存
    for (int i = 1, a, b; i <= m; i++) {
        scanf("%d %d", &a, &b);
        query[a].emplace_back(b, i);
        query[b].emplace_back(a, i);
    }

    Tarjan(root);

    for (int i = 1; i <= m; i++) {
        printf("%d\n", ans[i]);
    }

    return 0;
}

强连通分量

tarjan

视频讲解：

算法轻松掌握tarjan强连通分量_哔哩哔哩_bilibili

思想：

在递归站中的low值相等的点是一个强联通分量

dfn值和low值相等的是该分量的代表点

练习题：

杭电：迷宫城堡 - 1269

洛谷：P3387 【模板】缩点 

/**
 * https://www.luogu.com.cn/problem/P3387
 * P3387 【模板】缩点
 *
 * tarjan 求强连通分量
 * 然后缩点构造DAG图
 */
#include <bits/stdc++.h>
#define int long long
using namespace std;

// tarjan 标配
vector<vector<int>> graph;  // 存图
vector<int> dfn;            // dfs被访问的时间点
vector<int> low;            // 通过回溯可以到达的最早时间点
int timestamp = 1;          // 时间戳
// 求强连通分量 标配
vector<int> scc;     // 强联通分量
stack<int> stk;      // 递归栈
vector<bool> inStk;  // 快速辨别是都在递归栈中

void tarjan(int cur) {
    dfn[cur] = low[cur] = timestamp++;
    stk.push(cur);
    inStk[cur] = true;

    for (int& nex : graph[cur]) {
        if (dfn[nex] == 0) {
            // 未访问则搜索一次
            tarjan(nex);
            low[cur] = min(low[cur], low[nex]);
        } else if (inStk[nex]) {
            // 在栈中，也要松弛一次
            low[cur] = min(low[cur], dfn[nex]);
        }
    }

    // 自己的dfn和low相同，则构成一个强联通分量
    if (dfn[cur] == low[cur]) {
        int x = -1;
        do {
            x = stk.top();
            stk.pop();
            inStk[x] = false;
            scc[x] = cur;
        } while (x != cur);
    }
}

signed main() {
    int n, m;
    cin >> n >> m;

    graph.resize(n + 1);
    dfn.resize(n + 1);
    low.resize(n + 1);
    timestamp = 1;
    scc.resize(n + 1, -1);
    inStk.resize(n + 1);

    vector<int> val(n + 1);   // 点权
    vector<int> from(m + 1);  // 出发点
    vector<int> to(m + 1);    // 到达点

    // 点权
    for (int i = 1; i <= n; i++) {
        cin >> val[i];
    }
    // 建图，单向图
    for (int i = 1; i <= m; i++) {
        cin >> from[i] >> to[i];
        graph[from[i]].emplace_back(to[i]);
    }

    // 跑tarjan 获得强连通分量
    for (int i = 1; i <= n; i++) {
        if (dfn[i] == 0) {
            tarjan(i);
        }
    }

    /** ******** tarjan 跑完，获得强连通分量 ****************************/
    /** ******** 根据强连通分量，缩点构造DAG图 ***************************/

    // 先将每个强联通分量的点权集中到代表点上
    for (int i = 1; i <= n; i++) {
        if (scc[i] != i) {  // 代表点不用重复加
            val[scc[i]] += val[i];
        }
    }

    unordered_map<int, vector<int>> dagGraph;
    for (int i = 1; i <= m; i++) {
        int &u = from[i], &v = to[i];
        // 不在一个分量中
        if (scc[u] != scc[v]) {
            dagGraph[scc[u]].emplace_back(scc[v]);
        }
    }

    function<int(int)> dfsDag = [&](int cur) -> int {
        int sum = 0;
        for (int& nex : dagGraph[cur]) {
            // 获得子树的最大值，还可以记忆化优化下
            sum = max(sum, dfsDag(nex));
        }
        return val[cur] + sum;
    };

    int maxx = 0;
    // 遍历每个点，可能有某点的是单独的分量没有边
    for (int i = 1; i <= n; i++) {
        if (scc[i] == i) {
            maxx = max(maxx, dfsDag(scc[i]));
        }
    }

    cout << maxx << endl;

    return 0;
}

kosaraju

另一种求强连通分量的方法

  • 建立正向和反向图
  • 先dfs反向图
  • 在正向图中逆序dfs反向图的结果，并记录每个点在哪个联通分量中
/**
 * https://www.luogu.com.cn/problem/P3387
 * P3387 【模板】缩点
 *
 * kosaraju 求强连通分量
 * 然后缩点构造DAG图
 */
#include <bits/stdc++.h>
#define int long long
using namespace std;

// kosaraju 标配
vector<vector<int>> forwardGraph;  // 正向图
vector<vector<int>> reverseGraph;  // 反向图
vector<int> scc;                   // 强连通分量
vector<int> vis;                   // vis标记
stack<int> stk;                    // 反图入栈

void reverseDFS(int cur) {
    vis[cur] = true;
    for (int& nex : reverseGraph[cur]) {
        if (!vis[nex]) {
            reverseDFS(nex);
        }
    }
    // 访问的点依次入栈
    stk.push(cur);
}

void forwardDFS(int cur, int father) {
    vis[cur] = true;
    scc[cur] = father;  // 记录是哪个强连通分量
    for (int& nex : forwardGraph[cur]) {
        if (!vis[nex]) {
            forwardDFS(nex, father);
        }
    }
}

signed main() {
    int n, m;
    cin >> n >> m;

    forwardGraph.resize(n + 1);
    reverseGraph.resize(n + 1);
    scc.resize(n + 1);
    vis.resize(n + 1);

    vector<int> val(n + 1);   // 点权
    vector<int> from(m + 1);  // 出发点
    vector<int> to(m + 1);    // 到达点

    // 记录点权
    for (int i = 1; i <= n; i++) {
        cin >> val[i];
    }

    // 正向反向图同时建立
    for (int i = 1; i <= m; i++) {
        cin >> from[i] >> to[i];
        forwardGraph[from[i]].push_back(to[i]);
        reverseGraph[to[i]].push_back(from[i]);
    }

    fill(vis.begin(), vis.end(), false);
    // 反向图遍历
    for (int i = 1; i <= n; i++) {
        if (!vis[i]) {
            reverseDFS(i);
        }
    }
    fill(vis.begin(), vis.end(), false);
    // 逆序遍历反向图的结果
    // 目的是获得强连通分量scc
    while (!stk.empty()) {
        int cur = stk.top();
        stk.pop();
        if (!vis[cur]) {
            forwardDFS(cur, cur);
        }
    }

    /** ************** kosaraju 跑完，获得强连通分量 *********************/
    /** ******** 根据强连通分量，缩点构造DAG图 ***************************/

    // 先将每个强联通分量的点权集中到代表点上
    for (int i = 1; i <= n; i++) {
        if (scc[i] != i) {  // 代表点不用重复加
            val[scc[i]] += val[i];
        }
    }

    unordered_map<int, vector<int>> dagGraph;
    for (int i = 1; i <= m; i++) {
        int &u = from[i], &v = to[i];
        // 不在一个分量中
        if (scc[u] != scc[v]) {
            dagGraph[scc[u]].emplace_back(scc[v]);
        }
    }

    function<int(int)> dfsDag = [&](int cur) -> int {
        int sum = 0;
        for (int& nex : dagGraph[cur]) {
            // 获得子树的最大值，还可以记忆化优化下
            sum = max(sum, dfsDag(nex));
        }
        return val[cur] + sum;
    };

    int maxx = 0;
    // 遍历每个点，可能有某点的是单独的分量没有边
    for (int i = 1; i <= n; i++) {
        if (scc[i] == i) {
            maxx = max(maxx, dfsDag(scc[i]));
        }
    }

    cout << maxx << endl;

    return 0;
}

割点 割边

视频讲解：

算法轻松掌握tarjan割点&桥算法_哔哩哔哩_bilibili

算法轻松掌握tarjan割点&桥算法_5_code实现_哔哩哔哩_bilibili

割点：

  • cur != root && cur 有儿子 && low[nex] >= dfn[cur]
  • cur == root && cur 有儿子数量 >= 2

割边：

  • low[nex] > dfn[cur]

来自：邋遢大哥233的个人空间_哔哩哔哩_bilibili

在这里插入图片描述

割点

练习题：

洛谷：P3388 【模板】割点（割顶）

// P3388 【模板】割点（割顶）
// 写法挺多的，以后总结出自己的模板
#include <bits/stdc++.h>
using namespace std;

const int M = 10 + 2 * 10000;

vector<vector<int>> graph(M);  // 存图
int dfn[M];                    // dfs被访问的时间点
int low[M];                    // 通过回溯可以到达的最早时间点
int father[M];                 // 记录父节点
bool cut[M];                   // 是否是割点

int timestamp = 1;  // 时间戳

void tarjan(int cur) {
    dfn[cur] = low[cur] = timestamp++;
    int child = 0;

    for (auto& nex : graph[cur]) {
        if (dfn[nex] == 0) {
            // 未访问则搜索一次
            child++, father[nex] = cur;
            tarjan(nex);
            // 是根节点，并且孩子个数大于等于2
            if (-1 == father[cur] && child >= 2) {
                cut[cur] = true;
            }
            // 不是根节点，但是孩子不可以回溯的更高
            if (-1 != father[cur] && low[nex] >= dfn[cur]) {
                cut[cur] = true;
            }

            // // 是割边(桥)
            // if (low[nex] > dfn[cur]) {
            //     // 每条边只会被访问一次，直接存
            //     //
            //     子树的回溯值比当权点的时间戳大于等于，则表示不会回溯到更先的节点，则是割边
            // }

            low[cur] = min(low[cur], low[nex]);
        } else if (nex != father[cur]) {
            // 访问过，但是并不是父节点
            low[cur] = min(low[cur], dfn[nex]);
        }
    }
}

int main() {
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low));
    memset(father, -1, sizeof(father));
    memset(cut, false, sizeof(cut));

    int n, m;
    scanf("%d %d", &n, &m);

    // 无向图
    for (int i = 1, from, to; i <= m; i++) {
        scanf("%d %d", &from, &to);
        graph[from].emplace_back(to);
        graph[to].emplace_back(from);
    }

    for (int i = 0; i <= n; i++) {
        if (dfn[i] == 0) {
            tarjan(i);
        }
    }

    // 统计割点数量
    int sum = 0;
    for (int i = 1; i <= n; i++) {
        sum += cut[i];
    }
    printf("%d\n", sum);
    for (int i = 1; i <= n; i++) {
        if (cut[i]) {
            printf("%d ", i);
        }
    }

    return 0;
}

割边 (桥)

练习题：

力扣：1192. 查找集群内的「关键连接」

class Solution {
private:
    vector<vector<int>> graph;
    vector<int> dfn;  // 时间戳
    vector<int> low;  // 回溯值
    int timestamp = 1;

    vector<vector<int>> ans;

    void tarjan(int cur, int pre) {
        dfn[cur] = low[cur] = timestamp++;

        for (int& nex : graph[cur]) {
            // 因为是图，防止环
            if (nex == pre) {
                continue;
            }
            if (dfn[nex] == 0) {
                // 还未dfs过
                tarjan(nex, cur);
                // 子节点回溯不到cur之前
                // 注意没有=因为可能有环
                if (low[nex] > dfn[cur]) {
                    ans.emplace_back(vector<int>{cur, nex});
                }
                // 利用子节点的回溯值更新
                low[cur] = min(low[cur], low[nex]);
            } else {
                // 不是父节点
                low[cur] = min(low[cur], dfn[nex]);
            }
        }
    }

public:
    vector<vector<int>> criticalConnections(int n, vector<vector<int>>& connections) {
        graph.resize(n);
        dfn.resize(n);
        low.resize(n);

        // 存无向图
        for (vector<int>& arr : connections) {
            graph[arr[0]].emplace_back(arr[1]);
            graph[arr[1]].emplace_back(arr[0]);
        }

        for (int i = 0; i < n; i++) {
            if (dfn[i] == 0) {
                tarjan(i, -1);
            }
        }

        return ans;
    }
};

其他相关资料

60 分钟搞定图论中的 Tarjan 算法（一） - 知乎 (zhihu.com)

tarjan算法_百度百科 (baidu.com)

END

天赐细莲
关注
专栏目录
Tarjan算法精讲
05-07
《Tarjan算法精讲》 ...总的来说，Tarjan算法是一种实用且高效的图论算法，尤其适用于处理含有大量强连通分量的复杂有向图。理解和掌握这一算法对于解决相关问题，如网络分析、数据结构设计等，具有重要意义。
Tarjan算法详解（AcWing 1174 受欢迎的牛）
昂昂累世士的博客
07-13 3156
题目描述： 每一头牛的愿望就是变成一头最受欢迎的牛。 现在有 N 头牛，编号从 1 到 N，给你 M 对整数 (A,B)，表示牛 A 认为牛 B 受欢迎。 这种关系是具有传递性的，如果 A 认为 B 受欢迎，B 认为 C 受欢迎，那么牛 A 也认为牛 C 受欢迎。 你的任务是求出有多少头牛被除自己之外的所有牛认为是受欢迎的。 输入格式 第一行两个数 N,M； 接下来 M 行，每行两个数 A,B，意思是 A 认为 B 是受欢迎的（给出的信息有可能重复，即有可能出现多个 A,B）。 输出格式 输出被除自己之外的
Tarjan 算法（超详细！！）
最新发布
WerChange的OI博客
01-24 2662
去年还在车上背模板的算法，今年终于搞懂了
Tarjan算法详解
加油，努力，认真
05-11 6202
目录一、什么是强连通分量1. 概念2. 强连通分量二、两种dfs遍历1. 方式12. 方式2三、一个简单例子理解算法四、更完整的一个例子五、Code实现 一、什么是强连通分量 tarjan强连通分量算法 1. 概念 连通：无向图中，从任意点i可到达任一点j 强连通：有向图中，从任意点i可到达任一点j 弱连通：把有向图看作无向图时，从任意点i可到达任一点j 如图，强连通无论那个点，都能按照方向到达任意一点，弱连通如果强行按方向，那么B到不了C，A到不了B和C，C到不了B。但如果把他看作是无向图，那么他们也
Tarjan算法
qq_61768466的博客
06-02 1339
还记得无向图判连通块吗？对于无向图中，判连通块是一件很容易的事。你只需要dfs(深度优先搜索)一下就可以了。但是，如果我们把无向图换成有向图呢？这就是另一个故事了…计算机科学家，以,等算法闻名。是求强连通分量的一个强力的算法。要理解这个算法，我们先讲几个定义：神奇海螺结束！先讲一下我们要用到的数组。:第iii个节点他的时间戳:第iii个节点他最多经过一条返祖边所能到达的最小时间戳:一个栈,用来储存当前还未确定但已经扩展过的点:第iii个节点他所在的强连通分量编号我们讲一下算法流程。此时来到了点uuu扩展他的
Tarjan算法超超超详解（ACM/OI）（强连通分量/缩点）（图论）（C++）
热门推荐
qaqwqaqwq的博客
08-24 1万+
深入浅出的Tarjan算法手把手讲解！看完就会！
Tarjan 算法论文 DEPTH-FIRST SEARCH AND LINEAR GRAPH ALGORITHMS.pdf
04-10
Tarjan算法是图论领域中一个经典的算法，由美国计算机科学家罗伯特·塔扬（Robert Tarjan）提出，主要用于深度优先搜索（DFS）遍历图中的节点，并对图中的强连通分量（Strongly Connected Components，SCCs）或双...
Tarjan算法讲义
07-14
Tarjan 算法是图论中非常实用 / 常用的算法之一，能解决强连通分量，双连通分量，割点和桥，求最近公共祖先（LCA）等问题。 关于 Tarjan 算法，笔者将用一系列文章系统介绍 Tarjan 算法的原理以及其主要解决的问题...
C++Tarjan算法实现.zip
08-20
Tarjan算法，全称为Robert Tarjan的强连通分量算法，是图论中的一个经典算法，主要用于找出有向图中的强连通分量。在C++编程中，它能有效地处理复杂的图结构问题，尤其是在分析网络流、最短路径等场景下。本文将深入...
Tarjan算法 讲解
12-10
**Tarjan算法**是一种用于解决图论中**强连通分量**问题的经典算法。它由罗伯特·塔扬（Robert Tarjan）于1972年提出，并且由于其高效性，在计算机科学领域得到了广泛的应用。 **强连通分量**是指在一个有向图中，...
Tarjan算法详细讲解
木牛的博客
07-06 9624
Tarjan算法讲解的博客网上找到三篇比较好的,现在都转载了,个人只研究了第一篇,正如博主所说,讲的标比较详细,清晰,剩下两篇也可以看一下. 卿学姐视频讲解https://www.bilibili.com/video/av7330663/ 以下内容转自:http://www.cnblogs.com/uncle-lu/p/5876729.html 全网最详细tarjan算法讲解，我不敢说别的。反正其他tarjan算法讲解，我看了半天才看懂。我写的这个，读完一遍，发现原来tarjan这么简单！ ...
Tarjan算法详解（包含人工栈写法）
weixin_42137657的博客
04-28 1557
一、Tarjan算法简介 Tarjan算法是由Robert Tarjan发明的一种基于DFS的图论算法，他可以用来求解有向图的强联通 分量或者求解无向图的中的割点和桥等，可以说是图论算法中的基本算法之一。本文将以求解有向 图的强联通分量来介绍Tarjan算法。 二、有向图的强联通 有向图的两个结点可以相互到达，他们便在一个强联通分量内，如图所示： 其中{1,2,3,5}四个结点可以相互到达，...
浅谈 Tarjan 算法
William_Wang_的博客
06-07 3461
无向图中，若删去一条边会使得这个图的极大连通分量数增加，则该边被称为桥。也可以理解为无向图的一个连通块中，若删除一条边会使得至少两点之间无法相互到达，该边被称为桥。无向图中，若删去一个点会使得这个图的极大连通分量数增加，这个点被称为割点。也可以理解为无向图的一个连通块中，若删除一个点会使得至少两点之间无法相互到达，该点被称为割点。注意，强连通分量（SCC，Strongly Connected Components）是在单向图中的。强联通子图，定义为：在单向图中，该子图上的任意两点之间能互相到达。
Tarjan算法超详细讲解(割点割边强连通)
汪阿少的博客
02-06 6692
本文出自我的掘金博客, 欢迎大家访问传送门 今天我主要介绍Tarjan算法在割点割边以及强连通分量中的应用以及缩点技巧 按照老规矩, 先上两道模板题 【模板】强连通分量 【模板】割点（割顶） 割点割边 一, 离散数学中的定义: 割点: 无向连通图中，去掉一个顶点及和它相邻的所有边，图中的连通分量数增加，则该顶点称为割点。 割边: 无向联通图中，去掉一条边，图中的连通分量数增加，则这条边，称为...
Tarjan算法（详解 + 刷题）
IT OR 考公？
01-15 1169
包含 4 道 Tarjan 图论题目和AC代码（讲解）
Tarjan 算法学习笔记
m0_72410588的博客
05-10 1048
支持度（Support）是指数据集DDD中包含某个项集XXX的记录所占的比例。SuppXfreqX∣D∣SuppX∣D∣freqX​其中freqXfreq(X)freqX表示包含XXX的记录数，∣D∣|D|∣D∣表示数据集DDD中记录的总数。置信度（Confidence）是指数据集DDD中包含项集XXX的记录中同时包含另一个项集YYY的比例。
Tarjan 算法
qq_40329819的博客
11-26 660
解决问题 Tarjan 算法是图论中非常实用 / 常用的算法之一，能解决强连通分量（有向图两点互打），双连通分量（任意两点存在至少两条"边不重复"的路径的图），割点和桥，求最近公共祖先（LCA）等问题。 求强连通分量 一些定义 搜索树：以某一个节点 x 出发进行深度优先搜索，每一个节点只访问一次，所有被访问过的节点与边构成一棵树 时间戳 dfndfndfn ：标记图中每个节点在进行深度优先搜索时被访问的时间顺序 追溯值 lowlowlow ：搜索树中 dfndfndfn 最小值 有视频好理解 算法思想 处
Tarjan与2-SAT图论算法详解PPT
Tarjan算法是图论中常见的一种方法，可以用于缩点和求强连通分量。 Tarjan算法的重要性在于它可以将有向图中的强连通分量缩成一个点，从而将原图转化为一个有向无环图。这个过程可以通过DFS来实现。首先对于一个图...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值