【Lintcode】176. Route Between Two Nodes in Graph

题目地址：

https://www.lintcode.com/problem/route-between-two-nodes-in-graph/description

给定一个有向图，再给定两个顶点$s$和$t$，问是否存在从$s$到$t$的一条路径。

法1：BFS。直接从$s$到$t$一路搜过去即可。代码如下：

import java.util.*;

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(DirectedGraphNode s, DirectedGraphNode t) {
        // write your code here
        if (s == t) {
            return true;
        }
        
        Queue<DirectedGraphNode> queue = new LinkedList<>();
        Set<DirectedGraphNode> visited = new HashSet<>();
        queue.offer(s);
        visited.add(s);
        
        while (!queue.isEmpty()) {
            DirectedGraphNode begin = queue.poll();
            for (DirectedGraphNode neighbor : begin.neighbors) {
                if (neighbor == t) {
                    return true;
                }
                
                if (visited.add(neighbor)) {
                    queue.offer(neighbor);
                }
            }
        }
        
        return false;
    }
}

class DirectedGraphNode {
    int label;
    List<DirectedGraphNode> neighbors;
    DirectedGraphNode(int x) {
        label = x;
        neighbors = new ArrayList<>();
    }
}

时间复杂度$O(V+E)$，空间$O(V)$。

法2：DFS。也是直接套用图的DFS模板。代码如下：

import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Solution {
    public boolean hasRoute(DirectedGraphNode s, DirectedGraphNode t) {
        // write your code here
        return dfs(s, t, new HashSet<>());
    }
    
    private boolean dfs(DirectedGraphNode s, DirectedGraphNode t, Set<DirectedGraphNode> visited) {
        if (s == t) {
            return true;
        }
        
        visited.add(s);
        // 遍历s的所有邻居节点，如果某个邻居节点能到t，则返回true
        for (DirectedGraphNode neighbor : s.neighbors) {
            if (!visited.contains(neighbor) && dfs(neighbor, t, visited)) {
                return true;
            }
        }
        
        // 否则说明s的所有邻居都到不了t，就返回false
        return false;
    }
}

时间复杂度$O(V+E)$，空间$O(V)$。