Lintcode: Route Between Two Nodes in Graph

Given a directed graph, design an algorithm to find out whether there is a route between two nodes.

Have you met this question in a real interview? Yes
Example
Given graph:

A----->B----->C
      |
      |
      |
      v
     ->D----->E
for s = B and t = E, return true

for s = D and t = C, return false

DFS:

/**
 * Definition for Directed graph.
 * class DirectedGraphNode {
 *     int label;
 *     ArrayList<DirectedGraphNode> neighbors;
 *     DirectedGraphNode(int x) {
 *         label = x;
 *         neighbors = new ArrayList<DirectedGraphNode>();
 *     }
 * };
 */
public class Solution {
   /**
     * @param graph: A list of Directed graph node
     * @param s: the starting Directed graph node
     * @param t: the terminal Directed graph node
     * @return: a boolean value
     */
    public boolean hasRoute(ArrayList<DirectedGraphNode> graph, 
                            DirectedGraphNode s, DirectedGraphNode t) {
        // write your code here
        HashSet<DirectedGraphNode> visited = new HashSet<DirectedGraphNode>();
　　　　　　　visited.add(s);
        return dfs(s, t, visited);
    }
    
    public boolean dfs(DirectedGraphNode s, DirectedGraphNode t, HashSet<DirectedGraphNode> visited) {
        if (s == t) return true;
        for (DirectedGraphNode neighbor : s.neighbors) {
            if (!visited.contains(neighbor)) {
                visited.add(s);
                if (dfs(neighbor, t, visited))
                    return true;
            }
        }
        return false;
    }
}

BFS:

public class Solution {
   /**
     * @param graph: A list of Directed graph node
     * @param s: the starting Directed graph node
     * @param t: the terminal Directed graph node
     * @return: a boolean value
     */
    public boolean hasRoute(ArrayList<DirectedGraphNode> graph, 
                            DirectedGraphNode s, DirectedGraphNode t) {
        // write your code here
        HashSet<DirectedGraphNode> visited = new HashSet<DirectedGraphNode>();
        LinkedList<DirectedGraphNode> queue = new LinkedList<DirectedGraphNode>();
        if (s == t) return true;
        queue.offer(s);
        visited.add(s);
        while (!queue.isEmpty()) {
            DirectedGraphNode cur = queue.poll();
            for (DirectedGraphNode neighbor : cur.neighbors) {
                if (neighbor == t) return true;
                if (visited.contains(neighbor)) continue;
                visited.add(neighbor);
                queue.offer(neighbor);
            }
        }
        return false;
    }
}