Question

1697. Checking Existence of Edge Length Limited Paths

中文文档

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 \times \log m + q \times \log q)$, where $m$ and $q$ are the number of edges and queries, respectively.

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

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];
  }
}

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;
  }
};

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
}

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
  }
}

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(\alpha(n))$.
2. Union: Merge two subsets into one set. The time complexity of a single operation is $O(\alpha(n))$.

Here, $\alpha$ 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.

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]

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];
}

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];
}

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]
}