Tarjan SCC

最新推荐文章于 2023-07-25 13:49:24 发布
最新推荐文章于 2023-07-25 13:49:24 发布
阅读量553 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangche0526/article/details/55058681
版权

Tarjan SCC

模板

以下部分内容转载自http://kmplayer.iteye.com/blog/604532

  1. 在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected component)。
  2. 下图中，子图{1,2,3,4}为一个强连通分量，因为顶点1,2,3,4两两可达。{5},{6}也分别是两个强连通分量。
  3. Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。搜索时，把当前搜索树中未处理的节点加入一个堆栈，回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。
    1
    定义几个关键数组:
    int DFN[MAX]; //记录节点u第一次被访问时的步数
    int LOW[MAX]; //记录与节点u和u的子树节点中最早的步数
    接下来是对算法流程的演示。
    从节点1开始DFS，把遍历到的节点加入栈中。搜索到节点u=6时，DFN[6]=LOW[6]，找到了一个强连通分量。退栈到u=v为止，{6}为一个强连通分量。
    2
    返回节点5，发现DFN[5]=LOW[5]，退栈后{5}为一个强连通分量。
    3
    返回节点3，继续搜索到节点4，把4加入堆栈。发现节点4向节点1有后向边，节点1还在栈中，所以LOW[4]=1。节点6已经出栈，(4,6)是横叉边，返回3，(3,4)为树枝边，所以LOW[3]=LOW[4]=1。
    4
    继续回到节点1，最后访问节点2。访问边(2,4)，4还在栈中，所以LOW[2]=DFN[4]=5。返回1后，发现DFN[1]=LOW[1]，把栈中节点全部取出，组成一个连通分量{1,3,4,2}。
    5
    至此，算法结束。经过该算法，求出了图中全部的三个强连通分量{1,3,4,2},{5},{6}。
  4. 分析：
    运行Tarjan算法的过程中，每个顶点都被访问了一次，且只进出了一次堆栈，每条边也只被访问了一次，所以该算法的时间复杂度为 O(N+M) 。
  5. 代码：
struct E{int from,to,next;} e[MAXM+1];int ecnt,G[MAXN+1];
void addEdge(int u,int v){e[++ecnt]=(E){u,v,G[u]};G[u]=ecnt;}

int gcnt,belong[MAXN+1];//缩成的点数，这个点属于所点后的那个点

