Tarjan算法是一种用于查找有向图中的强连通分量（SCC）、无向图中的割点和桥的深度优先搜索
算法。它的时间复杂度为 O(n+e)，其中 n 是顶点数，e 是边数。下面是一个基于 C++ 的
Tarjan 算法实现示例，用于查找强连通分量（SCC）[^1]。
### 强连通分量（SCC）的
Tarjan 算法实现
```cpp
#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>
using namespace std;
class Graph {
private:
int V; // 顶点数量
vector<vector<int>> adj; // 邻接表
vector<int> dfn; // 发现时间
vector<int> low; // 最早能追溯到的节点
stack<int> s; // 栈用于记录当前 SCC 的节点
vector<bool> inStack; // 节点是否在栈中
int time; // 时间戳
public:
Graph(int V) : V(V), adj(V), dfn(V, -1), low(V, -1), inStack(V, false), time(0) {}
void addEdge(int u, int v) {
adj[u].push_back(v);
}
void
tarjanSCC(int u) {
dfn[u] = low[u] = ++time;
s.push(u);
inStack[u] = true;
for (int v : adj[u]) {
if (dfn[v] == -1) { // 如果未被访问过
tarjanSCC(v);
low[u] = min(low[u], low[v]);
} else if (inStack[v]) { // 如果在栈中，说明是回边
low[u] = min(low[u], dfn[v]);
}
}
// 如果是根节点，开始弹出栈中的节点，形成 SCC
if (dfn[u] == low[u]) {
cout << "SCC: ";
while (true) {
int v = s.top();
s.pop();
inStack[v] = false;
cout << v << " ";
if (v == u) break;
}
cout << endl;
}
}
void findSCCs() {
for (int i = 0; i < V; i++) {
if (dfn[i] == -1) {
tarjanSCC(i);
}
}
}
};
int main() {
Graph g(5);
g.addEdge(0, 1);
g.addEdge(1, 2);
g.addEdge(2, 0);
g.addEdge(1, 3);
g.addEdge(3, 4);
cout << "Strongly Connected Components:" << endl;
g.findSCCs();
return 0;
}
```
### 割点的
Tarjan 算法实现
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Graph {
private:
int V; // 顶点数量
vector<vector<int>> adj; // 邻接表
vector<int> dfn; // 发现时间
vector<int> low; // 最早能追溯到的节点
vector<bool> isCut; // 是否是割点
int time; // 时间戳
public:
Graph(int V) : V(V), adj(V), dfn(V, -1), low(V, -1), isCut(V, false), time(0) {}
void addEdge(int u, int v) {
adj[u].push_back(v);
adj[v].push_back(u); // 无向图需要双向边
}
void
tarjanCutPoint(int u, int parent) {
dfn[u] = low[u] = ++time;
int children = 0; // 子节点数量
for (int v : adj[u]) {
if (v == parent) continue; // 跳过父节点
if (dfn[v] == -1) { // 如果未被访问过
children++;
tarjanCutPoint(v, u);
low[u] = min(low[u], low[v]);
// 如果 u 是根且有多个子节点，则 u 是割点
if (parent == -1 && children > 1) {
isCut[u] = true;
}
// 如果 u 不是根且 low[v] >= dfn[u]，则 u 是割点
if (parent != -1 && low[v] >= dfn[u]) {
isCut[u] = true;
}
} else { // 回边
low[u] = min(low[u], dfn[v]);
}
}
}
void findCutPoints() {
for (int i = 0; i < V; i++) {
if (dfn[i] == -1) {
tarjanCutPoint(i, -1);
}
}
cout << "Cut Points: ";
for (int i = 0; i < V; i++) {
if (isCut[i]) {
cout << i << " ";
}
}
cout << endl;
}
};
int main() {
Graph g(5);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 3);
g.addEdge(2, 3);
g.addEdge(1, 4);
cout << "Finding Cut Points:" << endl;
g.findCutPoints();
return 0;
}
```
### 桥的
Tarjan 算法实现
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Graph {
private:
int V; // 顶点数量
vector<vector<int>> adj; // 邻接表
vector<int> dfn; // 发现时间
vector<int> low; // 最早能追溯到的节点
int time; // 时间戳
public:
Graph(int V) : V(V), adj(V), dfn(V, -1), low(V, -1), time(0) {}
void addEdge(int u, int v) {
adj[u].push_back(v);
adj[v].push_back(u); // 无向图需要双向边
}
void
tarjanBridge(int u, int parent) {
dfn[u] = low[u] = ++time;
for (int v : adj[u]) {
if (v == parent) continue; // 跳过父节点
if (dfn[v] == -1) { // 如果未被访问过
tarjanBridge(v, u);
low[u] = min(low[u], low[v]);
// 如果 low[v] > dfn[u]，则 u-v 是桥
if (low[v] > dfn[u]) {
cout << "Bridge: " << u << "-" << v << endl;
}
} else { // 回边
low[u] = min(low[u], dfn[v]);
}
}
}
void findBridges() {
for (int i = 0; i < V; i++) {
if (dfn[i] == -1) {
tarjanBridge(i, -1);
}
}
}
};
int main() {
Graph g(5);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 3);
g.addEdge(2, 3);
g.addEdge(1, 4);
cout << "Finding Bridges:" << endl;
g.findBridges();
return 0;
}
```
### 总结
以上代码分别实现了
Tarjan 算法用于查找强连通分量（SCC）、割点和桥。每个
算法的核心思想都是基于深度优先搜索（DFS），通过维护 `dfn` 和 `low` 数组来判断节点之间的连接关系。这些
算法的时间复杂度为 O(n+e)，非常适合处理大规模图数据。
扫一扫
285
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
