Ex3_15 判断图是否是一个强连通分量 判断点是否在汇点强连通分量中_十一次作业

(a) 可以用图中的每一个顶点表示街道中的每个十字路口，由于街道都是单行的，所以图是有向图，若从一个十字路口都有一条合法的路线到另一个十字路口,则图是一个强连通图。即要验证的是图是否是一个强连通图。

 (b) 若从市政厅沿着合法路线到达任何一个地方都有合法路线返回则说明市政厅位于一个有向图中的一个汇点强连通部件中。

package org.xiu68.ch03.ex11;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class Ex3_15 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] edges=new int[][]{
            {0,1,0,0},
            {0,0,1,0},
            {0,0,0,1},
            {1,0,0,0}
        };
        MGraph1 m1=new MGraph1(edges);
        m1.checkSC(0);  //强连通图
        
        System.out.println("***************************");
        int[][] edges1=new int[][]{
            {0,1,0,1},
            {0,0,1,0},
            {0,0,0,1},
            {0,0,0,0}
        };
        MGraph1 m2=new MGraph1(edges1);
        m2.checkSC(0);
        for(int i=0;i<4;i++){
            System.out.print(i+":");
            m2.isInSinkSCC(i);
        }
        //输出
        /*
         非强连通图
        0:不存在汇点强连通分量中
        1:不存在汇点强连通分量中
        2:不存在汇点强连通分量中
        3:存在汇点强连通分量中
        */
        
        System.out.println("***************************");
        int[][] edges3=new int[][]{
            {0,0,0,0,0,0,0},
            {1,0,0,1,0,0,0},
            {1,0,0,1,0,0,0},
            {0,0,0,0,1,1,0},
            {0,0,0,1,0,0,1},
            {0,0,0,1,0,0,1},
            {0,0,0,0,1,1,0}
        };
        MGraph1 m3=new MGraph1(edges3);
        for(int i=0;i<edges3.length;i++){
            System.out.print(i+":");
            m3.isInSinkSCC(i);
        }
        //输出
        /*
        0:存在汇点强连通分量中
        1:不存在汇点强连通分量中
        2:不存在汇点强连通分量中
        3:存在汇点强连通分量中
        4:存在汇点强连通分量中
        5:存在汇点强连通分量中
        6:存在汇点强连通分量中
        */
    }

}


class MGraph1{
    private int[][] edges;                //有向图
    private int[][] rEdges;                //有向图的反向图
    private int vexNum;                    //顶点数量
    private Stack<Integer> stack;        //存储反向图深度优先遍历的post值
    
    public MGraph1(int[][] edges){
        this.edges=edges;
        this.vexNum=edges.length;
        stack=new Stack<>();
        rEdges=new int[vexNum][vexNum];    //反向图
        
        //求原图的反向图
        for(int i=0;i<vexNum;i++){
            for(int j=i+1;j<vexNum;j++){
                rEdges[i][j]=edges[j][i];
                rEdges[j][i]=edges[i][j];
            }
        }
        
    }
    //******************************************************
    //验证图是否是强连通的
    /*
     * 先从某个顶点开始对原图进行深度优先遍历
     * 再从这个顶点开始对反向图做深度优先遍历
     * 若两次遍历都能访问所有顶点说明是强连通图
     */
    public void checkSC(int v){
        boolean[] visited=new boolean[vexNum];    //原图中已访问的顶点
        dfs(edges,visited,v);
        
        boolean[] rVisited=new boolean[vexNum];    //反向图中已访问的顶点
        dfs(rEdges,rVisited,v);
        
        for(int i=0;i<vexNum;i++){
            if(!visited[i] || !rVisited[i]){
                System.out.println("非强连通图");
                return;
            }
        }
        System.out.println("强连通图");
    }
    
    //深度优先遍历
    public void dfs(int[][] edges,boolean[] visited,int v){
        visited[v]=true;
        for(int i=0;i<vexNum;i++){
            if(edges[v][i]==1 && !visited[i]){
                dfs(edges,visited,i);
            }
        }
    }
//**************************************************************    
    //判断一个顶点是否位于一个汇点强连通部件中
    public void isInSinkSCC(int target){
        rDFSTraverse();                                    //先对反向图进行深度优先遍历
        
        //List<List<Integer>> sccs=new ArrayList<>();    //存放每一个强连通部件对应的顶点
        
        boolean[] visited=new boolean[vexNum];            //记录深度优先遍历原图过程中非当前强连通分量已经访问的顶点
        int[] visitedN=new int[vexNum];                    //记录顶点属于第几个强连通分量
        boolean[] isSinkSCC=new boolean[vexNum];        //记录第i个强连通分量是否是汇点强连通部件，最多有vexNum个强连通部件        
        int n=0;                                        //第几个强连通部件    
        
        for(int i=0;i<vexNum;i++){
            visitedN[i]=-1;
            isSinkSCC[i]=true;
        }
                                            
        while(!stack.isEmpty()){
            int v=stack.pop();
            if(!visited[v]){
                //sccs.add(new ArrayList<Integer>());
                List<Integer> vexs=new ArrayList<>();    //记录第n个强连通分量的顶点
                
                DFS(visited,visitedN,v,vexs,isSinkSCC,n);
                for(int i=0;i<vexs.size();i++){
                    //sccs.get(i).add(vexs.get(i));
                    visited[vexs.get(i)]=true;
                }
                n++;
            }
        }
        if(isSinkSCC[visitedN[target]]){
            System.out.println("存在汇点强连通分量中");
        }else{
            System.out.println("不存在汇点强连通分量中");
        }
    }
    /*
     * 对原图进行深度优先遍历
     * 在汇点强连通部件中对某个顶点进行深度优先遍历则刚好访问该强连通部件的所有顶点
     */
    private void DFS(boolean[] visited,int[] visitedN,int v,/*List<List<Integer>> sccs,*/
            List<Integer> vexs,boolean[] isSinkSCC,int n){ 
        //sccs.get(n).add(v);
        vexs.add(v);
        visitedN[v]=n;
        for(int i=0;i<vexNum;i++){
            if(edges[v][i]==1){            
                //若在一个汇点强连通部件中进行深度优先遍历,刚好得到该汇点强连通部件
                //若遍历到其他强连通分量的顶点说明该强连通分量不是汇点强连通分量
                if(visited[i]){        
                    isSinkSCC[n]=false;
                }else if(visitedN[i]!=n){                
                    DFS(visited,visitedN,i,/*sccs,*/vexs,isSinkSCC,n);
                }
            }
        }//for
    }
    
    //**************************************************************    
        /*
         * 对反向图进行深度优先遍历,post值最大的顶点将位于反向图中的一个源点强连通部件，
         * 也就是原图中的某个汇点连通部件的某个顶点
         * 按post值从小到大,压入栈中
         */
        public void rDFSTraverse(){
            boolean[] visited=new boolean[vexNum];
            for(int i=0;i<vexNum;i++){
                if(!visited[i]){
                    rDFS(visited,stack,i);
                }
            }
        }        
        //对反向图做深度优先遍历
        private void rDFS(boolean[] visited,Stack<Integer> stack,int v){
            visited[v]=true;
            for(int i=0;i<vexNum;i++){
                if(rEdges[v][i]==1 && !visited[i]){
                    rDFS(visited,stack,i);
                }
            }
            stack.push(v);
        }
}