Depth-First Search (I)

 

1. Eulerian Path

　　This is my solution to the USACO training problem "fence", which requires to find a Eulerian Path from a given undirected graph. To store the path of a DFS traversal, we can avail ourselves of the Stack generated by dfs recursive function and another Stack we create such that the two Stacks will constitute a Queue, where the finishing order of the visit can be maintained.

import java.io.*;
import java.util.*;

public class fence {
    public static final int NUM = 500;
    public static Scanner input;
    public static PrintWriter output;
    public static Stack<Integer> path;
    public static int [][] adjMat;
    
    public static void dfs(int pos) {
        for (int i=0;i<NUM;i++) {
            if (adjMat[i][pos]>0) {
                adjMat[i][pos]--;
                adjMat[pos][i]--;
                dfs(i);
            }
        }
        // two Stacks constitute a Queue
        path.push(pos);
    }
    public static void genEulerPath() {
        path = new Stack<Integer>();
        int start = 0;
        for (int i=0;i<NUM;i++) {
            int cnt = 0;
            for (int j=0;j<NUM;j++) {
                cnt += adjMat[i][j];
            }
            if ((cnt&1)==1) {
                start = i;
                break;
            }
        }
        dfs(start);
        while (!path.isEmpty()) {
            // Print the Eulerian Path:
            output.println(path.pop().intValue()+1);
        }
    }
    public static void main(String[] args) throws IOException {
        adjMat = new int [NUM][NUM];
        input = new Scanner(new FileReader("fence.in"));
        int edge = input.nextInt();
        for (int i=0;i<edge;i++) {
            int p = input.nextInt()-1;
            int r = input.nextInt()-1;
            adjMat[p][r]++;
            adjMat[r][p]++;
        }
        input.close();
        output = new PrintWriter(new FileWriter("fence.out"));
        genEulerPath();
        output.close();
    }
}

 

2. SCC and Linearization

　　As it turns out, a directed graph can always be looked at as a DAG of its Strongly Connected Components, such that we can print those components in a Topological Order. My following code is aimed to shed light on how to do this work:

import java.util.*;

class AdjList {
    // Adjacency List Class:
    private class Vert {
        public int end; 
        public Vert next;
    }
    
    private int num;
    private Vert[] vert;
    
    public AdjList(int num) {
        // Generate num vertices:
        this.num = num;
        vert = new Vert[num];
        for (int i=0;i<num;i++) {
            vert[i] = new Vert();
        }
    }
    public void insEdge(int p,int r) {
        // Insert a directed edge to the graph:
        Vert v = new Vert();
        v.next = vert[p].next;
        v.end = r;
        vert[p].next = v;
    }
    public AdjList transpose() {
        // Generated a transpose graph:
        AdjList g = new AdjList(num);
        for (int i=0;i<num;i++) {
            Vert itr = vert[i].next;
            while (itr!=null) {
                g.insEdge(itr.end,i);
                itr = itr.next;
            }
        }
        return g;
    }
    private void dfs(int src,boolean[] vis,Stack<Integer> path) {
        // Depth-First Search in a directed graph:
        vis[src] = true;
        Vert itr = vert[src].next;
        while (itr!=null) {
            if (!vis[itr.end]) {
                dfs(itr.end,vis,path);
            }
            itr = itr.next;
        }
        // two Stacks constitute a Queue
        path.push(src);
    }
    public void solveSCC() {
        // Determine all the Strongly Connected Components
        //        and print them in a Topological order:
        boolean[] vis = new boolean[num];
        Stack<Integer> postVis = new Stack<Integer>();
        for (int i=0;i<num;i++) {
            // do DFS in the original graph in index order
            if (!vis[i]) {
                dfs(i,vis,postVis);
            }
        }
        AdjList g = transpose();
        for (int i=0;i<num;i++) {
            vis[i] = false;
        }
        Queue<Stack<Integer>> q = new LinkedList<Stack<Integer>>();
        while (!postVis.isEmpty()) {
            // do DFS in the transpose graph, and the order is determined
            //            by the finishing time of the previous DFS
            int i = postVis.pop();
            if (!vis[i]) {
                Stack<Integer> comp = new Stack<Integer>();
                g.dfs(i,vis,comp);
                q.add(comp);    // linearization
            }
        }
        int cnt = 0;
        while (!q.isEmpty()) {
            // in the second DFS loop, a SCC c1 will always come into being before
            //        another SCC c2 if c1 has a  path towards c2
            System.out.print("Component "+(++cnt)+": ");
            Stack<Integer> stack = q.poll();
            while (!stack.isEmpty()) {
                System.out.print(stack.pop().intValue()+1+" ");
            }
            System.out.println();
        }
    }
}

public class SCC {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("Vertex Number:");
        AdjList g = new AdjList(in.nextInt());
        System.out.println("Edge Number:");
        int edgeNum = in.nextInt();
        System.out.println("List Edges:");
        for (int i=0;i<edgeNum;i++) {
            g.insEdge(in.nextInt()-1,in.nextInt()-1);
        }
        in.close();
        g.solveSCC();
    }
}

　　Sample Input and Output:

　　　　　

References:

　　1. Cormen, T. H. et al. Introduction to Algorithms [M] .  北京：机械工业出版社, 2006-09

　　2. Dasgupta, Sanjoy, Christos Papadimitriou, and Umesh Vazirani. Algorithms[M].北京：机械工业出版社，2009-01-01