强连通分量Tarjan

最新推荐文章于 2025-03-22 20:45:19 发布
原创 最新推荐文章于 2025-03-22 20:45:19 发布 · 192 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入解析了强连通分量的概念及其实现算法，包括Tarjan算法和Kosaraju算法，通过多个实例展示了如何使用这些算法解决实际问题，如寻找最受欢迎的牛、间谍网络分析等，同时提供了详细的代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

参考博客：浅析强连通分量（Tarjan和kosaraju）

                Tarjan·关于图的连通性 & 连通分量

题目：1332 上白泽慧音

代码：

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

const int maxn = 5010;
const int N =  50010;
stack<int>s;
int n, m, idx = 0, k = 1, Bcnt = 0;
int head[N];
int ins[maxn];
int dfn[maxn], low[maxn];
int belong[maxn];
set<int>g[maxn];
set<int>::iterator it;
int ans = 0;
struct edge
{
    int v, next;
} e[N];
void add(int u, int v)
{
    e[k].v = v;
    e[k].next = head[u];
    head[u] = k++;
}
void tarjan(int u)
{
    int v;
    dfn[u] = low[u] = ++idx;
    ins[u] = 1;
    s.push(u);
    for(int i = head[u]; i != -1; i = e[i].next)
    {
        v = e[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(ins[v])low[u] = min(low[u], dfn[v]);
    }
    if(dfn[u] == low[u])
    {
        Bcnt++;
        do
        {
            v = s.top();
            s.pop();
            ins[v] = 0;
            g[Bcnt].insert(v);
        }
        while(u != v);
        int  f = g[Bcnt].size();
        ans = max(f, ans);
    }
}
void init()
{
    idx = 0, k = 1, Bcnt = 0, ans = 0;
    memset(ins, 0, sizeof(ins));
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0,sizeof(low));
    memset(head, -1, sizeof(head));
}
int main()
{
    int T, p, u, v, choose;
    init();
    scanf("%d %d", &n, &p);
    for(int i = 1; i <= p; i++)
    {
        scanf("%d %d %d", &u, &v, &choose);
        add(u, v);
        if(choose == 2)add(v, u);
    }
    for(int i= 1; i <= n; i++)if(!dfn[i])tarjan(i);
    int mi = INT_MAX, pos = 0;
    cout<<ans<<endl;
    for(int i = 1; i <= Bcnt; i++)
    {
        if(g[i].size() == ans)
        {
            int first_num = *(g[i].begin());
            if(mi > first_num)
            {
                pos = i;
                mi = first_num;
            }
        }
    }
    int t = 0;
    for(it = g[pos].begin(); it != g[pos].end(); it++)
    {
        if(t != 0)cout<<" ";
        printf("%d", *it);
        t++;
    }
    cout<<endl;
    return 0;
}

题目：Popular Cows    POJ - 2186 

题意：就是有N头牛，给你M中关系，问你有多少头牛受欢迎，当一个牛被除了自己本身的所有牛喜欢那么这头牛就是最受欢迎的牛。

题解：本题采用Tarjan+缩点，把强连通分量看成一个点，统计出度为0的点有多少个，如果出度为0的点为一个的话，那么则这个点（可能是强连通分量缩的点）就是最受欢的，输出这个点包含多少头牛。如果出度为0的点有两个以上，那么就不存在最受欢迎的牛。

代码：

#include<stdio.h>
#include<iostream>
#include<stack>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn = 10010;
const int N = 50010;
stack<int>s;
int n, m, idx = 0, k = 1, Bcnt = 0;
int head[N];
int ins[maxn];
int dfn[maxn], low[maxn];
int belong[maxn];
int num[maxn];
int degree[maxn];

