更好的阅读体验

前言

凡事都得靠自己 --bobo

  • 催隔壁 @K8He n 天了让他写 \(Tarjan\) 的学习笔记，但貌似还没有动静，所以决定自己写一个。

正文

  • 本文配套题单：14.图论-tarjan（强连通分量、割点、割边）

    前置知识

    • 熟练使用链式前向星
    • 在一张连通图中，所有的节点以及发生递归的边共同构成一棵搜索树。如果这张图不连通，则构成搜索森林。
    • 如图(从学校课件上扒下来的图)
      • \({\color{green}树边}\)： \(DFS\) 时经过的点，即 \(DFS\) 搜索树上的边。
      • \({\color{yellow}返祖边}\)：也叫回边，与 \(DFS\) 方向相反，从某个节点指向其某个祖先的边。
      • \({\color{red}横叉边}\): 从某个节点指向搜索树中另一子树终端某节点的边，它主要是在搜索的时候遇到了一个已经访问过的节点，但是这个节点并不是当前节点的祖先时形成的。
        • 无向图不存在横叉边。
      • \({\color{blue}前向边}\): 指向子树中节点的边，父节点指向子孙节点。
        • PS：前向边无用，因为通过树边就能直接到达这个点。
      • 返祖边与树边必定构成环，横叉边可能与树边构成环。
    • 时间戳、追溯值
      • 时间戳 \(dfn\) :用来标记某个节点在进 \(DFS\) 时被访问的时间顺序（由小到大）。
      • 追溯值 \(low\) :用来表示从当前节点 \(x\) 作为搜索树的根节点出发，能够访问到的所有节点中，时间戳 (\(dfn\))最小的值。
      • 当 \(dfn[x]==low[x]\) 时，以 \(x\) 为根的搜索子树中所有节点是一个强连通（从栈顶到 \(x\) 的所有节点）分量。
      • \(low[x]\) 的计算方法
        • 如果 \(x->y\) 是树边（没有被访问过），那么 \(low[x]=min(low[x],low[y])\) 。
        • 如果 \(x->y\) 是返祖边（访问过，且在栈中），那么 \(low[x]=min(low[x],dfn[y])\) 。
        • 如果 \(x->y\) 是横叉边（不在栈中），那么什么都不做。 
          1. for(i=head[x];i!=0;i=e[i].next)
          2. {
          3.     if(dfn[e[i].to]==0)
          4.     {
          5.         tarjan(e[i].to);
          6.         low[x]=min(low[x],low[e[i].to]);
          7.     }
          8.     else
          9.     {
          10.         if(ins[e[i].to]==1)//ins[x]表示x是否在栈内
          11.         {
          12.             low[x]=min(low[x],dfn[e[i].to]);
          13.         }
          14.     }
          15. }
    • 时间复杂度 \(\Theta(N+M)\)
      • 运行 \(Tarjan\) 算法的过程中，每个节点都被访问了一次，且只进出了一次栈，每条边也只被访问了一次，故时间复杂度为 \(\Theta(N+M)\) 。

    Tarjan 与有向图

    强连通分量（Strongly Connected Components，SCC）

    • 强连通(strongly connected):在一个有向图 \(G\) 里，设有两个点 \(a,b\) ,由 \(a\) 有一条路可以走到 \(b\) ,由 \(b\) 又有一条路可以走到 \(a\) ，则称这两个顶点 \((a,b)\) 强连通。
    • 强连通图：如果在一个有向图 \(G\) 里，每两个点都强连通，则称 \(G\) 是一个强连通图。
    • 强连通分量：非强连通图有向图的极大强连通子图，称为强连通分量（Strongly Connected Components，SCC）。
    • 如果节点 \(x\) 是某个强连通分量在搜索树中遇到的第一个节点，那么这个强连通分量的其余节点肯定在搜索树中以 \(x\) 为根的子树中，节点 \(x\) 被称为这个强连通分量的根。
    • 例题

      • luogu B3609 [图论与代数结构 701] 强连通分量

        1. #include<bits/stdc++.h>
        2. using namespace std;
        3. #define ll long long
        4. #define endl '\n'
        5. struct node
        6. {
        7.     int next,to;
        8. }e[100001];
        9. vector<int>scc[100001];
        10. stack<int>s;
        11. int head[100001],dfn[100001],low[100001],ins[100001],vis[100001],c[100001],cnt=0,tot=0,ans=0;
        12. void add(int u,int v)
        13. {
        14.     cnt++;
        15.     e[cnt].next=head[u];
        16.     e[cnt].to=v;
        17.     head[u]=cnt;
        18. }
        19. void tarjan(int x)
        20. {
        21.     int i,k=0;
        22.     tot++;
        23.     dfn[x]=low[x]=tot;
        24.     ins[x]=1;
        25.     s.push(x);
        26.     for(i=head[x];i!=0;i=e[i].next)
        27.     {
        28.         if(dfn[e[i].to]==0)
        29.         {
        30.             tarjan(e[i].to);
        31.             low[x]=min(low[x],low[e[i].to]);
        32.         }
        33.         else
        34.         {
        35.             if(ins[e[i].to]==1)//说明e[i].to是祖先节点or左子树节点
        36.             {
        37.                 low[x]=min(low[x],dfn[e[i].to]);
        38.             }
        39.         }
        40.     }
        41.     if(dfn[x]==low[x])//如果这里构成了一个强连通分量
        42.     {
        43.         ans++;//ans是强连通分量的编号
        44.         while(x!=k)//将这个强连通分量内的点标记一下
        45.         {
        46.             k=s.top();
        47.             ins[k]=0;
        48.             c[k]=ans;//c[k]表示k属于哪个强连通分量内
        49.             scc[ans].push_back(k);
        50.             s.pop();
        51.         }
        52.     }
        53. }
        54. int main()
        55. {
        56.     int n,m,i,j,u,v;
        57.     cin>>n>>m;
        58.     for(i=1;i<=m;i++)
        59.     {
        60.         cin>>u>>v;
        61.         add(u,v);
        62.     }
        63.     for(i=1;i<=n;i++)
        64.     {
        65.         if(dfn[i]==0)
        66.         {
        67.             tarjan(i);
        68.         }
        69.     }
        70.     cout<<ans<<endl;
        71.     for(i=1;i<=n;i++)
        72.     {
        73.         if(vis[c[i]]==0)
        74.         {
        75.             vis[c[i]]=1;
        76.             sort(scc[c[i]].begin(),scc[c[i]].end());
        77.             for(j=0;j<scc[c[i]].size();j++)
        78.             {
        79.                 cout<<scc[c[i]][j]<<" ";
        80.             }
        81.             cout<<endl;
        82.         }
        83.     }
        84.     return 0;
        85. }

      • luogu P2661 [NOIP2015 提高组] 信息传递

        • 易知本题答案为最小的强连通分量大小（非 \(1\) ） 
          1. scc=0;
          2. while(x!=k)
          3. {
          4.     k=s.top();
          5.     ins[k]=0;
          6.     scc++;
          7.     s.pop();
          8. }
          9. if(scc!=1)
          10. {
          11.     maxin=min(maxin,scc);
          12. }

          \(maxin\) 即为结果

      • luogu P2863 [USACO06JAN] The Cow Prom S

        • 按照题意打就行

      • luogu P2921 [USACO08DEC] Trick or Treat on the Farm G 先跑一遍 \(Tarjan\) （这是一个有 \(n\) 个点，\(n\) 条边的图，故只有 \(1\) 个强连通分量的大小不为 \(1\) ），然后分类讨论：

        • 若节点 \(x\) 所在强连通分量的大小不为 \(1\) ，则答案为 \(x\) 所在强连通分量的大小。
        • 若节点 \(x\) 所在强连通分量的大小为 \(1\) ，则答案为节点 \(x\) 到不为1的强连通分量的距离 \(+\) 这个强连通分量的大小。
          • 至于怎么求距离，记忆化搜索是个好东西。 
            1. #include<bits/stdc++.h>
            2. using namespace std;
            3. #define ll long long
            4. #define sort stable_sort
            5. #define endl '\n'
            6. struct node
            7. {
            8.     int next,to;
            9. }e[100001];
            10. stack<int>s;
            11. int head[100001],dfn[100001],low[100001],ins[100001],scc[100001],c[100001],u[100001],v[100001],anss[100001],cnt=0,tot=0,ans=0;
            12. void add(int u,int v)
            13. {
            14.     cnt++;
            15.     e[cnt].next=head[u];
            16.     e[cnt].to=v;
            17.     head[u]=cnt;
            18. }
            19. void tarjan(int x)
            20. {
            21.     int i,k=0;
            22.     tot++;
            23.     dfn[x]=low[x]=tot;
            24.     ins[x]=1;
            25.     s.push(x);
            26.     for(i=head[x];i!=0;i=e[i].next)
            27.     {
            28.         if(dfn[e[i].to]==0)
            29.         {
            30.             tarjan(e[i].to);
            31.             low[x]=min(low[x],low[e[i].to]);
            32.         }
            33.         else
            34.         {
            35.             if(ins[e[i].to]==1)
            36.             {
            37.                 low[x]=min(low[x],dfn[e[i].to]);
            38.             }
            39.         }
            40.     }
            41.     if(dfn[x]==low[x])
            42.     {
            43.         ans++;
            44.         while(x!=k)
            45.         {
            46.             k=s.top();
            47.             ins[k]=0;
            48.             c[k]=ans;
            49.             scc[ans]++;
            50.             s.pop();
            51.         }
            52.     }
            53. }
            54. void search(int rt,int x,int sum)
            55. {
            56.     if(anss[x]==0)
            57.     {
            58.         search(rt,v[x],sum+1);
            59.     }
            60.     else
            61.     {
            62.         anss[rt]=anss[x]+sum;
            63.         return;
            64.     }
            65. }
            66. int main()
            67. {
            68.     int n,i,j,sum;
            69.     cin>>n;
            70.     for(i=1;i<=n;i++)
            71.     {
            72.         u[i]=i;
            73.         cin>>v[i];
            74.         add(u[i],v[i]);
            75.     }
            76.     for(i=1;i<=n;i++)
            77.     {
            78.         if(dfn[i]==0)
            79.         {
            80.             tarjan(i);
            81.         }
            82.     }
            83.     for(i=1;i<=n;i++)
            84.     {
            85.         if(u[i]==v[i])//给自环打个标记
            86.         {
            87.             anss[i]=1;
            88.         }
            89.         else
            90.         {
            91.             if(scc[c[u[i]]]>=2)
            92.             {
            93.                 anss[i]=scc[c[u[i]]];
            94.             }
            95.         }
            96.     }
            97.     for(i=1;i<=n;i++)
            98.     {
            99.          if(anss[i]==0)
            100.         {
            101.             search(u[i],v[i],1);
            102.         }
            103.     }
            104.     for(i=1;i<=n;i++)
            105.     {
            106.         cout<<anss[i]<<endl;
            107.     }
            108.     return 0;
            109. }

    缩点

    • 缩点：把强连通分量看作一个大点，并保留不在此强连通分量内的边，重新建图（易知此时的图是一个 DAG ,可以进行拓扑排序）。 
      1. if(dfn[x]==low[x])
      2. {
      3.     ans++;
      4.     while(x!=k)
      5.     {
      6.         k=s.top();
      7.         ins[k]=0;
      8.         c[k]=ans;
      9.         b[ans]+=a[k];//a[]为原点权，b[]为缩点后的点权
      10.         s.pop();
      11.     }
      12. }
      1. cnt=0;
      2. memset(e,0,sizeof(e));
      3. memset(head,0,sizeof(head));
      4. for(i=1;i<=m;i++)
      5. {
      6.     if(c[u[i]]!=c[v[i]])//Pursuing_OIer 教给我的神奇的建边方法（其实很好理解）
      7.     {
      8.         add(c[u[i]],c[v[i]]);
      9.     }
      10. }
    • 例题
      • luogu P5145 漂浮的鸭子 跑一遍缩点，求最大环，把边权转换为点权即可。
      • luogu P2002 消息扩散 ，luogu P2835 刻录光盘观察题意，易知结果为缩点后入度为 \(0\) 的点个数。
      • luogu P2812 校园网络【[USACO]Network of Schools加强版】 第一问显然同luogu P2002，令 \(p,q\) 分别表示缩点后入度、出度为 \(0\) 的点的个数，第二问显然是要求 \(max(p,q)\) , 只有一个 \(SCC\) 时记得特判。

        双倍经验 luogu P2746 [USACO5.3] 校园网Network of Schools UVA12167 Proving Equivalences
      • luogu P2341 [USACO03FALL / HAOI2006] 受欢迎的牛 G 观察题意，易知缩点后若有强连通分量的个数 \(>1\) ，则无解；当只有 \(1\) 个强连通分量时，这个强连通分量的大小即为所求。
      • luogu P2515 [HAOI2010] 软件安装 读完题，发现和luogu P2014 [CTSC1997] 选课 很像，只不过选课是一棵树，本题是一个图。可能本题建图有点麻烦，剩下的话，缩点后当树形 \(DP\) 做就行了。 
        1. for(i=1;i<=n;i++)
        2. {
        3.     cin>>u[i];
        4.     v[i]=i;
        5.     if(u[i]!=0)
        6.     {
        7.         add(u[i],v[i]);
        8.     }
        9. }
        11. ······
        13. cnt=0;
        14. memset(e,0,sizeof(e));
        15. memset(head,0,sizeof(head));
        16. for(i=1;i<=n;i++)
        17. {
        18.     if(c[u[i]]!=c[v[i]])
        19.     {
        20.         add(c[u[i]],c[v[i]]);
        21.         din[c[v[i]]]++;
        22.     }
        23. }
        24. for(i=1;i<=ans;i++)
        25. {
        26.     if(din[i]==0)
        27.     {
        28.         add(0,i);
        29.     }
        30. }
      • luogu P3387 【模板】缩点 缩点后跑最长路（ \(SPFA\) or 拓扑）。 
        1. int top_sort()
        2. {
        3.     queue<int>q;
        4.     int i,k,num=0;
        5.     for(i=1;i<=ans;i++)
        6.     {
        7.         if(din[i]==0)
        8.         {
        9.             q.push(i);
        10.             dis[i]=b[i];//b[]为缩点后的点权
        11.         }
        12.     }
        13.     while(q.empty()==0)
        14.     {
        15.         k=q.front();
        16.         q.pop();
        17.         for(i=head[k];i!=0;i=e[i].next)
        18.         {
        19.             dis[e[i].to]=max(dis[e[i].to],dis[k]+b[e[i].to]);
        20.             din[e[i].to]--;
        21.             if(din[e[i].to]==0)
        22.             {
        23.                 q.push(e[i].to);
        24.             }
        25.         }
        26.     }
        27.     for(i=1;i<=ans;i++)
        28.     {
        29.         num=max(num,dis[i]);
        30.     }
        31.     return num;
        32. }
      • CF999E Reachability from the Capital 读题，易知对于每个强连通分量缩点后入度为 \(0\) 的点的数量即为所求（起点所在强连通分量要特判），代码。
      • luogu P3119 [USACO15JAN] Grass Cownoisseur G 读题，每个点原点权均为1（且一个点的点权只能算一次），题目要求分别以 \(1\) 为起点和终点（建反图就行了）的最长路，果断 \(SPFA\) ，但是这个缩点后建边不太好搞…………
        • 因为分别以 \(1\) 为起点和终点（建反边就行了）的最长路会把 \(1\) 多算一次，记得减去 \(1\) 的点权。
        • 结果初始值要设为 \(b[c[1]]\) ,因为可能没有边与 \(1\) 相连，比如 两张图分别对应原图和反图。
        • 剩下的细节看代码吧。
      • luogu P2321 [HNOI2006] 潘多拉的宝盒
        • 简化题意：有 \(s\) 个咒语机，每个咒语机有 \(n\) 个元件，每个元件的出度为 \(2\) （字符串后面加 \(0\) 指向一个元件，字符串后面加 \(1\) 指向另一个元件），又有 \(m\) 个输出元。称从一个元件出发，以一个咒语机结尾而产生的字符串为一种方案。若咒语机 \(x\) 产生的所有方案包含咒语机 \(y\) 产生的所有方案，则称咒语机 \(x\) 是咒语机 \(y\) 的升级。求最长升级序列的长度。
        • 本题难在建图，但建图后 \(Tarjan\) 缩点+记忆化搜索记录最长链即可。
          • 若在搜索过程中，一个宝盒出现输出元，而另一个没有没有出现，此时一定有这两个宝盒间不存在包含关系，即不存在升级;否则建一条起点为i，终点为j的有向边。
        • 代码
        • 潘多拉（图片来源：奥奇传说）
      • CF131D Subway
        • 本题有些特殊，因为是无向图。
        • 题解 懒得搬了。

    Tarjan 与无向图

    无向图与割点（割顶）、割边（桥）

    • 在一个无向图中，不存在横叉边（因为边是双向的）。
    • 一个无向图中，可能不止存在一个割点或一条割边。
    • 割点（割顶）：在一个无向图中，若删除节点 \(x\) 以及所有与 \(x\) 相关联的边之后，图将会被分成两个或者两个以上不相连的子图，那么称 \(x\) 为这个图的割点（割顶）。
      • 判定法则：

        当遍历到一个节点 \(x\) 时，这个点为割点的情况有两种：

        • 该节点为根节点且子节点的个数 \(>1\) (易知此时对于 \(x\) 的任意一个子节点 \(y\) 都有 \(dfn[x]<low[y]\) )，则删掉这个节点 \(x\) 后必将导致子节点不连通，即该节点 \(x\) 为图的一个割点。
        • 该节点不为根节点，且存在一个子节点 \(y\) 使得 \(dfn[x]≤low[y]\)（子节点 \(y\) 可回溯到的最早节点不早于 \(x\) 点，即子节点 \(y\) 无法回到 \(x\) 的祖先节点） ,则删掉这个节点 \(x\) 后必将导致 \(x\) 的父节点与 \(x\) 的子节点不连通，即该节点 \(x\) 为图的一个割点。
          • 若不存在一个子节点 \(y\) 使得 \(dfn[x]≤low[y]\)，说明子节点 \(y\) 能绕行其他边到达比 \(x\) 更早访问的节点， \(x\) 就不是本图的割点，即环内的点割不掉。
      • 应用：如图，节点 \((0,4,5,6,7,11)\) 为割点。
      • 例题
        • luogu P3388 【模板】割点（割顶） 
          1. #include<bits/stdc++.h>
          2. using namespace std;
          3. #define ll long long
          4. #define endl '\n'
          5. struct node
          6. {
          7.     int next,to;
          8. }e[400001];
          9. int head[400001],dfn[400001],low[400001],flag[400001],cnt=0,tot=0;
          10. void add(int u,int v)
          11. {
          12.     cnt++;
          13.     e[cnt].next=head[u];
          14.     e[cnt].to=v;
          15.     head[u]=cnt;
          16. }
          17. void tarjan(int x,int fa)
          18. {
          19.     int i,k=0,son=0;//son用于存子节点个数
          20.     tot++;
          21.     dfn[x]=low[x]=tot;
          22.     for(i=head[x];i!=0;i=e[i].next)
          23.     {
          24.         if(dfn[e[i].to]==0)
          25.         {
          26.             tarjan(e[i].to,fa);
          27.             low[x]=min(low[x],low[e[i].to]);
          28.             if(low[e[i].to]>=dfn[x])
          29.             {
          30.                 son++;
          31.                 if(x!=fa||son>=2)
          32.                 {
          33.                     flag[x]=1;
          34.                 }
          35.             }
          36.         }
          37.         else
          38.         {
          39.             low[x]=min(low[x],dfn[e[i].to]);
          40.         }
          41.     }
          42. }
          43. int main()
          44. {
          45.     int n,m,i,u,v,sum=0;
          46.     cin>>n>>m;
          47.     for(i=1;i<=m;i++)
          48.     {
          49.         cin>>u>>v;
          50.         add(u,v);
          51.         add(v,u);
          52.     }
          53.     for(i=1;i<=n;i++)
          54.     {
          55.         if(dfn[i]==0)
          56.         {
          57.             tarjan(i,i);
          58.         }
          59.     }
          60.     for(i=1;i<=n;i++)
          61.     {
          62.         sum+=flag[i];
          63.     }
          64.     cout<<sum<<endl;
          65.     for(i=1;i<=n;i++)
          66.     {
          67.         if(flag[i]==1)
          68.         {
          69.             cout<<i<<" ";
          70.         }
          71.     }
          72.     return 0;
          73. }

          双倍经验（输入格式有点ex） UVA315 Network

        • luogu P3469 [POI2008] BLO-Blockade
          • 考虑分类讨论：

            • 若节点 \(x\) 不是割点，则删去所有与 \(x\) 相连的边后，只有 \(x\) 与其他 \(n-1\) 个点不连通，其他 \(n-1\) 个点之间仍然是连通的，故此时答案为 \(2(n-1)\) 。

              • PS：因为是有序点对，即 \((x,y)\) 和 \((y,x)\) 是不同的点对。
            • 若节点 \(x\) 是割点，则删去所有与 \(x\) 相连的边后，图为分成若干个连通块，求出各个连通块的大小后，两两相乘再相加即为此时答案。
              • 设在搜索树中，节点 \(x\) 的子节点集合中，有 \(t\) 个节点 \(s_{1},s_{2},s_{3},…,s_{t}\) 满足割点判定法则 \(dfn[x]≤low[s_{k}](1≤k≤t)\) 。则删去所有与 \(x\) 相连的边后，这个图至多分成 \(t+2\) 个连通块，每个连通块的节点构成情况如下：

                • \(1\) 个由节点 \(x\) 自身单独构成的连通块。
                • \(t\) 个由搜索树上以 \(s_{k}(1≤k≤t)\) 为根的子树的节点构成的连通块。
                • \(1\) 个由除了上述节点之外的所有节点构成的连通块（可以没有）。eg:搜索树上 \(x\) 父亲节点方向的所有节点。
              • 跑一遍 \(Tarjan\) 求出搜索树每个子树的大小。设 \(size[x]\) 用来表示以 \(x\) 为根的子树大小，故此时答案为 \(size[s_{1}]×(n-size[s_{1}])+size[s_{2}]×(n-size[s_{2}])+…+size[s_{t}]×(n-size[s_{t}])+1×(n-1)+(n-1- \sum\limits_{k=1}^{t} size[s_{k}] )×(1+ \sum\limits_{k=1}^{t} size[s_{k}] )\) 。
          • 剩下细节看代码吧。
          • 双倍经验 SP15577 STC10 - Blockade
    • 割边（桥）：在一个无向图中，若删除边 \(e\) 之后，图将会被分成两个不相连的子图，那么称 \(e\) 为这个图的割边（桥）。
      • 判定法则：当遍历到一个节点 \(x\) 时，与其子节点 \(y\) 的这条边 \(e\) ，使得 \(dfn[x]<low[y]\) （从 \(y\) 出发，若不经过边 \(e\) ，则无法到达 \(x\) 或 更早访问的节点）,则这条边 \(e\) 为图的一条割边。

        • 若 \(low[y]≤dfn[x]\) ,则说明 \(y\) 能通过其他的边到达 \(x\) 或 更早访问的节点，即这条边 \(e\) 不是图的一条割边。
      • 注意事项：
        • 有重边的边一定不是割边。
        • 边是无方向的，所以父亲与孩子之间节点的关系需要自己规定，防止误认为环。
        • 两个割点之间的边不一定是割边；割边的两个端点不一定是割点，但至少有一个是割点（eg：有重边）。
      • 例题
        • luogu P1656 炸铁路 读题，易知结果为图中的割边。 
          1. #include<bits/stdc++.h>
          2. using namespace std;
          3. #define ll long long
          4. #define sort stable_sort
          5. #define endl '\n'
          6. struct node
          7. {
          8.     int from,to;
          9. }e[2001];
          10. vector<int>E[2001];
          11. int dfn[2001],low[2001],flag[2001],cnt=0,tot=0;
          12. void add(int u,int v)
          13. {
          14.     cnt++;
          15.     e[cnt].from=min(u,v);
          16.     e[cnt].to=max(u,v);
          17. }
          18. void tarjan(int x,int fa)
          19. {
          20.     int i,k=0,pd=0;//pd用来记录遍历x的子节点时是否回到了fa
          21.     tot++;
          22.     dfn[x]=low[x]=tot;
          23.     for(i=0;i<E[x].size();i++)//不要写成i<=E[x].size()-1
          24.     {
          25.         if(dfn[E[x][i]]==0)
          26.         {
          27.             tarjan(E[x][i],x);
          28.             low[x]=min(low[x],low[E[x][i]]);
          29.             if(low[E[x][i]]>dfn[x])
          30.             {
          31.                 add(x,E[x][i]);
          32.             }
          33.         }
          34.         else
          35.         {
          36.             if(E[x][i]==fa&&pd==0)
          37.             {
          38.                 pd=1;
          39.             }
          40.             else//若pd==1，则将其当作计算儿子节点的方法来更新当前节点的值。
          41.             {
          42.                 low[x]=min(low[x],dfn[E[x][i]]);
          43.             }
          44.         }
          45.     }
          46. }
          47. bool cmp(node a,node b)
          48. {
          49.     if(a.from==b.from)
          50.     {
          51.         return a.to<b.to;
          52.     }
          53.     else
          54.     {
          55.         return a.from<b.from;
          56.     }
          57. }
          58. int main()
          59. {
          60.     int n,m,i,u,v;
          61.     cin>>n>>m;
          62.     for(i=1;i<=m;i++)
          63.     {
          64.         cin>>u>>v;
          65.         E[u].push_back(v);
          66.         E[v].push_back(u);
          67.     }
          68.     for(i=1;i<=n;i++)
          69.     {
          70.         if(dfn[i]==0)
          71.         {
          72.             tarjan(i,i);
          73.         }
          74.     }
          75.     sort(e+1,e+1+cnt,cmp);
          76.     for(i=1;i<=cnt;i++)
          77.     {
          78.         cout<<e[i].from<<" "<<e[i].to<<endl;
          79.     }
          80.     return 0;
          81. }

    无向图与双连通分量

    • 若一个无向连通图不存在割点，则称它为点双连通图。
    • 若一个无向连通图不存在割边，则称它为边双连通图。
    • 无向图中极大的点双连通子图叫点双连通分量（ \(v-DCC\) ）。
    • 无向图中极大的边双连通子图叫边双连通分量（ \(e-DCC\) ）。
      • eg：
    • 点双连通分量和边双连通分量统称为双连通分量。
    • 在一张连通的无向图中，对于两个点 \(x\) 和 \(y\) ，如果删去哪条边（只能删去一条）都不能使它们不连通，我们就说 \(x\) 和 \(y\) 边双连通。
    • 在一张连通的无向图中，对于两个点 \(x\) 和 \(y\) ，如果删去哪个点（只能删去一个，且不能删去 \(x\) 和 \(y\) 自己）都不能使它们不连通，我们就说 \(x\) 和 \(y\) 点双连通。

    点双连通分量

    • 点双连通分量

      • 若某个点为孤立点，则它自己单独构成一个 \(v-DCC\) 。
      • 除了孤立点之外，点双连通分量的大小至少为 \(2\) 。
      • 性质
        • 点双连通分量之间以割点连接，且两个点双连通分量之间有且只有一个割点。

          • 证明：若两个点双连通分量之间共用两个点，则删除其中任意一个点，所有点依旧连通。如图，
        • 每一个割点可任意属于多个点双连通分量，因此求点双连通分量时，可能包含重复的点。
        • 每一个割点都在至少两个点双连通分量中。
          • 证明：在一个非点双连通图中，删去割点后图会不连通，故割点至少连接着图的两部分。但是因为点双连通图中不存在割点，所以这两部分肯定不在同一个点双连通分量中。因此割点至少存在于两个点双连通分量中。
        • 只有一条边连通的两个点也是一个点双连通分量。如图
        • 除了上一条中的情况外，其他的点双连通分量都满足任意两点间都存在不少于两条点不重复路径。
        • 任意一个不是割点的点都只存在于一个点双连通分量中。
        • 点双连通不具有传递性，如图，\((1,3)\) 点双连通，\((1,7)\) 点双连通，但是 \((3,7)\) 不点双连通。
      • 应用：如图，存在( \(1,2,3\) ) , ( \(3,4\) ) , ( \(4,5,6\) ) 这三个点双连通分量。
      • 算法

        用一个栈存点，若遍历回到 \(x\) 时，发现割点判定法则 \(dfn[x]≤low[y]\) 成立，则从栈中弹出节点，直到 \(y\) 被弹出。那么，刚才弹出的节点和 \(x\) 一起构成一个 \(v-DCC\) 。
    • 缩点
      • 对每一个割点和 \(v-DCC\) 建点，然后根据从属关系连边，构成一棵树（或森林）。
    • 例题
      • luogu P8435 【模板】点双连通分量

        • 事实上在求割点的同时，同时可以顺便求出点双连通分量，维护一个栈在求割点的途中若有 \(dfn[x]>low[y]\) ,则将 \((x,y)\) 入栈；而当 \(dfn[x]≤low[y]\) 时，将栈中所有在 \((x,y)\) 之上的边全部取出，这些边所连接的点与 \(x\) 构成了一个点双连通分量，显然割点是可以属于多个点双连通分量的。
        • 每当新搜到一个节点时，将其压入栈中。
        • 当发现 \(x\) 的子节点 \(y\) 不能通过其他方式到达 \(x\) 的祖先，但可以到达 \(x\)（即 \(dfn[x]≤low[y]\) 成立） ，则弹出栈顶元素直到 \(y\) 弹出。
        • 弹出的所有元素组成的集合 \(E\) 加上 \(x\) ,则为一个点双连通分量。
        1. #include<bits/stdc++.h>
        2. using namespace std;
        3. #define ll long long
        4. #define endl '\n'
        5. struct node
        6. {
        7.     int next,to;
        8. }e[4000001];
        9. vector<int>v_dcc[4000001];
        10. stack<int>s;
        11. int head[4000001],dfn[4000001],low[4000001],cnt=0,tot=0,ans=0;
        12. void add(int u,int v)
        13. {
        14.     cnt++;
        15.     e[cnt].next=head[u];
        16.     e[cnt].to=v;
        17.     head[u]=cnt;
        18. }
        19. void tarjan(int x,int fa)
        20. {
        21.     int i,k=0;
        22.     if(x==fa&&head[x]==0)//孤立点判定
        23.     {
        24.         ans++;
        25.         v_dcc[ans].push_back(x);
        26.     }
        27.     tot++;
        28.     dfn[x]=low[x]=tot;
        29.     s.push(x);
        30.     for(i=head[x];i!=0;i=e[i].next)
        31.     {
        32.         if(dfn[e[i].to]==0)
        33.         {
        34.             tarjan(e[i].to,fa);
        35.             low[x]=min(low[x],low[e[i].to]);
        36.             if(low[e[i].to]>=dfn[x])
        37.             {
        38.                 ans++;
        39.                 v_dcc[ans].push_back(x);
        40.                 while(e[i].to!=k)//弹栈时不能弹出割点，因为割点属于多个点双连通分量
        41.                 {
        42.                     k=s.top();
        43.                     v_dcc[ans].push_back(k);
        44.                     s.pop();
        45.                 }
        46.             }
        47.         }
        48.         else
        49.         {
        50.             low[x]=min(low[x],dfn[e[i].to]);
        51.         }
        52.     }
        53. }
        54. int main()
        55. {
        56.     int n,m,i,j,u,v;
        57.     cin>>n>>m;
        58.     for(i=1;i<=m;i++)
        59.     {
        60.         cin>>u>>v;
        61.         if(u!=v)//重边会影响结果，记得特判
        62.         {
        63.             add(u,v);
        64.             add(v,u);
        65.         }
        66.     }
        67.     for(i=1;i<=n;i++)
        68.     {
        69.         if(dfn[i]==0)//注意图可能不连通
        70.         {
        71.             tarjan(i,i);
        72.         }
        73.     }
        74.     cout<<ans<<endl;
        75.     for(i=1;i<=ans;i++)
        76.     {
        77.         cout<<v_dcc[i].size()<<" ";
        78.         for(j=0;j<v_dcc[i].size();j++)
        79.         {
        80.             cout<<v_dcc[i][j]<<" ";
        81.         }
        82.         cout<<endl;
        83.     }
        84.     return 0;
        85. }
      • luogu B3610 [图论与代数结构 801] 无向图的块
        • 此题中的块即为大小不为 \(1\) 的点双连通分量，故不需要判断孤立点了。
        • 再按字典序排序一下就行。
        1. #include<bits/stdc++.h>
        2. using namespace std;
        3. #define ll long long
        4. #define endl '\n'
        5. struct node
        6. {
        7.     int next,to;
        8. }e[4000001];
        9. vector<int>v_dcc[4000001];
        10. stack<int>s;
        11. int head[4000001],dfn[4000001],low[4000001],cnt=0,tot=0,ans=0;
        12. void add(int u,int v)
        13. {
        14.     cnt++;
        15.     e[cnt].next=head[u];
        16.     e[cnt].to=v;
        17.     head[u]=cnt;
        18. }
        19. void tarjan(int x,int fa)
        20. {
        21.     int i,k=0;
        22.     tot++;
        23.     dfn[x]=low[x]=tot;
        24.     s.push(x);
        25.     for(i=head[x];i!=0;i=e[i].next)
        26.     {
        27.         if(dfn[e[i].to]==0)
        28.         {
        29.             tarjan(e[i].to,fa);
        30.             low[x]=min(low[x],low[e[i].to]);
        31.             if(low[e[i].to]>=dfn[x])
        32.             {
        33.                 ans++;
        34.                 v_dcc[ans].push_back(x);
        35.                 while(e[i].to!=k)
        36.                 {
        37.                     k=s.top();
        38.                     v_dcc[ans].push_back(k);
        39.                     s.pop();
        40.                 }
        41.             }
        42.         }
        43.         else
        44.         {
        45.         low[x]=min(low[x],dfn[e[i].to]);
        46.         }
        47.     }
        48. }
        49. bool cmp(vector<int> x,vector<int> y)
        50. {
        51.     for(int i=0;i<min(x.size(),y.size());i++)
        52.     {
        53.         if(x[i]!=y[i])
        54.         {
        55.             return x[i]<y[i];
        56.         }
        57.     }
        58.     return x.size()<y.size();
        59. }
        60. int main()
        61. {
        62.     int n,m,i,j,u,v;
        63.     cin>>n>>m;
        64.     for(i=1;i<=m;i++)
        65.     {
        66.         cin>>u>>v;
        67.         if(u!=v)
        68.         {
        69.             add(u,v);
        70.             add(v,u);
        71.         }
        72.     }
        73.     for(i=1;i<=n;i++)
        74.     {
        75.         if(dfn[i]==0)
        76.         {
        77.             tarjan(i,i);
        78.         }
        79.     }
        80.     cout<<ans<<endl;
        81.     for(i=1;i<=ans;i++)
        82.     {
        83.         sort(v_dcc[i].begin(),v_dcc[i].end());
        84.     }
        85.     sort(v_dcc+1,v_dcc+1+ans,cmp);
        86.     for(i=1;i<=ans;i++)
        87.     {
        88.         for(j=0;j<v_dcc[i].size();j++)
        89.         {
        90.             cout<<v_dcc[i][j]<<" ";
        91.         }
        92.         cout<<endl;
        93.     }
        94.     return 0;
        95. }
      • luogu P3225 [HNOI2012] 矿场搭建
        • 在求点双连通分量的时候把割点顺便求出来，令点双连通分量的大小为 \(size\) ,然后分类讨论：

          • 当一个点双连通分量中没有割点时，需要建两个救援出口，方案总数增加 \(C_{size}^2=\frac{size!}{{(size-2)}!×2!}=\frac{size(size-1)}{2}\) 。如图，\((1,2,3,4)\) 为本图的点双连通分量，且没有割点，则在 \((1,2,3,4)\) 中任选两个点作为救援出口。
          • 当一个点双连通分量中有 \(1\) 个割点时，需要建一个救援出口（不能建在割点上），方案总数增加 \(C_{size-1}^1=\frac{(size-1)!}{{(size-2)}!×1!}=size-1\) 。如图， \((1,2,6,3,5),(1,4)\) 为本图的两个点双连通分量，且 \(1\) 为本图的割点，则在 \((2,6,3,5),(4)\) 中各任选出一个点作为救援出口。
          • 当一个点双连通分量中的割点个数大于 \(1\) ，不需要建救援出口。如图，点双连通分量 \((2,5,6)\) 中有两个割点，则不需要建救援出口。
            • 证明：当割点坍塌后，可以通过另一个割点达到其他点双连通分量。
        • 剩下的看代码吧。
        • 三倍经验 SP16185 BUSINESS - Mining your own business UVA1108 Mining Your Own Business

    边双连通分量

    • 边双连通分量

      • 性质

        • 边双连通具有传递性，即若 \(x,y\) 边双连通，\(y,z\) 边双连通，则 \(y,z\) 边双连通。如图，\((1,3)\) 边双连通，\((1,7)\) 边双连通，则 \((3,7)\) 边双连通。
      • 算法
        • 跑一遍 \(Tarjan\) 求出所有割边，然后把割边去掉，无向图会分成若干个连通块，每个连通块就是一个边双连通分量。
      • 例题
        • luogu P8436 【模板】边双连通分量

          1. #include<bits/stdc++.h>
          2. using namespace std;
          3. #define ll long long
          4. #define endl '\n'
          5. struct node
          6. {
          7.     int next,to,flag;
          8. }e[4000001];
          9. vector<int>e_dcc[4000001];
          10. stack<int>s;
          11. int head[4000001],dfn[4000001],low[4000001],flag[4000001],dout[4000001],cnt=1,tot=0,ans=0;
          12. void add(int u,int v)
          13. {
          14.     cnt++;
          15.     e[cnt].next=head[u];
          16.     e[cnt].flag=0;
          17.     e[cnt].to=v;
          18.     head[u]=cnt;
          19. }
          20. void tarjan(int x,int fa)
          21. {
          22.     int i,k=0;
          23.     tot++;
          24.     dfn[x]=low[x]=tot;
          25.     s.push(x);
          26.     for(i=head[x];i!=0;i=e[i].next)
          27.     {
          28.         if(dfn[e[i].to]==0)
          29.         {
          30.             tarjan(e[i].to,i);
          31.             low[x]=min(low[x],low[e[i].to]);
          32.             if(low[e[i].to]>dfn[x])//割边判定法则
          33.             {
          34.                 e[i].flag=e[i^1].flag=1;
          35.             }
          36.         }
          37.         else
          38.         {
          39.             if((fa^1)!=i)
          40.             {
          41.                 low[x]=min(low[x],dfn[e[i].to]);
          42.             }
          43.         }
          44.     }
          45.     if(low[x]==dfn[x])//这里可以用DFS替代
          46.     {
          47.         ans++;
          48.         while(x!=k)
          49.         {
          50.             k=s.top();
          51.             s.pop();
          52.             e_dcc[ans].push_back(k);
          53.         }
          54.     }
          55. }
          56. int main()
          57. {
          58.     int n,m,i,j,u,v;
          59.     cin>>n>>m;
          60.     for(i=1;i<=m;i++)
          61.     {
          62.         cin>>u>>v;
          63.         if(u!=v)
          64.         {
          65.             add(u,v);
          66.             add(v,u);
          67.         }
          68.     }
          69.     for(i=1;i<=n;i++)
          70.     {
          71.         if(dfn[i]==0)
          72.         {
          73.             tarjan(i,0);
          74.         }
          75.     }
          76.     cout<<ans<<endl;
          77.     for(i=1;i<=ans;i++)
          78.     {
          79.         cout<<e_dcc[i].size()<<" ";
          80.         for(j=0;j<e_dcc[i].size();j++)
          81.         {
          82.             cout<<e_dcc[i][j]<<" ";
          83.         }
          84.         cout<<endl;
          85.     }
          86.     return 0;
          87. }
    • 缩点
      • 算法：把每一个边双连通分量缩成一个点使得原本的连通图变成一棵树（若原图不连通，则为树林），且树边就是原图的割边。其中满足 \(low[x]==dfn[x]\) 的节点 \(x\) ，这必定是一个边双连通分量的根。

        • 证明：在一个边双连通分量中没有割边，且节点 \(x\) 满足 \(low[x]==dfn[x]\) ，则在以 \(x\) 为根的子树内没有一个节点有连边到该节点的祖先节点，所以仍在栈中的节点一定是以 \(x\) 为根的边双连通分量。
      • 例题
        • luogu P2860 [USACO06JAN] Redundant Paths G

          • 简化题意：给定一个连通的无向图进行加边操作，使得每一对点之间都至少有两条相互分离的路径（两条路径没有一条重合的道路），即使得所有的节点都在环上（可能是不同的环），也可以理解为每个节点的入度至少为 \(2\) ,求最小的加边数。
          • 考虑跑一遍 \(e-DCC\) 的缩点，找出所有的叶子节点（即入度为 \(1\) 的节点），设其个数为 \(leaf\) ,则结果为 $\left \lceil \frac{leaf}{2} \right \rceil $ 。
            • 如图， \(1,3,4,5\) 为以 \(2\) 为根的树中的叶子节点( \(leaf=4\) )，则连接 \(1->3\) ， \(4->5\) 为满足题意的一组解( \(\left \lceil \frac{leaf}{2} \right \rceil =2\) )。
            • 如图， \(1,3,4,5,6\) 为以 \(2\) 为根的树中的叶子节点( \(leaf=5\) )，则连接 \(1->3\) ， \(4->5\) , \(3->6\) 为满足题意的一组解( \(\left \lceil \frac{leaf}{2} \right \rceil =3\) )。
          • 代码
        • CF652E Pursuit For Artifacts
          • 要求每条边最多只能经过一次，容易知道本题可能需要缩点。
          • 对于每个边双连通分量缩点，易知如果在一个边双连通分量中存在边权为 \(1\) 的边，则把缩成的这个点的点权赋值为 \(1\) ，然后从起点 \(c[a]\) 开始 \(DFS\) ，看到达终点 \(c[b]\) 时是否经过点权为 \(1\) 的点。然后注意一下每条边最多只能经过一次，开个 \(vis\) 数组判断即可。
          • 代码

