Expm 9_3 无向图的双连通分量问题

 

【问题描述】

给定一个无向图，设计一个算法，判断该图中是否存在关节点，并划分双连通分量。

package org.xiu68.exp.exp9;

import java.util.Stack;

public class Exp9_3 {
    
    //无向图的双连通分量问题
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] graph=new int[][]{
            {0,1,1,0,0},
            {1,0,1,0,0},
            {1,1,0,1,1},
            {0,0,1,0,1},
            {0,0,1,1,0}
        };
        MGraph1 m=new MGraph1(graph);
        m.bicompDFS(0);
        //运行结果
            /*
             双连通部件: 
            (4,2) (3,4) (2,3) 
            双连通部件: 
            (2,0) (1,2) (0,1)
             */
    }

}


//邻接矩阵表示无向图
class MGraph1{
    private int vexNum;                //顶点数量
    private int[][] edges;            //边
    
    private Stack<Edge> edgeStack;    //边栈
    private int[][] visitedEdge;    //记录哪条边已经访问过,1为访问过,0为未访问过
    
    private int[] color;            //记录顶点的访问状态，-1为未访问到,0为正在搜索中,1为已搜索完成
    private int    clock;                //访问时刻
    private int[] pre;                //记录顶点的访问时间
    private int[] post;                //记录顶点的结束访问时刻

    
    public MGraph1(int[][] edges) {
        this.edges = edges;
        this.vexNum=edges.length;
        this.color=new int[vexNum];
        this.pre=new int[vexNum];
        this.post=new int[vexNum];
        this.clock=1;
        this.edgeStack=new Stack<>();
        this.visitedEdge=new int[vexNum][vexNum];
        
        //初始化所有结点为未访问状态
        for(int i=0;i<vexNum;i++){
            color[i]=-1;
        }
    }
    
    //返回从v出发，经过一条其后代组成的边包括回退边,所能访问到的顶点的最小的pre值
    public int bicompDFS(int v){
        //color[v]的值：-1为未访问到,0为正在搜索中,1为已搜索完成
        color[v]=0;                        //顶点v正在搜索中
        pre[v]=clock;                    //顶点v的访问时刻
        clock++;
        
        int back=pre[v];    //表示从v出发，经过一条其后代组成的边包括回退边,所能访问到的顶点的最小的pre值
        
        for(int i=0;i<vexNum;i++){
            if(edges[v][i]==1 && color[i]!=1 && visitedEdge[v][i]!=1){    //顶点v和i之间有边未访问过
                
                edgeStack.push(new Edge(v,i));            //放入边栈中
                visitedEdge[v][i]=visitedEdge[i][v]=1;    //记录边已访问过
                
                if(color[i]==-1){                 //树边
                    int wBack=bicompDFS(i);
                    
                    if(wBack>=pre[v]){          //说明v的子树没有回路关联到v的祖先
                        System.out.println("双连通部件: ");
                        Edge e=edgeStack.pop();
                        while(true){
                            System.out.print("("+e.getHead()+","+e.getTail()+") ");
                            if(e.getHead()==v && e.getTail()==i)
                                break;
                            e=edgeStack.pop();
                        }
                        System.out.println();
                    }
                    if(wBack<back)
                        back=wBack;                //记录从v开始经过的顶点的最小的pre值
                }else if(color[i]==0){            //回边
                    if(pre[i]<back)
                        back=pre[i];            //记录从v开始经过的顶点的最小的pre值
                }
            }//if
        }//for
        
        post[v]=clock;
        clock++;
        color[v]=1;
        
        return back;
    }
}

class Edge{
    private int head;    //边的头
    private int tail;    //边的尾
    
    public Edge(int head,int tail){
        this.head=head;
        this.tail=tail;
    }

    public int getHead() {
        return head;
    }

    public void setHead(int head) {
        this.head = head;
    }

    public int getTail() {
        return tail;
    }

    public void setTail(int tail) {
        this.tail = tail;
    }
    
}