LeetCode 1697. Checking Existence of Edge Length Limited Paths Solution in Java, C++, Python & More | Explanation + Code

Description

An undirected graph of n nodes is defined by edgeList, where edgeList[i] = [ui, vi, disi] denotes an edge between nodes ui and vi with distance disi. Note that there may be multiple edges between two nodes.

Given an array queries, where queries[j] = [pj, qj, limitj], your task is to determine for each queries[j] whether there is a path between pj and qj such that each edge on the path has a distance strictly less than limitj .

Return a boolean array answer, where answer.length == queries.length and the jth value of answer is true if there is a path for queries[j] is true, and false otherwise.

 

Example 1:

Input: n = 3, edgeList = [[0,1,2],[1,2,4],[2,0,8],[1,0,16]], queries = [[0,1,2],[0,2,5]]
Output: [false,true]
Explanation: The above figure shows the given graph. Note that there are two overlapping edges between 0 and 1 with distances 2 and 16.
For the first query, between 0 and 1 there is no path where each distance is less than 2, thus we return false for this query.
For the second query, there is a path (0 -> 1 -> 2) of two edges with distances less than 5, thus we return true for this query.

Example 2:

Input: n = 5, edgeList = [[0,1,10],[1,2,5],[2,3,9],[3,4,13]], queries = [[0,4,14],[1,4,13]]
Output: [true,false]
Explanation: The above figure shows the given graph.

 

Constraints:

• 2 <= n <= 105
• 1 <= edgeList.length, queries.length <= 105
• edgeList[i].length == 3
• queries[j].length == 3
• 0 <= ui, vi, pj, qj <= n - 1
• ui != vi
• pj != qj
• 1 <= disi, limitj <= 109
• There may be multiple edges between two nodes.

Solutions

Solution 1: Offline Queries + Union-Find

According to the problem requirements, we need to judge each query queries[i], that is, to determine whether there is a path with edge weight less than or equal to limit between the two points a and b of the current query.

The connectivity of two points can be determined by a union-find set. Moreover, since the order of queries does not affect the result, we can sort all queries in ascending order by limit, and also sort all edges in ascending order by edge weight.

Then for each query, we start from the edge with the smallest weight, add all edges with weights strictly less than limit to the union-find set, and then use the query operation of the union-find set to determine whether the two points are connected.

The time complexity is O(m × log m + q × log q), where m and q are the number of edges and queries, respectively.

Union-Find is a tree-like data structure that, as the name suggests, is used to handle some disjoint set merge and query problems. It supports two operations:

1. Find: Determine which subset an element belongs to. The time complexity of a single operation is O(α(n)).
2. Union: Merge two subsets into one set. The time complexity of a single operation is O(α(n)).

Here, α is the inverse Ackermann function, which grows extremely slowly. In other words, the average running time of its single operation can be considered a very small constant.

Below is a common template for Union-Find, which needs to be mastered proficiently. Where:

• n represents the number of nodes.
• p stores the parent node of each point. Initially, the parent node of each point is itself.
• size only makes sense when the node is an ancestor node, indicating the number of points in the set where the ancestor node is located.
• find(x) function is used to find the ancestor node of the set where x is located.
• union(a, b) function is used to merge the sets where a and b are located.

PythonJavaC++GoRustPythonJavaC++Go

class Solution: def distanceLimitedPathsExist( self, n: int, edgeList: List[List[int]], queries: List[List[int]] ) -> List[bool]: def find(x): if p[x] != x: p[x] = find(p[x]) return p[x] p = list(range(n)) edgeList.sort(key=lambda x: x[2]) j = 0 ans = [False] * len(queries) for i, (a, b, limit) in sorted(enumerate(queries), key=lambda x: x[1][2]): while j < len(edgeList) and edgeList[j][2] < limit: u, v, _ = edgeList[j] p[find(u)] = find(v) j += 1 ans[i] = find(a) == find(b) return ans(code-box)

class Solution { private int[] p; public boolean[] distanceLimitedPathsExist(int n, int[][] edgeList, int[][] queries) { p = new int[n]; for (int i = 0; i < n; ++i) { p[i] = i; } Arrays.sort(edgeList, (a, b) -> a[2] - b[2]); int m = queries.length; boolean[] ans = new boolean[m]; Integer[] qid = new Integer[m]; for (int i = 0; i < m; ++i) { qid[i] = i; } Arrays.sort(qid, (i, j) -> queries[i][2] - queries[j][2]); int j = 0; for (int i : qid) { int a = queries[i][0], b = queries[i][1], limit = queries[i][2]; while (j < edgeList.length && edgeList[j][2] < limit) { int u = edgeList[j][0], v = edgeList[j][1]; p[find(u)] = find(v); ++j; } ans[i] = find(a) == find(b); } return ans; } private int find(int x) { if (p[x] != x) { p[x] = find(p[x]); } return p[x]; } }(code-box)