参考资料：

学校的课件（不方便放出）

《算法竞赛进阶指南》———李煜东

强连通分量 | 割点和桥 |双连通分量

『学习笔记』Tarjan

强连通分量及缩点tarjan算法解析

『Tarjan算法 无向图的割点与割边』

【学习笔记】Tarjan的更多相关文章

  1. [学习笔记]tarjan求割点

    都口胡了求割边,就顺便口胡求割点好了QAQ 的定义同求有向图强连通分量. 枚举当前点的所有邻接点: 1.如果某个邻接点未被访问过,则访问,并在回溯后更新 2.如果某个邻接点已被访问过,则更新 对于当前 ...

  2. [学习笔记]tarjan求割边

    上午打模拟赛的时候想出了第三题题解,可是我不会求割边只能暴力判割边了QAQ 所以,本文介绍求割边(又称桥). 的定义同求有向图强连通分量. 枚举当前点的所有邻接点: 1.如果某个邻接点未被访问过,则访 ...

  3. [学习笔记]Tarjan&&欧拉回路

    本篇并不适合初学者阅读. SCC: 1.Tarjan缩点:x回溯前,dfn[x]==low[x]则缩点. 注意: ①sta,in[]标记. ②缩点之后连边可能有重边. 2.应用: SCC应用范围还是很 ...

  4. 学习笔记--Tarjan算法之割点与桥

    前言 图论中联通性相关问题往往会牵扯到无向图的割点与桥或是下一篇博客会讲的强连通分量,强有力的\(Tarjan\)算法能在\(O(n)\)的时间找到割点与桥 定义 若您是第一次了解\(Tarjan\) ...

  5. [学习笔记] Tarjan算法求桥和割点

    在之前的博客中我们已经介绍了如何用Tarjan算法求有向图中的强连通分量,而今天我们要谈的Tarjan求桥.割点,也是和上篇有博客有类似之处的. 关于桥和割点: 桥:在一个有向图中,如果删去一条边,而 ...

  6. [学习笔记] Tarjan算法求强连通分量

    今天,我们要探讨的就是--Tarjan算法. Tarjan算法的主要作用便是求一张无向图中的强连通分量,并且用它缩点,把原本一个杂乱无章的有向图转化为一张DAG(有向无环图),以便解决之后的问题. 首 ...

  7. $tarjan$简要学习笔记

    $QwQ$因为$gql$的$tarjan$一直很差所以一直想着要写个学习笔记,,,咕了$inf$天之后终于还是写了嘻嘻. 首先说下几个重要数组的基本定义. $dfn$太简单了不说$QwQ$ 但是因为有 ...

  8. Tarjan的学习笔记 求割边求割点

    博主图论比较弱,搜了模版也不会用... 所以决心学习下tarjan算法. 割点和割边的概念不在赘述,tarjan能在线性时间复杂度内求出割边. 重要的概念:时间戟,就是一个全局变量clock记录访问结 ...

  9. 仙人掌&圆方树学习笔记

    仙人掌&圆方树学习笔记 1.仙人掌 圆方树用来干啥? --处理仙人掌的问题. 仙人掌是啥? (图片来自于\(BZOJ1023\)) --也就是任意一条边只会出现在一个环里面. 当然,如果你的图 ...

  10. OI知识点|NOIP考点|省选考点|教程与学习笔记合集

    点亮技能树行动-- 本篇blog按照分类将网上写的OI知识点归纳了一下,然后会附上蒟蒻我的学习笔记或者是我认为写的不错的专题博客qwqwqwq(好吧,其实已经咕咕咕了...) 基础算法 贪心 枚举 分 ...

