寻找无向连通图的割点

无向连通图的割点又被成为关节点(articulation point), 移除关节点，则原连通图变成两个连通分量, 一个没有关节点的连通图被成为重连通图 (biconnected graph)

 

 

要寻找无向连通图中所有的关节点，比较便捷的方法是利用一次深度优先遍历，找到所有关节点

 

对于节点u，及其子节点v,  u->v, 可以用数组dfn[u]来表示当前u的遍历序列号，用low[u]表示u及u的子节点通过非tree edge所能找到的最早的祖先节点的序列号, 如果u是关节点，则有两种情况：

1. 如果u是根节点，且u有两棵及以上的子树，则节点u为关节点，很明显，移除u会使其两棵子树变成不连通的两个连通分量

2. 如果对于节点v， low[v]的值 >= dfn[u], 说明v及其子节点最多能指到节点u, 没有其他路径能指到u的祖先，则移除u，其子节点v会成为独立的连通分量

 

得到公式:  low[u] = min (

　　　　　　　　　　dfn[u],

　　　　　　　　　　low[v],  u -> v 是tree edge, 即节点v以前未被dfs遍历过, 此时low[u] = min(low[u], low[v])

　　　　　　　　　　dfn[v],  u -> v 是back edge, 即节点v已经被访问过, 此时low[u] = min(low[u], dfn[v]),

　　　　　　　　　　为什么不是low[v]而是dfn[v], 因为此时节点v已经被访问过了，说明 u->v是条回边，v是当前节点u的祖先,我们直接取该祖先的遍历序列值即可

　　　　　　　　　　　　)

 

下表给出图(a)对应的dfn与low数组值。

 

i	0	1	2	3	4	5	6	7	8	9	10	11	12
vertex	A	B	C	D	E	F	G	H	I	J	K	L	M
dfn[i]	1	5	12	10	11	13	8	6	9	4	7	2	3
low[i]	1	1	1	5	5	1	5	5	8	2	5	1	1

 

 

package com.rui.microsoft;

public class Test39_FindCutPoints {

    public static void main(String[] args) {
        UndirectedGraph dGraph = new UndirectedGraph(5);
        dGraph.addEdge(0, 1);
        dGraph.addEdge(1, 2);
        dGraph.addEdge(2, 0);
        dGraph.addEdge(0, 3);
        dGraph.addEdge(3, 4);
        dGraph.tarjan(0);
        
        for(int i = 0; i < dGraph.V; i++){
            if(dGraph.APs[i]){
                System.out.println(" " + i);
            }
        }
    }
}

class UndirectedGraph{
    
    int V;
    Bag<Integer>[] adj;
    
    boolean[] visited;
    int[] dfn;
    int[] low;
    int[] parents;
    
    boolean[] APs;
    
    int order = 0;
    
    public UndirectedGraph(int size) {
        this.V = size;
        this.adj = new Bag[size];
        
        this.dfn = new int[size];
        this.low = new int[size];
        this.parents = new int[size];
        this.visited = new boolean[size];
        this.APs = new boolean[size];
        
        for(int i = 0; i < size; i++){
            this.adj[i] = new Bag<Integer>();
            this.parents[i] = -1;
            this.APs[i] = false;
        }
    }
    
    void addEdge(int from, int to){
        adj[from].add(to);
        adj[to].add(from);
    }
    
    void tarjan(int u){
        dfn[u] = low[u] = ++order;
        visited[u] = true;
        int childs = 0;
        
        //dfs
        for(int v: this.adj[u]){
            if(!visited[v]){
                childs++;
                parents[v] = u;
                tarjan(v);
                
                //after dfs the subtree of v
                low[u] = min(low[u], low[v]);
                
                //check
                if(parents[u] == -1 && childs > 1){
                    APs[u] = true;
                }
                
                if(parents[u] != -1 && dfn[u] <= low[v]){
                    APs[u] = true;
                }
            }else{
                //back edge
                low[u] = min(low[u], dfn[v]);
            }
        }
    }
    
    int min(int a, int b){
        return a<b? a: b;
    }
}

辅助类Bag

package com.rui.microsoft;

import java.util.Iterator;
import java.util.NoSuchElementException;

public class Bag<Item> implements Iterable<Item>{
    
    private Node<Item> first;
    private int N;
    
    private static class Node<Item>{
        private Item item;
        private Node<Item> next;
    }
    
    public Bag(){
        first = null;
        N = 0;
    }
    
    public boolean isEmpty(){
        return first == null;
    }
    
    public int size(){
        return N;
    }
    
    public void add(Item item){
        Node<Item> oldFirst = first;
        first = new Node<Item>();
        first.item = item;
        first.next = oldFirst;
        N++;
    }
    
    @Override
    public Iterator<Item> iterator() {
        return new ListIterator<Item>(first);
    }
    
    private class ListIterator<Item> implements Iterator<Item> {
        private Node<Item> current;

        public ListIterator(Node<Item> first) {
            current = first;
        }

        public boolean hasNext()  { return current != null;                     }
        public void remove()      { throw new UnsupportedOperationException();  }

        public Item next() {
            if (!hasNext()) throw new NoSuchElementException();
            Item item = current.item;
            current = current.next; 
            return item;
        }
    }
    
}