class Solution { public: vector<bool> distanceLimitedPathsExist(int n, vector<vector<int>>& edgeList, vector<vector<int>>& queries) { vector<int> p(n); iota(p.begin(), p.end(), 0); sort(edgeList.begin(), edgeList.end(), [](auto& a, auto& b) { return a[2] < b[2]; }); function<int(int)> find = [&](int x) -> int { if (p[x] != x) p[x] = find(p[x]); return p[x]; }; int m = queries.size(); vector<bool> ans(m); vector<int> qid(m); iota(qid.begin(), qid.end(), 0); sort(qid.begin(), qid.end(), [&](int i, int j) { return queries[i][2] < queries[j][2]; }); int j = 0; for (int i : qid) { int a = queries[i][0], b = queries[i][1], limit = queries[i][2]; while (j < edgeList.size() && edgeList[j][2] < limit) { int u = edgeList[j][0], v = edgeList[j][1]; p[find(u)] = find(v); ++j; } ans[i] = find(a) == find(b); } return ans; } };(code-box)

func distanceLimitedPathsExist(n int, edgeList [][]int, queries [][]int) []bool { p := make([]int, n) for i := range p { p[i] = i } sort.Slice(edgeList, func(i, j int) bool { return edgeList[i][2] < edgeList[j][2] }) var find func(int) int find = func(x int) int { if p[x] != x { p[x] = find(p[x]) } return p[x] } m := len(queries) qid := make([]int, m) ans := make([]bool, m) for i := range qid { qid[i] = i } sort.Slice(qid, func(i, j int) bool { return queries[qid[i]][2] < queries[qid[j]][2] }) j := 0 for _, i := range qid { a, b, limit := queries[i][0], queries[i][1], queries[i][2] for j < len(edgeList) && edgeList[j][2] < limit { u, v := edgeList[j][0], edgeList[j][1] p[find(u)] = find(v) j++ } ans[i] = find(a) == find(b) } return ans }(code-box)

impl Solution { #[allow(dead_code)] pub fn distance_limited_paths_exist( n: i32, edge_list: Vec<Vec<i32>>, queries: Vec<Vec<i32>>, ) -> Vec<bool> { let mut disjoint_set: Vec<usize> = vec![0; n as usize]; let mut ans_vec: Vec<bool> = vec![false; queries.len()]; let mut q_vec: Vec<usize> = vec![0; queries.len()]; // Initialize the set for i in 0..n { disjoint_set[i as usize] = i as usize; } // Initialize the q_vec for i in 0..queries.len() { q_vec[i] = i; } // Sort the q_vec based on the query limit, from the lowest to highest q_vec.sort_by(|i, j| queries[*i][2].cmp(&queries[*j][2])); // Sort the edge_list based on the edge weight, from the lowest to highest let mut edge_list = edge_list.clone(); edge_list.sort_by(|i, j| i[2].cmp(&j[2])); let mut edge_idx: usize = 0; for q_idx in &q_vec { let s = queries[*q_idx][0] as usize; let d = queries[*q_idx][1] as usize; let limit = queries[*q_idx][2]; // Construct the disjoint set while edge_idx < edge_list.len() && edge_list[edge_idx][2] < limit { Solution::union( edge_list[edge_idx][0] as usize, edge_list[edge_idx][1] as usize, &mut disjoint_set, ); edge_idx += 1; } // If the parents of s & d are the same, this query should be `true` // Otherwise, the current query is `false` ans_vec[*q_idx] = Solution::check_valid(s, d, &mut disjoint_set); } ans_vec } #[allow(dead_code)] pub fn find(x: usize, d_set: &mut Vec<usize>) -> usize { if d_set[x] != x { d_set[x] = Solution::find(d_set[x], d_set); } return d_set[x]; } #[allow(dead_code)] pub fn union(s: usize, d: usize, d_set: &mut Vec<usize>) { let p_s = Solution::find(s, d_set); let p_d = Solution::find(d, d_set); d_set[p_s] = p_d; } #[allow(dead_code)] pub fn check_valid(s: usize, d: usize, d_set: &mut Vec<usize>) -> bool { let p_s = Solution::find(s, d_set); let p_d = Solution::find(d, d_set); p_s == p_d } }(code-box)

p = list(range(n)) size = [1] * n def find(x): if p[x] != x: p[x] = find(p[x]) return p[x] def union(a, b): pa, pb = find(a), find(b) if pa == pb: return p[pa] = pb size[pb] += size[pa](code-box)

int[] p = new int[n]; int[] size = new int[n]; for (int i = 0; i < n; ++i) { p[i] = i; size[i] = 1; } int find(int x) { if (p[x] != x) { p[x] = find(p[x]); } return p[x]; } void union(int a, int b) { int pa = find(a), pb = find(b); if (pa == pb) { return; } p[pa] = pb; size[pb] += size[pa]; }(code-box)

vector<int> p(n); iota(p.begin(), p.end(), 0); vector<int> size(n, 1); int find(int x) { if (p[x] != x) { p[x] = find(p[x]); } return p[x]; } void unite(int a, int b) { int pa = find(a), pb = find(b); if (pa == pb) return; p[pa] = pb; size[pb] += size[pa]; }(code-box)

p := make([]int, n) size := make([]int, n) for i := range p { p[i] = i size[i] = 1 } func find(x int) int { if p[x] != x { p[x] = find(p[x]) } return p[x] } func union(a, b int) { pa, pb := find(a), find(b) if pa == pb { return } p[pa] = pb size[pb] += size[pa] }(code-box)