图论——环检测

图论——环检测

问题分析

检测上图是否有环其实也相当简单，只要dfs的过程发现某个顶点的邻接顶点已经访问过了，就说明有环，除此之外，还要排除一种情况，如下：
例如从0开始dfs，0已访问
dfs 1，发现1的邻接顶点0已被访问，此时不可以判定有环，即要排除已访问的顶点不是上一个顶点(parent)

代码

graph.txt

7 6
0 1
0 2
1 3
2 6
2 3
1 4

环检测

public class CycleDetection2 {
    private UndirectedGraph graph;
    private boolean[] visited;
    private boolean hasCycle;

    public CycleDetection2(UndirectedGraph graph){
        this.graph = graph;
        visited = new boolean[graph.vertexNum()];
        for(int v=0;v<graph.vertexNum();v++){
            if(!visited[v]){
                if(dfs(v,v)){
                    hasCycle = true;
                    break;
                }
            }
        }
    }
    public boolean isHasCycle(){
        return hasCycle;
    }

    /**
     * v是从parent顶点过来的
     * @param v
     * @param parent
     * @return
     */
    private boolean dfs(int v,int parent){
        visited[v] = true;
        for(int w:graph.adj(v)) {
            if(!visited[w]){
                if(dfs(w,v))return true;
                //0-----1，排除0->1->0这种环检测
            }else if(w!=parent){
                return true;
            }
        }
        return false;
    }


    public static void main(String[] args) {
        UndirectedGraph graph = new UndirectedGraph("graph.txt");
        System.out.println(graph);
        CycleDetection2 graphDFS = new CycleDetection2(graph);
        System.out.println(graphDFS.isHasCycle());
    }
}

建图代码

public class UndirectedGraph {
    private int V;//顶点数
    private int E;//边数
    private TreeSet<Integer>[] adj;//邻接表，TreeSet数组存储

    public UndirectedGraph(String filename){
        File file = new File(filename);
        try(Scanner scanner = new Scanner(file)){
            V = scanner.nextInt();//顶点数
            if(V<=0) throw new RuntimeException("顶点个数必须大于0");
            adj = new TreeSet[V];
            for(int i=0;i<V;i++){
                adj[i] = new TreeSet<>();
            }
            E = scanner.nextInt();//边数
            if(E<0) throw new RuntimeException("边数不能为负数");
            for(int i=0;i<E;i++){
                int a = scanner.nextInt();
                validateVertex(a);
                int b = scanner.nextInt();
                validateVertex(b);
                //自环边检测
                if(a==b){
                    throw new RuntimeException("简单图不能包含自环边");
                }
                //平行边检测
                if(adj[a].contains(b)){
                    throw new RuntimeException("简单图不能包含平行边");
                }
                adj[a].add(b);
                adj[b].add(a);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    public void validateVertex(int v){
        if(v<0||v>=V){
            throw new RuntimeException("顶点下标溢出");
        }
    }
    public int vertexNum(){
        return V;
    }
    public int edgeNum(){
        return E;
    }
    public boolean hasEdge(int v,int w){
        validateVertex(v);
        validateVertex(w);
        return adj[v].contains(w);
    }

    //邻接顶点
    public Iterable<Integer> adj(int v){
        validateVertex(v);
        return adj[v];
    }

    //度
    public int degree(int v){
        validateVertex(v);
        return adj[v].size();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("V = %d,E = %d\n",V,E));
        for(int i=0;i<adj.length;i++){
            sb.append(i+":");
            for (Iterator<Integer> it = adj[i].iterator(); it.hasNext(); ) {
                sb.append(it.next()+" ");
            }
            sb.append("\n");
        }
        return sb.toString();
    }


    public static void main(String[] args) {
        UndirectedGraph graph = new UndirectedGraph("graph.txt");
        System.out.println(graph);
    }
}