Interview Questions: Undirected Graphs

Undirected Graphs

Nonrecursive depth-first search. Implement depth-first search in an undirected graph without using recursion.

非递归实现DFS。

public void DFS(Graph G, int v, boolean[] marked) {
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(v);
	    System.out.println(v);
    	marked[v] = true;
        while (!stack.isEmpty()) {
            boolean flag = true;
            int cur = stack.peek();
            for (int w : G.adj(cur)) {
                // 当前栈顶结点存在未被访问的邻接点则将该邻接点入栈
                if (!marked[w]) {
                    stack.push(w);
                    System.out.println(w);
                    marked[w] = true;
                    flag = false;
                    break;
                }
            }
            // 若栈顶结点不存在未被访问的邻接点，则将栈顶结点出栈
            if (flag) {
                stack.pop();
            }
        }
    }

Diameter and center of a tree. Given a connected graph with no cycles

• Diameter: design a linear-time algorithm to find the longest simple path in the graph.
• Center: design a linear-time algorithm to find a vertex such that its maximum distance from any other vertex is minimized.

求一个无环树图的直径和中心，直径为树图中长度最长的路径，中心为到其他点的最大距离最小的点。

具体方法：任意选取图中一个点，找到距离这个点最远的点A(对DFS来说，就是递归层次最深的点；对BFS来说，就是队列中最后加入的点)，再以点A为起点，找到距离点A最远的点B，那么从A到B构成的路径AB就是所要求的直径，而中心就是这条直径上的中点。所使用的时间为两次遍历，即$O(2V)$。

该方法的正确性证明参考 求最深根贪心证明 。

Euler cycle. An Euler cycle in a graph is a cycle (not necessarily simple) that uses every edge in the graph exactly once.

• Show that a connected graph has an Euler cycle if and only if every vertex has even degree.
• Design a linear-time algorithm to determine whether a graph has an Euler cycle, and if so, find one.

欧拉回路指的是包含了图中所有边(且仅包含一次)的路径。

对于A-B这条边，要么是从A走到B时遍历到这条边(以A的角度为出)，要么是从B走到A时遍历到这条边(以A的角度为入)。对于一个结点来说，只有当它的入度等于出度的时候，才能将所有与它连接的边包含到一条路径中。无向图中没有入度出度的概念，转换过来就是对于无向图中的一个结点，只有当与它连接的边的数量为偶数时，才能将这些边包含到一条路径中。

所以一个图只有每一个结点都有偶数条边，且图中只含有一个连通分量，才具有欧拉回路。

关于欧拉回路的路径寻找，参考 【欧拉回路】讲解+判定+输出“点”路径。

import java.util.*;

public class Euler {
    Graph g;

    public Euler(Graph g) {
        this.g = g;
    }

    public boolean hasEulerCycle() {
        int[] degree = g.degree();
        // 判断是否每个结点都有偶数条边相连
        for (int i = 0; i < g.V(); i++) {
            if (degree[i] % 2 == 1) {
                return false;
            }
        }
        // 判断是否只有一个连通分量
        return isConnected();
    }

    public Iterable<Integer> findPath() {
        List<Integer> path = new ArrayList<>();
        DFS(0, g.getEdges(), path);
        Collections.reverse(path);
        return path;
    }
    
    // Hierholzers算法寻找欧拉回路
    private void DFS(int v, List<List<Integer>> edges, List<Integer> path) {
        for (int i = 0; i < g.V(); i++) {
            if (edges.get(v).contains(i)) {
                edges.get(v).remove(Integer.valueOf(i));
                edges.get(i).remove(Integer.valueOf(v));
                DFS(i, edges, path);
            }
        }
        path.add(v);
    }

    // 判断是否只有一个连通分量
    private boolean isConnected() {
        Queue<Integer> q = new ArrayDeque<>();
        boolean[] visited = new boolean[g.V()];
        int count = 0;
        q.offer(0);
        visited[0] = true;
        while (!q.isEmpty()) {
            int cur = q.poll();
            count++;
            for (int i : g.adj(cur)) {
                if (!visited[i]) {
                    visited[i] = true;
                    q.add(i);
                }
            }

        }
        return count == g.V();
    }
}

class Graph {
    private List<List<Integer>> edges;
    private int V;
    private int E;
    private int[] degree;

    public Graph() {
        Scanner sc = new Scanner(System.in);
        V = sc.nextInt();
        E = sc.nextInt();
        edges = new ArrayList<>();
        degree = new int[V];
        for (int i = 0; i < V; i++) {
            edges.add(new ArrayList<>());
        }
        for (int i = 0; i < E; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            edges.get(a).add(b);
            degree[a]++;
            edges.get(b).add(a);
            degree[b]++;
        }
        sc.close();
    }


    public Iterable<Integer> adj(int v) {
        return edges.get(v);
    }

    public int V() {
        return V;
    }

    public int E() {
        return E;
    }

    public int[] degree() {
        return degree;
    }

    // 复制一个edges列表传递
    public List<List<Integer>> getEdges() {
        List<List<Integer>> temp = new ArrayList<>();
        for (List<Integer> list : edges) {
            temp.add(new ArrayList<>(list));
        }
        return temp;
    }
}