强连通分量Tarjan

最新推荐文章于 2022-05-18 19:18:44 发布
最新推荐文章于 2022-05-18 19:18:44 发布
阅读量151 收藏 1
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/REfusing/article/details/89684282
版权

参考博客：浅析强连通分量（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;
}

 

Re:fused
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Tarjan算法-求强连通分量入门
keepcoral的博客
06-27 1032
Tarjan算法求强连通分量，强连通分量就是有向图(可以是子图)中的任意两点都能互相到达，所以我们可以用Tarjan算法去求出所有的强连通分量，相当于缩点，然后把这些缩点连接起来，就是DAG(有向无环图)，DAG一定有一个点是出度为0的，可以尝试画画图。#include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;cstring&gt...
tarjan求强连通分量
Link_Ray的博客
11-23 475
强连通分量定义 在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。 tarjan求强连通分量 定义以下几个变量 dfn: 时间变量，代表给结点第几个被访问。 Dfn[u]: 结...
Tarjan求有向图的强连通分量（Tarjan算法描述）
Bright
07-12 4895
强连通分量是有向图中的概念，我们先说强连通分量的定义吧：在一个图的子图中，任意两个点相互可达，也就是存在互通的路径，那么这个子图就是强连通分量（或者称为强连通分支）。如果一个有向图的任意两个点相互可达，那么这个图就称为强连通图。        我们常用的求强连通分量的算法有两个，
强连通分量——tarjan
ecjtu_17_TY的博客
09-13 505
学自：https://blog.csdn.net/qq_34374664/article/details/77488976 强连通：在一个有向图里面，如果有两个点a和b满足a和b之间互通，则称（a，b）强连通 强连通图：一幅图中所有点之间都满足强连通，则可以称这是一幅强连通图，（无向图必是强连通图） 强连通分量：强连通图的一幅子图如果满足子图的所有点之间都是强连通，则称这幅子图为这幅强连通图...
tarjan强连通分量
weixin_50522312的博客
04-11 109
文章目录tarjan强连通分量 tarjan强连通分量 连通：无向图中，任意点i可以到任意点j 强连通：有向图中，任意点i可以到任意点j
Tarjan 的强连通分量算法的Python实现
06-08
）图作为输入，并以拓扑顺序返回其强连通分量作为输出 循环依赖 在各种情况下，依赖关系可能是循环的，并且必须同时执行一组相互依赖的操作。同时执行成本高昂的情况并不少见。使用 Tarjan 算法，可以确定执行相互...
HDU-1269（Tarjan模板-求强连通分量）
01-03
Tarjan求有向图的强连通分量， */ #include #include #include #include #include using namespace std; const int MAXN = 1e5 + 10; struct Edge{ int to, next, dis; }edge[MAXN << 1];
Tarjan算法求强连通分量
02-03
使用Tarjan算法进行快速计算强连通分量，C++语言实现。
求有向图的强连通分量(scc)Tarjan算法.docx
05-06
"有向图的强连通分量（scc）Tarjan算法" Tarjan算法是基于深度优先搜索的算法，用于求解有向图的强连通分量（scc）。强连通分量是指图中每两个顶点之间至少存在一条路径的子图。Tarjan算法的主要思想是通过深度...
强连通分量的Tarjan算法
weixin_45552088的博客
10-13 195
有向图的强连通分量（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 559
tarjan算法求强连通分量数量 一、概念： 1、强连通： 在一个有向图G里，设两个点a b发现，由a有一条路可以走到b，由b又有一条路可以走到a，我们就叫这两个顶点（a，b）强连通。 2、强连通图： 如果在一个有向图G中，每两个点都强连通，我们就叫这个图为强连通图。 3、强连通分量： 在一个有向图G中，有一个子图，这个子图每2个点都满足强连通，我们就叫这个子图叫做强连通分量 举个栗子： 在上图...
强连通分量Tarjan算法
Bule-Zst的博客
07-24 365
有向图的强连通分量：Tarjan算法
ACM教程 - 强连通分量（Tarjan）
牧码的博客
10-28 1104
一、讲解一 强连通定义：在有向图G&lt;V,E&gt;中，对于点集V'∈V, 点集中的任意两点都可达，则称V'为强连通。 孤立的一个点也是一个强连通分量。 在嵌套的多个环时 : {所有环上的点}为一个强连通分量( 最小环就是每个孤立点）注意一定是满足条件的最大点集。 则上图中强连通分量有 {1}，{2}，{3}，{7}，{4,5,6}。 tarjan的过程就是dfs过程： 对图......
图论——强连通分量（Tarjan算法)
热门推荐
上总介的博客
03-10 3万+
一周前写的Tarjan代码遗失了QAQ，趁还没忘，赶紧记录一下。
Tarjan三大算法之强连通分量
fuyukai的专栏
05-07 1829
简介： 在之前的两篇博客中，我们详细介绍了Tarjan大牛发明的用来求解割点、桥和双连通分量的算法，这次我们介绍一下强连通分量。算法： 这次的Tarjan算法，可以用一次DFS把所有强连通分量找出来，依旧是用两个时间戳和栈来实现。算法的大体思路还是在深搜过程中更新时间戳，并将遍历过的结点保存在栈中，之后通过对时间戳的判断，来发现强连通分量。当我们完成对一个结点u以及其子孙的访问后，我们可以进行一
有向图的强连通分量的tarjan算法
08-27 427
此篇文章的整理仅用于学习记录，供日后复习，大部分内容来源于北大郭炜老师整理的课件。 有关tarjan算法的一个结论：求几个点的LCA等价于求dfn[]最小的节点和dfn[]最大的这两个节点的LCA. 1.POJ2186:Popular Cows 题意：给定一个有向图，求有多少顶点是由任何顶点出发都可达的。 有用的定理：有向无环图中唯一出度为0的点，一定可以有任何点出发均可达（由于无环，所以...
强连通分量——tarjan算法缩点
c__chong的博客
05-18 1363
一. 什么是强连通分量？ 强连通分量：在有向图G中，如果两个顶点u,v间（u->v）有一条从vi到vj的有向路径，同时还有一条从u到v的有向路径，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。有向图的极大强连通子图，称为强连通分量。 简单点说就是：如果一个有向图中，存在一条回路，所有的结点至少被经过一次，这样的图为强连通图。 在强连图图的基础上加入一些点和路径，使得当前的图不在强连通，称原来的强连通的部分为强连通分量。 二. 强连通分
有向图强连通分量算法实现及原理
计算有向图的强连通分量通常可以采用Kosaraju算法或Tarjan算法。Kosaraju算法的基本思想是先进行一次深度优先搜索(DFS)以确定每个节点的后继者，然后对转置图再进行一次DFS，按照首次访问节点的逆序进行，这样每次...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值