随机推荐

  1. Git | git branch 分支操作

    假设我们已经有了稳定的代码,现在我想整一些花活.比较安全的一个方式是,在新的分支上整活. 新建 vga 分支:git branch vga,然后切换到 vga 分支:git switch vga,或者 ...

  2. KVM命令行Clone虚拟机的快速处理

    KVM命令行Clone虚拟机的快速处理 背景 鲲鹏+银河麒麟的测试环境 想着可以使用 KVM的方式创建虚拟机 virt-manager 有个clone虚拟机的提示, 但是发现没有创建新存储卷下面的磁盘 ...

  3. [转帖]《Linux性能优化实战》笔记（六）—— Linux 软中断与对应故障分析方法

    中断是系统用来响应硬件设备请求的一种机制,它会打断进程的正常调度和执行,然后调用内核中的中断处理程序来响应设备的请求. 一. 为什么要有中断 举个生活中的例子,让你感受一下中断的魅力.比如说你订了一份 ...

  4. [转帖]关系模型到 Key-Value 模型的映射

    https://cn.pingcap.com/blog/tidb-internal-2 在这我们将关系模型简单理解为 Table 和 SQL 语句,那么问题变为如何在 KV 结构上保存 Table 以 ...

  5. [转帖]Shell 脚本实现应用服务日志入库 Mysql

    今天给大家分享一个 shell 脚本工具,通过 shell 脚本与 mysql 的结合,将某个具体服务的错误输出日志入库到指定的 mysql 表中,以便于进行错误问题的定位与分析. 日常工作中,经常需 ...

  6. [转帖]看看 Jmeter 是如何玩转 redis 数据库的

    柠檬小欧 2021-08-31 20:06420 Jmeter 作为当前非常受欢迎的接口测试和性能测试的工具,在企业中得到非常广泛的使用,而 Redis 作为缓存数据库,也在企业中得到普遍使用,那如何 ...

  7. [转帖]超线程 Smt 究竟可以快多少？

    https://www.51cto.com/article/686171.html 刚才我们关闭SMT是把CPU10-CPU19全关了,只留下每对里面的1个CPU,也就是留下了CPU0-CPU9. 默 ...

  8. [转帖]宁可信鬼，也不信 iowait 这张嘴！

    https://zhuanlan.zhihu.com/p/407333624 原创:小姐姐味道(微信公众号ID:xjjdog),欢迎分享,转载请保留出处. 我们经常遇到iowait这个名词,在top命 ...

  9. [转帖]SPEC测试arm服务器性能,SPECJVM2008测试处理器性能_服务器评测与技术-中关村在线...

    首先,我们使用SPECJVM2008测试最新至强E5处理器的虚拟化性能. SPECJVM2008是一种通用的多线程Java基准测试工具,它能够反映JRE(Java Runtime Environmen ...

  10. ESXi6.5+vCenter6.5 CentOS7 虚拟机启动之后控制台黑屏的解决方案

    公司最近搬迁服务器, 服务器的地址都发生了变化, 发现部分机器总是黑屏无法使用, 想了一个坚决办法使服务器能够连接设置地址后使用. 1. 控制台开机. 2. 注意在开机五秒之内打开web控制台, 然后 ...