struct edge
{
    int v, next;
} e[N];
void add(int u, int v)
{
    e[k].v = v;
    e[k].next = head[u];
    head[u] = k++;
}
void tarjan(int u)
{
    int v;
    dfn[u] = low[u] = ++idx;
    ins[u] = 1;
    s.push(u);
    for(int i = head[u]; i != -1; i = e[i].next)
    {
        v = e[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(ins[v])low[u] = min(low[u], dfn[v]);
    }
    if(dfn[u] == low[u])
    {
        Bcnt++;
        do
        {
            v = s.top();
            s.pop();
            ins[v] = 0;
            belong[v] = Bcnt;
            num[Bcnt]++;

        }
        while(u != v);
    }
}
void init()
{
    idx = 0, k = 1, Bcnt = 0;
    memset(ins, 0, sizeof(ins));
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0,sizeof(low));
    memset(head, -1, sizeof(head));
    memset(num, 0, sizeof(num));
    memset(belong , 0, sizeof(belong));
    memset(degree, 0, sizeof(degree));
}
int main()
{
    int T, p, u, v, choose;
    init();
    scanf("%d %d", &n, &p);
    for(int i = 1; i <= p; i++)
    {
        scanf("%d %d", &u, &v);
        add(u, v);
    }
    for(int i= 1; i <= n; i++)if(!dfn[i])tarjan(i);
    for(int i = 1; i <= n; i++){
        for(int j = head[i]; j != -1; j = e[j].next){
            int v = e[j].v;
            if(belong[i] != belong[v]){
                degree[belong[i]]++;
            }
        }
    }
    int flag = 0, pos = 0;
    for(int i = 1; i <= Bcnt; i++){
        if(degree[i] == 0){
                flag++;
                pos = i;
        }
    }
    if(flag > 1)printf("0\n");
    else printf("%d\n", num[pos]);
    return 0;
}

题目：P2863 [USACO06JAN]牛的舞会The Cow Prom

代码：

#include<stdio.h>
#include<iostream>
#include<stack>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn = 10010;
const int N = 50010;
stack<int>s;
int n, m, idx = 0, k = 1, Bcnt = 0;
int head[N];
int ins[maxn];
int dfn[maxn], low[maxn];
int belong[maxn];
int num[maxn];

struct edge
{
    int v, next;
} e[N];
void add(int u, int v)
{
    e[k].v = v;
    e[k].next = head[u];
    head[u] = k++;
}
void tarjan(int u)
{
    int v;
    dfn[u] = low[u] = ++idx;
    ins[u] = 1;
    s.push(u);
    for(int i = head[u]; i != -1; i = e[i].next)
    {
        v = e[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(ins[v])low[u] = min(low[u], dfn[v]);
    }
    if(dfn[u] == low[u])
    {
        Bcnt++;
        do
        {
            v = s.top();
            s.pop();
            ins[v] = 0;
            belong[v] = Bcnt;
            num[Bcnt]++;

        }
        while(u != v);
    }
}
void init()
{
    idx = 0, k = 1, Bcnt = 0;
    memset(ins, 0, sizeof(ins));
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0,sizeof(low));
    memset(head, -1, sizeof(head));
    memset(num, 0, sizeof(num));
    memset(belong, 0, sizeof(belong));
}
int main()
{
    int T, p, u, v, choose;
    init();
    scanf("%d %d", &n, &p);
    for(int i = 1; i <= p; i++)
    {
        scanf("%d %d", &u, &v);
        add(u, v);
    }
    for(int i= 1; i <= n; i++)if(!dfn[i])tarjan(i);
    int ans = 0;
    for(int i = 1; i <= Bcnt; i++)
    {
        if(num[i] > 1)ans++;
    }
    printf("%d\n", ans);
    return 0;
}

缩点：

题目：P3387 【模板】缩点

代码：

#include<stdio.h>
#include<iostream>
#include<stack>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn = 10010;
const int N = 500100;
stack<int>s;
int n, m, idx = 0, k = 1, Bcnt = 0, cn = 0, ans;
int head[N], head1[N];
int ins[maxn];
int dfn[maxn], low[maxn];
int belong[maxn], point[maxn], w[maxn], degree[maxn];
int dis[maxn];

