zoukankan      html  css  js  c++  java
  • 求割点 割边 Tarjan

    附上一般讲得不错的博客 https://blog.csdn.net/lw277232240/article/details/73251092  

                                            https://www.cnblogs.com/collectionne/p/6847240.html

                                            https://blog.csdn.net/zhn_666/article/details/77971619

    然后附上模板题:              https://vjudge.net/problem/HihoCoder-1183

    裸题,直接要你输出割点 和 割边.. 唯一坑点就是割边的输出..自己看题.

    #include <set>
    #include <cstdio>
    #include <algorithm>
    
    using namespace std;
    
    
    struct Point {
        int u;
        int v;
        Point () { }
        Point (int uu, int vv) : u(uu), v(vv) { }
        bool operator < (const Point &a) const {
            if (u != a.u) return u < a.u;
            return v < a.v;
        }
    };
    
    struct Edge {
        int lst;
        int to;
    }edge[200500];
    int head[20500];
    int qsz = 1;
    
    inline void add(int u, int v) {
        edge[qsz].lst = head[u];
        edge[qsz].to  = v;
        head[u] = qsz++;
    }
    
    int  dfn[20500];
    int  low[20500];
    //int   pa[20500];
    int  dfn_num;
    set<int> ans;
    set<Point> ans_pt;
    /*
    void Tarjan(int u) {
        int i, v, child = 0;    
        dfn[u] = low[u] = ++dfn_num;
        for (i=head[u]; i; i=edge[i].lst) {
            v = edge[i].to;
            if (v == pa[u]) continue; 
            if (!dfn[v]) { // 树边, 父子边 
                pa[v] = u;
                Tarjan(v);
                child++;
                low[u] = min(low[u], low[v]);  
                //  case 1 u是根节点,同时只是有2颗子树---> 无向图 所以可能有多个根节点.
                if (!pa[u] && child>=2) ans.insert(u) ;  // 根节点是否有多颗子树.. 注意 这个是写在if (!vis[u])里面的.
                //  case 2 u是叶子节点, 割点条件是low[v]>=dfn[u] 
                if ( pa[u] && low[v] >= dfn[u]) ans.insert(u); // 说明v无法连接到u的祖先. 
                //  桥 的条件是: low[v] > dfn[u] 
                if (low[v] > dfn[u]) ans_pt.insert(Point(min(u, v), max(v, u))); // 说明v无法连接到u或者u的祖先.     
            } else {
                low[u] = min(low[u], dfn[v]);  // u v 为回边
            }
        }
    }
    */
    void Tarjan(int u, int fa) {
        int i, v, child = 0;    
        dfn[u] = low[u] = ++dfn_num;
        for (i=head[u]; i; i=edge[i].lst) {
            v = edge[i].to;
            if (v == fa) continue; 
            if (!dfn[v]) { // 树边, 父子边 
                Tarjan(v, u);
                child++;
                low[u] = min(low[u], low[v]);  
                //  case 1 u是根节点,同时只是有2颗子树---> 无向图 所以可能有多个根节点.
                if (fa==u && child>=2) ans.insert(u) ;  // 根节点是否有多颗子树.. 注意 这个是写在if (!vis[u])里面的.
                //  case 2 u是叶子节点, 割点条件是low[v]>=dfn[u] 
                if (fa!=u && low[v] >= dfn[u]) ans.insert(u); // 说明v无法连接到u的祖先. 
                //  桥 的条件是: low[v] > dfn[u] 
                if (low[v] > dfn[u]) ans_pt.insert(Point(min(u, v), max(v, u))); // 说明v无法连接到u或者u的祖先.     
            } else {
                low[u] = min(low[u], dfn[v]);  // u v 为回边
            }
        }
    }
    
    int main()
    {
    //    freopen("E:\input.txt", "r", stdin);
        int n, m;
        int u, v, i, j;
        scanf("%d%d", &n, &m);
        for (i=1; i<=m; ++i) {
            scanf("%d%d", &u, &v);
            add(u, v);
            add(v, u);
        }
        Tarjan(1, 1);
        
        if (ans.size()) {
            bool flag = true;
            
            for (auto iter : ans) {
                if (flag) {
                    printf("%d", iter);
                    flag = false;
                } else printf(" %d", iter);
            }
        } else {
            printf("Null");
        }
        printf("
    ");
        for (auto iter : ans_pt) 
            printf("%d %d
    ", iter.u, iter.v);    
        
        return 0;
    }
    View Code

    连通度 : 连通图的连通程度. 分为点连通 和 边连通.

    割点:在连通图中,删除了连通图的某个点以及与这个点相连的边后,图不再连通。这样的点就是割点。
    割边:在连通图中,删除了连通图的某条边后,图不再连通。这样的边被称为割边,也叫做桥。

    DFS搜索树:用DFS对图进行遍历时,按照遍历次序的不同,我们可以得到一棵DFS搜索树。


    树边:在搜索树中的蓝色线所示,可理解为在DFS过程中访问未访问节点时所经过的边,也称为父子边
    回边:在搜索树中的橙色线所示,可理解为在DFS过程中遇到已访问节点时所经过的边,也称为返祖边、后向边

    求割点 割边(桥)

    注意 low[]和求连通分量的意义不同

    求连通分量的low[]的意思是,节点u能访问的最小时间戳

    求割点 桥 的low[]的意思是  顶点u及其子树中的点,通过非父子边(回边),能够回溯到的最早的点(dfn最小)的dfn值

    void Tarjan(int u, int fa) {
        int i, v, child = 0;    
        dfn[u] = low[u] = ++dfn_num;
        for (i=head[u]; i; i=edge[i].lst) {
            v = edge[i].to;
            if (v == fa) continue; 
            if (!dfn[v]) { // 树边, 父子边 
                Tarjan(v, u);
                child++;
                low[u] = min(low[u], low[v]);  
                //  case 1 u是根节点,同时只是有2颗子树---> 无向图 所以可能有多个根节点.
                if (fa==u && child>=2) ans.insert(u) ;  // 根节点是否有多颗子树.. 注意 这个是写在if (!vis[u])里面的.
                //  case 2 u是叶子节点, 割点条件是low[v]>=dfn[u] 
                if (fa!=u && low[v] >= dfn[u]) ans.insert(u); // 说明v无法连接到u的祖先. 
                //  桥 的条件是: low[v] > dfn[u] 
                if (low[v] > dfn[u]) ans_pt.insert(Point(u, v)); // 说明v无法连接到u或者u的祖先.     
            } else {
                low[u] = min(low[u], dfn[v]);  // u v 为回边
            }
        }
    }
  • 相关阅读:
    ADB 多设备中指定设备的启动
    vuex 绑定表单,多个输入框的解决办法
    vue 自动触发点击事件
    js 打印dom的所有属性
    邮件分享
    table表格 td设置固定宽度
    Echarts--Y坐标标题显示不全
    ExtJS5.0 菜鸟的第一天
    字体设置
    短信验证码+倒计时
  • 原文地址:https://www.cnblogs.com/cgjh/p/9557760.html
Copyright © 2011-2022 走看看