This page explains Java solution to problem `Graph Connectivity With Threshold`

using `Union And Find`

algorithm.

We have `n`

cities labeled from `1`

to `n`

. Two different cities with labels `x`

and `y`

are directly connected by a bidirectional road if and only if `x`

and `y`

share a common divisor strictly greater than some threshold. More formally, cities with labels `x`

and `y`

have a road between them if there exists an integer `z`

such that all of the following are true:

`x % z == 0`

,`y % z == 0`

, and`z > threshold`

.

Given the two integers, `n`

and threshold, and an array of queries, you must determine for each `queries[i] = [ai, bi]`

if cities `ai`

and `bi`

are connected (i.e. there is some path between them).

Return an array answer, where `answer.length == queries.length`

and `answer[i]`

is `true`

if for the `i`

query, there is a path between ^{th}`ai`

and `bi`

, or `answer[i]`

is `false`

if there is no path.

Input: n = 6, threshold = 2, queries = [[1,4],[2,5],[3,6]]Output: [false,false,true]Explanation: The divisors for each number:

1: 1

2: 1, 2

3: 1, 3

4: 1, 2, 4

5: 1, 5

6: 1, 2, 3, 6

Using the underlined divisors above the threshold, only cities 3 and 6 share a common divisor, so they are the

only ones directly connected. The result of each query:

[1,4] 1 is not connected to 4

[2,5] 2 is not connected to 5

[3,6] 3 is connected to 6 through path 3--6

Input: n = 6, threshold = 0, queries = [[4,5],[3,4],[3,2],[2,6],[1,3]]Output: [true,true,true,true,true]

Input: n = 5, threshold = 1, queries = [[4,5],[4,5],[3,2],[2,3],[3,4]]Output: [false,false,false,false,false]

```
package com.vc.hard;
import java.util.ArrayList;
import java.util.List;
class GraphConnectivityWithThreshold {
public List<Boolean> areConnected(int n, int threshold, int[][] queries) {
if(queries == null) return new ArrayList<>();
int[] parent = new int[n + 1];
for(int i = 0; i <= n; i++) parent[i] = i;
for(int i = threshold + 1; i <= n; i++) {
for(int j = i; j <= n; j+=i) {
int iParent = find(i, parent);
int jParent = find(j, parent);
parent[iParent] = jParent;
}
}
List<Boolean> res = new ArrayList<>();
for(int[] query: queries) {
int xParent = find(query[0], parent);
int yParent = find(query[1], parent);
res.add(xParent == yParent);
}
return res;
}
private int find(int x, int[] parent) {
if(x == parent[x]) return x;
else {
parent[x] = find(parent[x], parent);
return parent[x];
}
}
}
```

O(N log N + Q) Where

N is total number of cities

Q is total number of queries

O(N + Q) Where

N is total number of cities

Q is total number of queries