struct edge
{
    int v, next;
} e[N];
struct edge_
{
    int v, next;
} e_[N];
void add(int u, int v)
{
    e[k].v = v;
    e[k].next = head[u];
    head[u] = k++;
}
void add_(int u, int v)
{
    e_[cn].v = v;
    e_[cn].next = head1[u];
    head1[u] = cn++;
}
void tarjan(int u)//强连通分量
{
    int v;
    dfn[u] = low[u] = ++idx;
    ins[u] = 1;
    s.push(u);
    for(int i = head[u]; i != -1; i = e[i].next)
    {
        v = e[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(ins[v])low[u] = min(low[u], dfn[v]);
    }
    if(dfn[u] == low[u])
    {
        Bcnt++;
        do
        {
            v = s.top();
            s.pop();
            ins[v] = 0;
            belong[v] = Bcnt;
        }
        while(u != v);
    }
}
void init()
{
    idx = 0, k = 1, Bcnt = 0, cn = 1, ans = -1;
    memset(head1, -1,sizeof(head1));
    memset(head, -1, sizeof(head));

}
void TopSort()//拓扑排序
{
     queue<int>q;
     for(int i = 1; i <= Bcnt; i++){
        if(!degree[i])q.push(i);
        dis[i] = w[i];
     }
     while(!q.empty()){
        int x = q.front();
        q.pop();
        for(int i = head1[x]; i != -1; i = e_[i].next){
            int v = e_[i].v;
            dis[v] = max(dis[v], dis[x]+w[v]);
            degree[v]--;
            if(degree[v] == 0)q.push(v);
        }
     }
     for(int i = 1; i <= Bcnt; i++){
        ans = max(ans, dis[i]);
     }


}
int main()
{
    int T, p, u, v, choose;
    init();
    scanf("%d %d", &n, &p);
    for(int i = 1; i <= n; i++)
    {
        scanf("%d", &point[i]);
    }
    for(int i = 1; i <= p; i++)
    {
        scanf("%d %d", &u, &v);
        add(u, v);
    }
    for(int i= 1; i <= n; i++)if(!dfn[i])tarjan(i);
    for(int i = 1; i <= n; i++)
    {
        int v;
        for(int j = head[i]; j != -1; j = e[j].next)
        {
            v = e[j].v;
            if(belong[i] != belong[v])//缩点
            {
                add_(belong[i], belong[v]);
                degree[belong[v]]++;
            }
        }
        w[belong[i]] += point[i];
    }
    TopSort();
    printf("%d\n", ans);
    return 0;
}

题目：P1262 间谍网络

思路：本题的思路就是，如果当这个人不能被贿赂并且这个人跟其他人没有关系，那么就是NO。剩下的就是利用缩点，把环缩成一个点，那么这个点的最小值就是整个点的价值。

代码：

#include<stdio.h>
#include<iostream>
#include<stack>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn = 10010;
const int N = 50010;
const int INF = 1e9+100;
stack<int>s;
int n, m, idx = 0, k = 1, Bcnt = 0;
int head[N];
int ins[maxn];
int dfn[maxn], low[maxn];
int belong[maxn];
int num[maxn];
int degree[maxn], money[maxn];

struct edge
{
    int v, next;
} e[N];
void add(int u, int v)
{
    e[k].v = v;
    e[k].next = head[u];
    head[u] = k++;
}
void tarjan(int u)
{
    int v;
    dfn[u] = low[u] = ++idx;
    ins[u] = 1;
    s.push(u);
    for(int i = head[u]; i != -1; i = e[i].next)
    {
        v = e[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(ins[v])low[u] = min(low[u], dfn[v]);
    }
    if(dfn[u] == low[u])
    {
        Bcnt++;
        do
        {
            v = s.top();
            s.pop();
            ins[v] = 0;
            belong[v] = Bcnt;
            num[Bcnt] = (num[Bcnt], money[v]);//更新环的最小值

        }
        while(u != v);
    }
}
void init()
{
    idx = 0, k = 1, Bcnt = 0;
    memset(ins, 0, sizeof(ins));
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0,sizeof(low));
    memset(head, -1, sizeof(head));
    memset(num, 0, sizeof(num));
    memset(belong, 0, sizeof(belong));
}
int main()
{
    int T, p, u, v, choose;
    init();
    scanf("%d %d", &n, &p);
    for(int i = 1; i <= n; i++)money[i] = INF;
    for(int i = 1; i <= p; i++)
    {
        int pos, val;
        scanf("%d %d", &pos, &val);
        money[pos] = val;
    }
    int m;
    scanf("%d", &m);
    for(int i = 1; i <= m; i++)
    {
        scanf("%d %d", &u, &v);
        add(u, v);
    }
    for(int i= 1; i <= n; i++)if(!dfn[i] && money[i] != INF)tarjan(i);
    for(int i = 1; i <= n; i++)
    {
        if(!dfn[i]) //如果这个人没有被贿赂，或者跟其他人没有关系
        {
            printf("NO\n");
            printf("%d\n", i);
            return 0;
        }
    }
    int ans = 0;
    for(int i = 1; i <= n; i++)
    {
        for(int j = head[i]; j != -1; j = e[j].next)
        {
            int v = e[j].v;
            if(belong[i] != belong[v])
            {
                degree[belong[v]]++;
            }
        }
    }
    for(int i = 1; i <= Bcnt; i++)
    {
        if(!degree[i]) //利用缩点，找到入度为0的点，
        {
            ans += num[i];
        }
    }
    printf("YES\n");
    printf("%d\n", ans);
    return 0;
}

割点:

题目：P3388 【模板】割点（割顶）

代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 20010;
const int N = 200100;
int head[N];
int dfn[maxn], low[maxn], k = 0, tot = 0, root, cut[maxn];
struct Node
{
    int v, next;
} e[N];
void add(int u, int v)
{
    e[k].v = v;
    e[k].next = head[u];
    head[u] = k++;
}
void Tarjan(int x)
{
    dfn[x] = low[x] = ++tot;
    int flag = 0;
    for(int i = head[x]; i != -1; i = e[i].next)
    {
        int y = e[i].v;
        if(!dfn[y])
        {
            Tarjan(y);
            low[x] = min(low[x], low[y]);
            if(dfn[x] <= low[y] && (x != root || ++flag > 1))cut[x] = 1;
        }
        else low[x] = min(low[x], dfn[y]);
    }
}
int main()
{
    memset(head, -1, sizeof(head));
    int n, m, a, b;
    scanf("%d %d", &n, &m);
    for(int i = 1; i <= m; i++)
    {
        scanf("%d %d", &a, &b);
        add(a, b);
        add(b, a);
    }
    for(int i = 1; i <= n; i++)
    {
        if(!dfn[i])root = i, Tarjan(i);
    }
    int cn = 0;
    for(int i = 1; i <= n; i++)
    {
        if(cut[i])cn++;
    }
    printf("%d\n", cn);
    for(int i =  1; i <= n; i++)
    {
        if(cut[i])printf("%d ", i);
    }
    printf("\n");
}

题目：Network of Schools    POJ - 1236 

思路：第一问就是问你最少给多少人发信息，所以利用缩点，然后寻找入度为0的点就是第一问的答案。第二问，最少增加多少条边，这个图示强联通图，所以就是缩点之后，找到入度和初度为0的最大值。

代码：

#include<stdio.h>
#include<iostream>
#include<stack>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn = 10010;
const int N = 500100;
stack<int>s;
int n, m, idx = 0, k = 1, Bcnt = 0, cn = 0, ans;
int head[N], head1[N];
int ins[maxn];
int dfn[maxn], low[maxn];
int belong[maxn], in[maxn], out[maxn];

struct edge
{
    int v, next;
} e[N];
struct edge_
{
    int v, next;
} e_[N];
void add(int u, int v)
{
    e[k].v = v;
    e[k].next = head[u];
    head[u] = k++;
}
void add_(int u, int v)
{
    e_[cn].v = v;
    e_[cn].next = head1[u];
    head1[u] = cn++;
}
void tarjan(int u)//强连通分量
{
    int v;
    dfn[u] = low[u] = ++idx;
    ins[u] = 1;
    s.push(u);
    for(int i = head[u]; i != -1; i = e[i].next)
    {
        v = e[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(ins[v])low[u] = min(low[u], dfn[v]);
    }
    if(dfn[u] == low[u])
    {
        Bcnt++;
        do
        {
            v = s.top();
            s.pop();
            ins[v] = 0;
            belong[v] = Bcnt;
        }
        while(u != v);
    }
}
void init()
{
    idx = 0, k = 1, Bcnt = 0, cn = 1, ans = -1;
    memset(head1, -1,sizeof(head1));
    memset(head, -1, sizeof(head));

}

int main()
{
    int T, p, u, v, choose;
    init();
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
    {
        int v;
        while(scanf("%d", &v) && v != 0)
        {
            add(i, v);
        }
    }
    for(int i= 1; i <= n; i++)if(!dfn[i])tarjan(i);
    for(int i = 1; i <= n; i++)
    {
        int v;
        for(int j = head[i]; j != -1; j = e[j].next)
        {
            v = e[j].v;
            if(belong[i] != belong[v])//缩点
            {
                add_(belong[i], belong[v]);
                in[belong[v]]++;
                out[belong[i]]++;
            }
        }
    }
    int ans1 = 0, ans2 = 0;
    for(int i = 1; i <= Bcnt; i++)
    {
        if(!in[i])ans1++;
        if(!out[i])ans2++;
    }
    printf("%d\n", ans1);
    if(Bcnt ==  1)
    {
        printf("0\n");
        return 0;
    }


    ans = max(ans1, ans2);
    printf("%d\n", ans);
    return 0;
}

 

tarjan求强连通分量
Link_Ray的博客
11-23 545
强连通分量定义 在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。 tarjan求强连通分量 定义以下几个变量 dfn: 时间变量，代表给结点第几个被访问。 Dfn[u]: 结...
图论：tarjan 算法求解强连通分量
PengFly123的博客
02-17 1045
有一个 nnn 个点，mmm 条边的有向图，请求出这个图点数大于 111 的强连通分量个数。第一行为两个整数 nnn 和 mmm。第二行至 m+1m+1m+1 行，每一行有两个整数 aaa 和 bbb，表示有一条从 aaa 到 bbb 的有向边。仅一行，表示点数大于 111 的强连通分量个数。 提示 数据规模与约定 对于全部的测试点，保证 2≤n≤1042\le n \le 10^42≤n≤104，2≤m≤5×1042\le m\le 5\times 10^42≤m≤5×104，1≤a,b≤n1 \leq
Tarjan求有向图的强连通分量（Tarjan算法描述）
Bright
07-12 4991
强连通分量是有向图中的概念，我们先说强连通分量的定义吧：在一个图的子图中，任意两个点相互可达，也就是存在互通的路径，那么这个子图就是强连通分量（或者称为强连通分支）。如果一个有向图的任意两个点相互可达，那么这个图就称为强连通图。        我们常用的求强连通分量的算法有两个，
强连通分量——tarjan
ecjtu_17_TY的博客
09-13 567
学自：https://blog.youkuaiyun.com/qq_34374664/article/details/77488976 强连通：在一个有向图里面，如果有两个点a和b满足a和b之间互通，则称（a，b）强连通 强连通图：一幅图中所有点之间都满足强连通，则可以称这是一幅强连通图，（无向图必是强连通图） 强连通分量：强连通图的一幅子图如果满足子图的所有点之间都是强连通，则称这幅子图为这幅强连通图...
tarjan强连通分量
weixin_50522312的博客
04-11 169
文章目录tarjan强连通分量 tarjan强连通分量 连通：无向图中，任意点i可以到任意点j 强连通：有向图中，任意点i可以到任意点j
强连通分量（tarjan算法）
WQhuanm的博客
01-08 3553
强连通：两个点u，v可以互相到达强连通分量，一个图中每一块的任意点可以互相到达的数量（不一定整个图强连通，但是局部强连通）
04.强连通分量Tarjan算法.md
最新发布
04-07
### 强连通分量Tarjan算法知识点详解 强连通分量Tarjan算法是一种用于在有向图中寻找强连通分量的高效算法。所谓强连通分量，是指在有向图中，任意两个节点互相可达的最大子图。在算法中，我们关注的是节点的访问...
【图论】Tarjan算法（强连通分量）
muyangquan0013的博客
08-21 1643
Tarjan算法是一种由美国计算机科学家罗伯特·塔杨（Robert Tarjan）提出的求解有向图强连通分量的线性时间的算法。
强连通分量 Tarjan
Cass-ette的博客
12-03 449
强连通分量 Tarjan 前言 其实很早就会用Tarjan打强连通了，但还是有些一知半解，也忘性大，现在总结一下。 强连通分量的定义 假设我们现在有这个图： 很显然这三个点两两之间可以到达，那么我们就称这个图是强连通的。 假设我们多加一个节点 之前的子图强连通，但不是强联通分量，因为它不是最大的强连通子图，而{1,2，3,4}是强连通分量。一个图可能有多个强连通分量，但我们找强连通一定要找尽可...
算法提高模板强连通分量tarjan算法
2301_80882026的博客
09-12 722
【代码】算法提高模板强连通分量tarjan算法。
强连通分量的Tarjan算法
weixin_45552088的博客
10-13 267
有向图的强连通分量（SCC）算法 强联通分量定义 给定有向图G(V,E)G(V,E)G(V,E)； 若u,v∈Vu,v\in Vu,v∈V,我们定义函数J[u][v]J[u][v]J[u][v],若uuu可以到达vvv，则有J[u][v]=1J[u][v]=1J[u][v]=1，否则J[u][v]=0J[u][v]=0J[u][v]=0； 对于非空点集Ci⊂VC_i\subset VCi​⊂V,且∀u,v∈Ci,J[u][v]=J[v][u]=1\forall u,v\in C_i,J[u][v]=J[v]
强联通分量——tarjan算法
luogu_bling的博客
10-15 961
tarjan算法求强连通分量数量 一、概念： 1、强连通： 在一个有向图G里，设两个点a b发现，由a有一条路可以走到b，由b又有一条路可以走到a，我们就叫这两个顶点（a，b）强连通。 2、强连通图： 如果在一个有向图G中，每两个点都强连通，我们就叫这个图为强连通图。 3、强连通分量： 在一个有向图G中，有一个子图，这个子图每2个点都满足强连通，我们就叫这个子图叫做强连通分量 举个栗子： 在上图...
强连通分量Tarjan算法
不导翁的博客
03-14 150
参考大佬的分析： 全网最!详!细!Tarjan算法讲解 https://blog.youkuaiyun.com/hurmishine/article/details/75248876
ACM教程 - 强连通分量（Tarjan）
10-28 1206
一、讲解一 强连通定义：在有向图G&lt;V,E&gt;中，对于点集V'∈V, 点集中的任意两点都可达，则称V'为强连通。 孤立的一个点也是一个强连通分量。 在嵌套的多个环时 : {所有环上的点}为一个强连通分量( 最小环就是每个孤立点）注意一定是满足条件的最大点集。 则上图中强连通分量有 {1}，{2}，{3}，{7}，{4,5,6}。 tarjan的过程就是dfs过程： 对图......
图论——强连通分量（Tarjan算法)
热门推荐
上总介的博客
03-10 4万+
一周前写的Tarjan代码遗失了QAQ，趁还没忘，赶紧记录一下。
Tarjan三大算法之强连通分量
fuyukai的专栏
05-07 1934
简介： 在之前的两篇博客中，我们详细介绍了Tarjan大牛发明的用来求解割点、桥和双连通分量的算法，这次我们介绍一下强连通分量。算法： 这次的Tarjan算法，可以用一次DFS把所有强连通分量找出来，依旧是用两个时间戳和栈来实现。算法的大体思路还是在深搜过程中更新时间戳，并将遍历过的结点保存在栈中，之后通过对时间戳的判断，来发现强连通分量。当我们完成对一个结点u以及其子孙的访问后，我们可以进行一
图论学习笔记（6）：Tarjan算法（强连通分量/缩点）
m0_74707185的博客
03-22 2287
Tarjan算法是一种求解有向图中强连通分量的经典算法，其核心思想是基于深度优先搜索，来求有向图的强连通分量的算法。变量名变量类型变量作用g[1010]用于构造图，存每个顶点对应得边ststack<int>用于在深度优先搜索得时候存访问的节点b[1010]bool状态数组，用于判断对于顶点是否入栈tempint时间戳，用于给顶点分配次序号dfn[1010]int节点被搜索的次序号数组，用于记录节点是第几个被深度优先搜索访问的low[1010]int。
初探Tarjan算法（求强连通分量）
huangdanning的博客（.cpp）
08-23 5772
膜你抄（QWQ） “tarjan陪伴强联通分量 生成树完成后思路才闪光 欧拉跑过的七桥古塘 让你 心驰神往”----《膜你抄》 Tarjan是一种求强连通分量、双连通分量的常用算法，其拓展例如求缩点、割点、割桥以及2-SAT等都是非常实用的（tarjan orz） 所以大概写这篇博客的目的就是加以介绍一下这个算法，至于2-SAT什么的……咳咳，你说什么？我没听见┓( ´∀` )┏ 如果没...
C++强连通分量Tarjan算法
03-04
<think>好的，我现在需要给用户介绍C++中的Tarjan强连通分量算法。首先，我得回忆一下Tarjan算法的基本概念和步骤，确保自己理解正确。 Tarjan算法是由Robert Tarjan提出的，用于寻找有向图中的强连通分量（SCC）。强连通分量指的是图中最大的子图，其中任意两个顶点都可以互相到达。这个算法使用深度优先搜索（DFS）来遍历图，并通过维护一个栈和一些辅助数组来跟踪节点的访问状态。 接下来，我应该分步骤详细说明算法的实现过程。首先，每个节点都有一个索引（index）和低链接值（lowlink）。索引表示节点被访问的顺序，低链接值是该节点能回溯到的最早访问的节点的索引。当某个节点的低链接值等于其索引时，说明找到了一个强连通分量，需要将栈中的节点弹出，直到当前节点为止，这些节点组成一个SCC。 然后，我需要考虑如何在C++中实现这个算法。通常会用邻接表来表示图结构，使用栈来保存当前路径上的节点，以及两个数组来存储索引和低链接值。还需要一个布尔数组来记录节点是否在栈中，以避免重复处理。 可能会遇到的问题包括如何初始化这些数组，如何处理未访问的节点，以及在DFS过程中如何更新低链接值。例如，当访问一个已经在栈中的节点时，需要比较当前节点的低链接值和目标节点的索引，取较小值来更新当前的低链接值。 此外，需要注意递归DFS的实现细节，比如递归终止条件，以及何时将节点弹出栈并记录SCC。代码示例需要清晰，变量命名要合理，确保用户能够理解每一步的作用。 最后，我应该测试一下这个算法，比如使用一个简单的有向图来验证输出是否正确。例如，对于包含四个节点的图，边为0→1，1→2，2→0，1→3，算法应该输出两个SCC：{0,1,2}和{3}。 在编写代码示例时，要注意注释和格式，帮助用户理解关键步骤。同时，要提醒用户关于时间复杂度的部分，Tarjan算法的时间复杂度是O(V+E)，适合处理较大的图结构。 总结下来，我需要结构清晰地介绍算法原理、步骤，并提供可运行的C++代码示例，确保用户能够理解并实现该算法。同时，要检查是否有遗漏的关键点，比如栈的使用和低链接值的更新逻辑，确保解释准确无误。</think>以下是关于Tarjan强连通分量算法的逐步说明和C++实现： **算法核心思想** 1. 通过DFS遍历图时维护一个栈 2. 使用两个关键数组： - $index[]$ 记录访问顺序 - $lowLink[]$ 记录能回溯到的最早节点 3. 当$lowLink[u] == index[u]$时，栈顶到当前节点的元素构成一个SCC **算法步骤** 1. 初始化全局计数器和标记数组 2. 对未访问的节点进行DFS 3. 每次DFS时： - 设置当前节点的index和lowLink - 将节点压入栈并标记在栈中 4. 遍历邻接节点： - 如果未访问，递归访问并更新lowLink - 如果已在栈中，更新lowLink值 5. 发现根节点时弹出栈中元素构成SCC **C++实现代码** ```cpp #include <vector> #include <stack> #include <algorithm> using namespace std; vector<vector<int>> sccTarjan(vector<vector<int>>& graph) { int n = graph.size(), index = 0; vector<int> indexMap(n, -1), lowLink(n, -1); vector<bool> onStack(n, false); stack<int> st; vector<vector<int>> scc; auto dfs = [&](auto self, int u) -> void { indexMap[u] = lowLink[u] = index++; st.push(u); onStack[u] = true; for(int v : graph[u]) { if(indexMap[v] == -1) { // 未访问 self(self, v); lowLink[u] = min(lowLink[u], lowLink[v]); } else if(onStack[v]) { // 已在栈中 lowLink[u] = min(lowLink[u], indexMap[v]); } } if(lowLink[u] == indexMap[u]) { // 发现SCC vector<int> component; while(true) { int v = st.top(); st.pop(); onStack[v] = false; component.push_back(v); if(v == u) break; } scc.push_back(component); } }; for(int i = 0; i < n; ++i) { if(indexMap[i] == -1) { dfs(dfs, i); } } return scc; } ``` **算法特征** - 时间复杂度：$O(V + E)$（线性时间） - 空间复杂度：$O(V)$（栈和辅助数组） - 特点：单次DFS即可找出所有SCC **使用示例** ```cpp // 构造图：0→1→2→0，1→3 vector<vector<int>> graph = { {1}, // 0 {2,3}, // 1 {0}, // 2 {} // 3 }; auto components = sccTarjan(graph); // 输出结果：[[3], [0,1,2]] ``` **应用场景** 1. 编译器中的代码优化 2. 电子电路分析 3. 社交网络社群发现 4. 代码依赖分析 5. 强连通性检测 关键理解点：$lowLink[u]$的更新策略既包含前向边的更新（递归返回时），也包含横向边的更新（遇到栈中节点时），这保证了能正确识别环路结构。当某个节点的lowLink等于其index值时，说明找到了环路的根节点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值