求无向连通图的割点

求一个连通图的割点，割点的定义是，如果除去此节点和与其相关的边，图不再连通。

连通图的定义：如果图中任意两点都是连通的，那么图被称作连通图。如果此图是有向图，则称为强连通图（注意：需要双向都有路径）

割点：在无向连通图中，删除一个顶点v及其相连的边后，原图从一个连通分量变成了两个或多个连通分量，则称顶点v为割点，同时也称关节点 (Articulation Point)。多连通图没有割点，若在多连通图上至少删去k个顶点才能破坏图的连通性，则称此图为k连通图。貌似有向连通图没有割点这个说法。

连通分量：求无向图的连通分量的时候需要先找到割点。在求有向图的强连通分量的时候，所使用的方法与求无向连通图割点的做法很相似，所谓的Tarjan算法。

算法分析

经典的解法是建立DFS搜索树，有两类树节点可以成为割点：

对根节点v，若其有两棵或两棵以上的dfs子树，则该根结点为割点；
对非叶子节点v（非根节点），若其某个子树的节点均没有指向v的祖先节点的回边，则v为割点。

实现的时候，随着DFS的进行，需要维护2类信息，一是每个节点v的DFS序号（节点的访问次序），一是每个节点v及v的子树在DFS树中能追溯到的最早祖先节点（即DFS序号最小），将其记为v的最早祖先（至少能追溯到v的父节点）。

如果v的某一个子树无法回溯到v的祖先，则v是割点，所以在遍历v子树的过程中，v可能会被反复判断为割点，如果仅仅是求割点则需要去除重复记录，如果是求连通分量则不需要。在遍历完节点v的所有子树及v自己的祖先后就可以求出v的最早祖先，进而结束v的处理，回到v的父节点。

