寻找图中是否存在路径
原题
有一个具有 n
个顶点的 双向 图,其中每个顶点标记从 0
到 n - 1
(包含 0
和 n - 1
)。图中的边用一个二维整数数组 edges
表示,其中 edges[i] = [ui, vi]
表示顶点 ui
和顶点 vi
之间的双向边。 每个顶点对由 最多一条 边连接,并且没有顶点存在与自身相连的边。
请你确定是否存在从顶点 source
开始,到顶点 destination
结束的 有效路径。
给你数组 edges
和整数 n
、source
和 destination
,如果从 source
到 destination
存在 有效路径 ,则返回 true
,否则返回 false
。
示例 1:(图片转存自LeetCode)
输入:n = 3, edges = [[0,1],[1,2],[2,0]], source = 0, destination = 2
输出:true
解释:存在由顶点 0 到顶点 2 的路径:
- 0 → 1 → 2
- 0 → 2
示例 2:
输入:n = 6, edges = [[0,1],[0,2],[3,5],[5,4],[4,3]], source = 0, destination = 5
输出:false
解释:不存在由顶点 0 到顶点 5 的路径.
提示:
1 <= n <= 2 * 105
0 <= edges.length <= 2 * 105
edges[i].length == 2
0 <= ui, vi <= n - 1
ui != vi
0 <= source, destination <= n - 1
- 不存在重复边
- 不存在指向顶点自身的边
Java
class Solution {
public boolean validPath(int n, int[][] edges, int source, int destination) {
}
}
解题思路
- 将图的边列表(二维整数数组
edges
)转化为图的邻接表形式,以便快速访问每个节点的相邻节点信息。由于节点编号从0
到n-1
连续,故采用数组而非 HashMap 进行存储。 - 使用[[深度优先搜索]]递归地进行图的遍历。在遍历过程中,需要避免重复访问已经访问过的节点,因此使用一个
visited
数组来记录哪些节点已经被访问过。 - 终止条件:
- 如果在遍历过程中找到了
destination
,则可以立即返回true
,表示路径存在。 - 如果遍历了所有可能的路径都没有找到
destination
,则返回false
,表示路径不存在。
- 如果在遍历过程中找到了
代码示例
Java
class Solution {
public boolean validPath(int n, int[][] edges, int source, int destination) {
// 如果起点和终点是同一个点,直接返回 true
if (source == destination) return true;
// 构建邻接表,用数组表示图
List<Integer>[] graph = new ArrayList[n];
for (int i = 0; i < n; i ++) {
graph[i] = new ArrayList<>();
}
// 填充邻接表
for (int[] edge : edges) {
int fromNode = edge[0];
int toNode = edge[1];
graph[fromNode].add(toNode);
graph[toNode].add(fromNode);
}
// 创建访问标记数组
boolean[] visited = new boolean[n];
// 使用 DFS 检查是否存在从 source 到 destination 的路径
return dfs(graph, visited, source, destination);
}
private boolean dfs(List<Integer>[] graph, boolean[] visited, int node, int destination) {
// 如果当前节点是目标节点,返回 true
if (node == destination) return true;
// 标记当前节点为已访问
visited[node] = true;
// 遍历所有相邻节点
for (int neighbor : graph[node]) {
// 如果相邻节点没有访问过,进行递归 DFS
if (!visited[neighbor]) {
if (dfs(graph, visited, neighbor, destination)) {
// 找到能到达终点的路径就返回 true
return true;
}
}
}
// 所有路径都不能到达终点,返回 false
return false;
}
}
优化思路
这是一个经典的并查集问题。通过并查集的数据结构,可以高效地判断两个节点是否连通。每次将两个节点的根节点连接在一起,最终只需检查 source
和 destination
是否有相同的根节点即可。
优化后代码
Java
class Solution {
private int[] parent;
private int[] rank; // 树的高度数组
public boolean validPath(int n, int[][] edges, int source, int destination) {
parent = new int[n];
rank = new int[n];
// 初始化并查集:每个节点的父节点为自己,rank 初始化为 1
for (int i = 0; i < n; i++) {
parent[i] = i;
rank[i] = 1;
}
// 遍历所有边,将两个节点连接(即在并查集中合并)
for (int[] edge : edges) {
union(edge[0], edge[1]);
}
// 检查起始节点和目标节点是否在同一集合中
return find(source) == find(destination);
}
// 查找某个节点的根节点,同时进行路径压缩
private int find(int x) {
if (parent[x] != x) { // 如果当前节点不是它自己的父节点,则继续向上查找
parent[x] = find(parent[x]);
}
return parent[x];
}
// 合并两个集合,使用 rank 优化合并
private void union(int x, int y) {
int rootX = find(x);
int rootY = find(y);
if (rootX != rootY) {
// 比较两个集合的 rank,rank 小的合并到大的上
if (rank[rootX] > rank[rootY]) {
parent[rootY] = rootX; // 将 y 的根节点挂到 x 的根节点上
} else if (rank[rootX] < rank[rootY]) {
parent[rootX] = rootY; // 将 x 的根节点挂到 y 的根节点上
} else {
parent[rootY] = rootX; // 如果 rank 相同,随意合并,但要增加新根的 rank
rank[rootX]++;
}
}
}
}