stack<int> st;bool inSt[MAXN+1];
int dfn[MAXN+1],low[MAXN+1];int vcnt;
void tarjan(int u)
{
    int i;
    dfn[u]=low[u]=++vcnt;
    st.push(u);inSt[u]=true;
    for(i=G[u];i;i=e[i].next)
    {
        int v=e[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else 
            if(inSt[v])
                low[u]=min(low[u],dfn[v]);
    }
    if(dfn[u]==low[u])
    {
        ++gcnt;
        do
        {
            u=st.top();st.pop();
            inSt[u]=false;
            belong[u]=gcnt;
        }
        while(dfn[u]!=low[u]);
    }
}

缩点

缩点有两种方式：

  1. 假缩点：由于题目较为简单，缩点后不会访问图，可以只用统计入度出度的方式逻辑缩点，而不在物理上建图 例1 例2
  2. 真缩点：由于缩点之后还需要进行复杂的操作（如树上动规），重新建一个缩过点的图 例3

例题

例1.USACO5.3 Network_of_Schools

Tarjan的简单应用

由于所点后续操作十分简单，我们没必要再费内存建另一张缩过点后的图，只需统计缩过后的每一个点的入度与出度。

由于所有入度为零的学校必须得到真传才可以，故A问题的答案即为所有入度为零的点；对于B问题，不仅需要入度为零的点得到真传，还要保证所有点都能肩负起传给其他所有学校的历史重任，即所有点的出度都不能为零。

事实上，只要上述一个条件满足，则另一个条件一定满足（因为只要一个条件满足，那么这张缩过点的图也变成一张连通图了）。故B问题的答案即为入度为零的点数和出度为零的点数两者的最大值。

有一点需要注意，如果最后缩成一个点，需要进行特殊处理。

/*
ID:zhangch33
Task:schlnet
LANG:C++
*/
#include<iostream>
#include<cstdio>
#include<stack>
#define max(a,b) (a>b?a:b)
#define min(a,b) (a<b?a:b)
using namespace std;

const int MAXN=100,MAXM=10000;

int N;

struct E{int from,to,next;} e[MAXM+1];int ecnt,G[MAXN+1];
void addEdge(int u,int v){e[++ecnt]=(E){u,v,G[u]};G[u]=ecnt;}

int gcnt,belong[MAXN+1];//缩成的点数，这个点属于所点后的那个点

stack<int> st;bool inSt[MAXN+1];
int dfn[MAXN+1],low[MAXN+1];int vcnt;
void tarjan(int u)
{
    int i;
    dfn[u]=low[u]=++vcnt;
    st.push(u);inSt[u]=true;
    for(i=G[u];i;i=e[i].next)
    {
        int v=e[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else 
            if(inSt[v])
                low[u]=min(low[u],dfn[v]);
    }
    if(dfn[u]==low[u])
    {
        ++gcnt;
        do
        {
            u=st.top();st.pop();
            inSt[u]=false;
            belong[u]=gcnt;
        }
        while(dfn[u]!=low[u]);
    }
}

int inDgr[MAXN+1],outDgr[MAXN+1];

int main()
{
    freopen("schlnet.in","r",stdin);
    freopen("schlnet.out","w",stdout);
    int i;
    scanf("%d",&N);
    for(i=1;i<=N;i++)
    {
        int u=i,v;
        scanf("%d",&v);
        while(v)
        {
            addEdge(u,v);
            scanf("%d",&v);
        }
    }
    for(i=1;i<=N;i++)
        if(!dfn[i]) tarjan(i);
    for(i=1;i<=ecnt;i++)
        if(belong[e[i].from]!=belong[e[i].to])
        {
            ++inDgr[belong[e[i].to]];
            ++outDgr[belong[e[i].from]];
        }
    int ansA=0,ansB=0;
    for(i=1;i<=gcnt;i++)
    {
        if(inDgr[i]) ++ansA;
        if(outDgr[i]) ++ansB;
    }
    ansB=max(ansA,ansB);
    if(gcnt==1) printf("1\n0\n");
    else printf("%d\n%d\n",ansA,ansB);
    return 0;
}
例2.HAOI2006 受欢迎的牛

这道题更水了，不过因为是本省省选真题，还是说一下：

很明显首先需要缩点，所完点后每一个强联通分量里的牛形成一个命运共同体，也就是说只要缩完后的点是受欢迎的，那么这里边所有的牛都是，我们想到要存一下每一个命运共同体里的牛的数量。

接下来，我们注意到当且仅当缩完后的点中有且只有一个点的出度为一时，这个点中的牛是受欢迎的（如果有两个这样的点，那么整张图就不存在受欢迎的牛），而答案就是这个点中牛的数目。

代码依然不长，在省选中实为送分题

#include<iostream>
#include<cstdio>
#include<stack>
using namespace std;

const int MAXN=1000,MAXM=5000;

int N,M;

struct E{int from,to,next;} e[MAXM+1];int ecnt,G[MAXN+1];
void addEdge(int u,int v){e[++ecnt]=(E){u,v,G[u]};G[u]=ecnt;}

stack<int> st;
bool inSt[MAXN+1];
int belong[MAXN+1],gcnt,memNum[MAXN+1];

int dfn[MAXN+1],low[MAXN+1];
int vcnt;
void tarjan(int u)
{
    int i;
    dfn[u]=low[u]=++vcnt;
    st.push(u);inST[u]=true;
    for(i=G[u];i;i=e[i].next)
    {
        int v=e[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else 
            if(inst[v])
                low[u]=min(low[u],dfn[v]);
    }
    if(dfn[u]==low[u])
    {
        ++gcnt;
        do
        {
            u=st.top();st.pop();
            inSt[u]=false;
            belong[u]=gcnt;
            ++memNum[gcnt];
        }while(low[u]!=dfn[u]);
    }
}

int outDgr[MAXN+1];

int main()
{
    int i;
    scanf("%d%d",&N,&M);
    for(i=1;i<=m;i++)
    {
            int u,v;
            scanf("%d%d",&u,&v);
            addEdge(u,v);
    }
    for(i=1;i<=N;i++)
            if(!dfn[i]) tarjan(i);
    for(i=1;i<=M;i++)
            if(belong[e[i].from]!=belong[e[i].to])
                    ++outDgr[e[i].to];
    int ans;
    bool exist=false;
    for(i=1;i<=gcnt;i++)
            if(!outDgr[i])
                    if(exist)
                    {
                            exist=false;
                            break;
                    }else exist=true,ans=i;
    if(exist) printf("%d\n",memNum[ans]);
    else printf("0\n");
    return 0;
}
例3.HAOI2010 软件安装

这道题难道是传说中的依赖背包？我也不清楚。不过很明显的是一定要先用tarjan缩点，然后再跑树上背包。这里有一个技巧，为了成功地跑树上背包，我们将一个超级源点连接到所有入度为零的点，把森林建成一棵树，这样答案就在源点上了。

#include<iostream>
#include<cstdio>
#include<stack>
using namespace std;

const int MAXN=100,MAXE=10000,MAXM=500;

int M,N;

struct E{int from,to,next;};
struct CFS//Chain Forward Star
{
    E e[MAXE+1];
    int ecnt,G[MAXN+1];
    void addEdge(int u,int v){e[++ecnt]=(E){u,v,G[u]};G[u]=ecnt;}
} G1,G2;

int weight[MAXN+1],value[MAXN+1];

stack<int> st;bool inSt[MAXN+1];
int dfn[MAXN+1],low[MAXN+1],times;
int belong[MAXN+1];
struct S{int w,v;} scc[MAXN+1];int scnt;
void tarjan(int u)
{
    int i;
    dfn[u]=low[u]=++times;
    inSt[u]=true;
    for(i=G1.G[i];i;i=G1.e[i].next)
    {
        int v=G1.e[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }else
            if(inSt[v])
                low[u]=min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u])
    {
        ++scnt;
        do
        {
            u=st.top();st.pop();
            inSt[u]=false;
            belong[u]=scnt;
            scc[scnt]={weight[u],value[u]};
        }
        while(low[u]!=dfn[u]);
    }
}

bool inDgr[MAXN+1];

inline void rebuild()
{
    int i;
    for(i=1;i<=G1.ecnt;i++)
        if(belong[G1.e[i].from]!=belong[G1.e[i].to])
        {
            G2.addEdge(belongG1.e[i].from],belong[G1.e[i].to]);
            inDgr[belong[G1.e[i].to]]=true;
        }
}

int dp[MAXN+1][MAXM+1];

void dfs(int u)
{
    int i,j,k;
    //dfs过程
    for(i=G2.G[u];i;i=G2.e[i].next)
    {
        dfs(G2.e[i].to);
        for(j=M-scc[u].w;j>=0;j--)
            for(k=0;k<=j;k++)
                dp[u][j]=max(dp[u][j],dp[u][k]+dp[G2.e[i].to][j-k]);
    }
    //更新本节点的值
    for(i=M;i>=0;i--)
        if(i>=scc[u].w)
            dp[u][i]=dp[u][j-scc[u].w]+scc[u].v;
        else dp[u][i]=0;
    //
}

int main()
{
    int i;
    scanf("%d%d",&N,&M);
    for(i=1;i<=N;i++)
        scanf("%d",&weight[i]);
    for(i=1;i<=N;i++)
        scanf("%d",&value[i]);
    for(i=1;i<=N;i++)
    {
        int u=i,v;
        scanf("%d",&v);
        while(v)
        {
            G1.addEdge(u,v);
            scanf("%d",&v);
        }
    }
    for(i=1;i<=n;i++)
        if(!dfn[i]) tarjan(i);
    rebuild();
    //
    for(i=1;i<=scnt;i++)
        if(!inDgr[i])
        {
            inDgr[i]=true;
            G2.addEdge(0,i);
        }
    dfs(0);
    printf("%d\n",dp[0][M]);
    return 0;
}
zhangche0526
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Tarjan算法附图详解（SCC）
蓝羽飞鸟的博客
05-19 1246
Tarjan算法用于有向图，用于找强连通区域，割边等，属于图论内容。 它的思路类似于DFS + Union Find， 下面来详细介绍： 图和详细视频参考链接 首先任意选一点作为起点做DFS，DFS的过程中要给各node标上id 然后每个node有一个low link value, 简单解释这是表示当前node能到达的node中最小的id（包括它自己的id) 比如node1，它能到达的node中最小id是0 node2 和 3能到达的最小id是2，同理4，5 好了，现在概念清楚了， 我们可以看到有相同l
SCC-Tarjan算法，强连通分量算法，从dfs到Tarjan详解
最新发布
EQUINOX1的博客
12-17 1216
如何一步步从dfs到tarjan算法？
有向图的强连通分量（SCC）与无向图割点的一些细节，Tarjan
wanglianda2007的博客
02-06 149
一些细节
有向图的强联通分量-SCC-Tarjan算法
重生之我是cxk的博客
07-25 291
强连通分量（Strongly Connected Components，SCC）的定义是：极大的强连通子图。下图中，子图{1,2,3,4}为一个强连通分量，因为顶点1,2,3,4两两可达。{5},{6}也分别是两个强连通分量。
专题清理之scc-tarjan缩点
AndrewLi的博客
05-26 518
题目 loj #10091 luogu P2341 [HAOI2006]受欢迎的牛 loj #10092 luogu P2272 [ZJOI2007]最大半连通子图 luogu P2746 #10093. [USACO5.3]校园网Network of Schools/网络协议 loj #10094. 「一本通 3.5 练习 2」消息的传递 loj #10095 P1262 间谍网络 ...
求有向图的强连通分量(scc)Tarjan算法.docx
05-06
"有向图的强连通分量（scc）Tarjan算法" Tarjan算法是基于深度优先搜索的算法，用于求解有向图的强连通分量（scc）。强连通分量是指图中每两个顶点之间至少存在一条路径的子图。Tarjan算法的主要思想是通过深度...
tarjan(e):Tarjan 的强连通分量算法-matlab开发
05-30
实现用于查找有向图的强连通分量的 Tarjan 算法。 在强连通分量 (SCC) 中，每个节点到每个其他节点都有一条路径。 SCC 是不相交的。 入度或出度为零或属于无环图的节点自己形成 SCC。 接受邻接矩阵作为输入。 为了...
有向图缩点：tarjan强连通缩点(模板)
01-20
SCC强连通缩点：(用之前记得init) const int N=1e4+100; const int M=1e5+100; struct Egde { int to,next; }edge1[M],edge2[M]; int head1[N],head2[N],low[N],dfn[N],c[N],Stack[N],num,cnt,cnt2,cnt1,dcc,n,m,...
Jadecy:Java库，用于计算（编码）deps，SCC和周期（Johnson算法）。-开源
04-25
它使用Tarjan算法进行SCC计算，并使用Johnson算法进行穷举循环计算，并使用连续而不是递归的方式进行处理，从而可以处理大图（<2 ^ 31个顶点）。 从1.1版开始，还可以计算出覆盖SCC所有边缘的最短周期。 也可以...
Editorials:算法题解＆教程
03-19
题解＆教程 不定期更新，有想让我写的算法或翻译请开问题。 请star以示支持，谢谢。 写作计划 Tarjan SCC / BCC AC自动机 背包全集 红黑树 后缀自动机 后缀曲面 快速傅立叶变换 图匹配 最小圆覆盖
Tarjan算法求强连通分量
02-03
使用Tarjan算法进行快速计算强连通分量，C++语言实现。
Dijkstra最短路径C++源码
04-05
Dijkstra最短路径C++源码，用矩阵表示图
tarjan算法求SCC，e-DCC，v-DCC
messywind的博客
06-30 560
在介绍算法之前先引入几个概念： 时间戳： 在深度优先搜索时，每个点xxx第一次被访问的顺序为时间戳，记作dfn[x]dfn[x]dfn[x]（从111开始） 追溯值： 从xxx开始走，所能遍历到的最小时间戳，记作low[x]low[x]low[x] 1.tarjan1.\text {tarjan}1.tarjan求SCC\text{SCC}SCC 给定一张有向图GGG，∀u,v\forall u,v∀u,v，即存在从uuu到vvv的路径又存在从vvv到uuu的路径，那么该图GGG是强连通图。 强连通分量(S
tarjan强连通分量SCC学习笔记
J
01-29 156
tarjan强连通分量SCC学习笔记变量释义核心流程典型应用 变量释义 tarjantarjantarjan算法的两个核心数组：dfndfndfn数组和lowlowlow数组。 dfn数组：节点在dfsdfsdfs树上的序号（相当于一个时间戳的作用）。 low数组：节点在dfsdfsdfs树上的子树（不完全是子树，要扣掉已经分配到强连通分量的点）中，所能返回的点的dfndfndfn的最小值（相当于找强连通分量的根）。 lowlowlow数组比较难懂，可以意会一下，强连通分量的关键是互相可达，dfsdfsdf
tarjan算法
热门推荐
施工中请绕行
02-19 2万+
      说到以Tarjan命名的算法，我们经常提到的有3个，其中就包括本文所介绍的求强连通分量的Tarjan算法。而提出此算法的普林斯顿大学的Robert E Tarjan教授也是1986年的图灵奖获得者（具体原因请看本博“历届图灵奖得主”一文）。      首先明确几个概念。强连通图。在一个强连通图中，任意两个点都通过一定路径互相连通。比如图一是一个强连通图，而图二不是。因为没有一条路使得点4到达点1、2或3。强连通分量。在一个非强连通图中极大的强连通子图就是该图的强连通分量。比如图三中子图{1,2,
20行代码实现，使用Tarjan算法求解强连通分量
TechFlow的博客
09-23 297
今天是算法数据结构专题的第36篇文章，我们一起来继续聊聊强连通分量分解的算法。 在上一篇文章当中我们分享了强连通分量分解的一个经典算法Kosaraju算法，它的核心原理是通过将图翻转，以及两次递归来实现。今天介绍的算法名叫Tarjan，同样是一个很奇怪的名字，奇怪就对了，这也是以人名命名的。和Kosaraju算法比起来，它除了名字更好记之外，另外一个优点是它只需要一次递归，虽然算法的复杂度是一样的，但是常数要小一些。它的知名度也更高，在竞赛当中经常出现。 先给大家提个醒，相比于Kosaraju算法，Tarj
1/13 关于SCC/Tarjan/Kosaraju
ugly_g的博客
01-13 228
总结一下，Kosaraju算法的主要是起始时间和终止时间设置，而Tarjan算法是dfn和low的设置，两个用的都是DFS算法，查找Graph中的强连通分量数目。
scc强连通分量——tarjan算法
Erin_jwx的博客
07-21 233
强连通分量：强连通子图（一个图可能不是强连通的，但它的子图可能是强连通的，这些子图被称为强连通分量） 代码参考 改写了一下，加了点注解 对于算法的理解，指路->【持续更新】算法学习—参考博客 #include<iostream> #include<cstdio> #include<algorithm> #include<stack> using namespace std; const int V = 8; int dfn[V]; //记录某一顶点被访问
Tarjan算法小结1——SCC
LPA的博客
11-06 754
Tarjan算法之强连通分量个数及成员个数(SCC)
tarjan算法代码
10-13
Tarjan算法是一种基于深度优先搜索的强连通分量算法，可以用于解决图论中的许多问题。以下是Tarjan算法的代码...`find_scc`函数是整个算法的入口，它遍历所有节点，对于未被访问过的节点，调用`tarjan`函数进行搜索。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值