//输入图的邻接矩阵，节点编号0~n
    void doDFS(const vector<vector<int> >& G,int v,int currDfs,bool isRoot,vector<int>& low,vector<int>& dfs,vector<int>& articulation);
    void calcArticulation(const vector<vector<int> >& G,vector<int>& articulation)
    {
        int v = 0;
        int currDfs=0;
        vector<int> low(G.size(),-1), dfs(G.size(),-1);
        doDFS(G,v,currDfs,true,low,dfs,articulation);

    }
    //G：邻接矩阵， v当前节点，currdfs当前的dfs编号，isroot指示v是否是dfs树的根节点，
    //low记录所有节点的最早祖先，dfs记录所有节点的dfs序号，articulation存放求得的割点
    void doDFS(const vector<vector<int> >& G,int v,int currDfs,bool isRoot,vector<int>& low,vector<int>& dfs,vector<int>& articulation)
    {
        dfs[v] = currDfs;
        low[v] = currDfs;
        bool isArticulation=false;
        int child=0; //记录节点v的dfs子树个数
        for(size_t i=0; i < G[v].size(); ++i)
        {
            if(G[v][i]==0){continue;}
            int next = i;
            if(dfs[next] == -1){
                child++;
                doDFS(G,next,currDfs+1,false,low,dfs,articulation);

                if(low[next] >= dfs[v]){//子树没有回溯到v的祖先，v是割点
                    isArticulation = true;
                }
                else{//子树连通祖先，需要更新low[v]
                    low[v] = low[next] < low[v] ? low[next]:low[v];
                }
            }
            else{
                //注意判断next小于low[v]，因为low[v]可能被循环反复更新
                low[v] = dfs[next] < low[v] ? dfs[next] : low[v];
            }
        }

        if(isArticulation==true)
        {
            //如果是DFS树根，还需要满足额外条件
            if(isRoot==true) {
                if(child > 1){
                    articulation.push_back(v);
                }
            }
            else{
                articulation.push_back(v);
            }
        }
    }
        static void test(const vector<vector<int> >& G)
    {
        vector<int> articulation;
        calcArticulation(G,articulation);
        for(size_t i=0; i < articulation.size();++i){
            printf("%d,",articulation[i]);
        }
        printf("\n");
    }
    //  ---- 0
    // |    / \
    // |  1    4
    // | / \
    // 2    3
    static void test1()
    {
        int t[5][5]={
            {0,1,1,0,1},
            {1,0,1,1,0},
            {1,1,0,0,0},
            {0,1,0,0,0},
            {1,0,0,0,0}
        };

        vector<vector<int> > G(5);
        for(int i=0; i < 5 ;++i){
            G[i].assign(t[i],t[i]+5);
        }
        test(G);
    }
    //       0
    //     /   \
    //    1     4
    //   / \
    // 2    3
    static void test2()
    {
        int t[5][5]={
            {0,1,0,0,1},
            {1,0,1,1,0},
            {0,1,0,0,0},
            {0,1,0,0,0},
            {1,0,0,0,0}
        };

        vector<vector<int> > G(5);
        for(int i=0; i < 5 ;++i){
            G[i].assign(t[i],t[i]+5);
        }
        test(G);
    }
    //      0
    //    /   \
    //   1     4
    //  / \
    // 2   3
    //      \
    //       5
    static void test3()
    {
        int t[6][6]={
            {0,1,0,0,1,0},
            {1,0,1,1,0,0},
            {0,1,0,0,0,0},
            {0,1,0,0,0,1},
            {1,0,0,0,0,0},
            {0,0,0,1,0,0}
        };

        vector<vector<int> > G(6);
        for(int i=0; i < 6 ;++i){
            G[i].assign(t[i],t[i]+6);
        }
        test(G);
    }
        //     0
    //    /  \
    //   1----3
    //  /
    // 2
    static void test4()
    {
        int t[4][4]={
            {0,1,0,1},
            {1,0,1,1},
            {0,1,0,0},
            {1,1,0,0}
        };

        vector<vector<int> > G(4);
        for(int i=0; i < 4 ;++i){
            G[i].assign(t[i],t[i]+4);
        }
        test(G);
    }
    //     0
    //    /
    //   1
    //  / \
    // 2   3
    static void test5()
    {
        int t[4][4]={
            {0,1,0,0},
            {1,0,1,1},
            {0,1,0,0},
            {0,1,0,0}
        };

        vector<vector<int> > G(4);
        for(int i=0; i < 4 ;++i){
            G[i].assign(t[i],t[i]+4);
        }
        test(G);
    }
    //双连通图，没有割点
    //  -----0
    // |   / |
    // |  1  |
    // | / \ |
    // 2     3
    static void test6()
    {
        int t[4][4]={
            {0,1,1,1},
            {1,0,1,1},
            {1,1,0,0},
            {1,1,0,0}
        };

        vector<vector<int> > G(4);
        for(int i=0; i < 4 ;++i){
            G[i].assign(t[i],t[i]+4);
        }
        test(G);
    }
    static void test7()
    {
        int t[2][2]={
            {0,1},
            {1,0}
        };

        vector<vector<int> > G(2);
        for(int i=0; i <2 ;++i){
            G[i].assign(t[i],t[i]+2);
        }
        test(G);
    }
    //     0
    //    / \
    //   1   4
    //  / \
    // 2   3
    // |    \
    //  ---- 5
    static void test8()
    {
        int t[6][6]={
            {0,1,0,0,1,0},
            {1,0,1,1,0,1},
            {0,1,0,0,0,0},
            {0,1,0,0,0,1},
            {1,0,0,0,0,0},
            {0,1,0,1,0,0}
        };

        vector<vector<int> > G(6);
        for(int i=0; i < 6 ;++i){
            G[i].assign(t[i],t[i]+6);
        }
        test(G);
    }
    void testArticulation()
    {
        test1();
        test2();
        test3();
        test4();
        test5();
        test6();
        test7();
        test8();
    }

posted @ 2015-02-11 23:14 _pop 阅读(2087) 评论(1) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

_pop

求无向连通图的割点

公告